@microsoft/live-share-media 1.0.1 → 1.1.0

package/src/MediaPlayerSynchronizer.ts

@@ -2,7 +2,11 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the Microsoft Live Share SDK License.
  */
-import { LiveTelemetryLogger, ILiveEvent } from "@microsoft/live-share";
+import {
+    LiveTelemetryLogger,
+    ILiveEvent,
+    IRuntimeSignaler,
+} from "@microsoft/live-share";
 import EventEmitter from "events";
 import {
     ExtendedMediaSessionAction,
@@ -17,6 +21,7 @@ import { VolumeManager } from "./VolumeManager";
 import { LiveMediaSession } from "./LiveMediaSession";
 import { IMediaPlayer } from "./IMediaPlayer";
 import { TelemetryEvents } from "./internals";
+import { waitUntilConnected } from "@microsoft/live-share/bin/internals";
 
 /**
  * Event data returned by `MediaPlayerSynchronizer` object.
@@ -76,6 +81,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
     private _logger: LiveTelemetryLogger;
     private _player: IMediaPlayer;
     private _mediaSession: LiveMediaSession;
+    private _runtime: IRuntimeSignaler;
     private _volumeManager: VolumeManager;
     private _onEnd?: () => void;
     private _onPlayerEvent: EventListener;
@@ -94,11 +100,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
     constructor(
         player: IMediaPlayer,
         mediaSession: LiveMediaSession,
+        runtime: IRuntimeSignaler,
         onEnd: () => void
     ) {
         super();
         this._player = player;
         this._mediaSession = mediaSession;
+        this._runtime = runtime;
         this._logger = mediaSession.logger;
         this._volumeManager = new VolumeManager(player);
         this._onEnd = onEnd;
@@ -204,7 +212,9 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                     // needed because cannot tell if its a user initiated event, so disallow pause
                     if (
                         this._expectedPlaybackState === "playing" &&
-                        !this._mediaSession.coordinator.isSuspended
+                        !this._mediaSession.coordinator.isSuspended &&
+                        // some players have ended, but emit a pause event immediately before ended event. Do not play if ended
+                        !this._player.ended
                     ) {
                         this._player.play();
                     }
@@ -350,7 +360,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                         }
                     }
 
-                    this.dispatchGroupAction(details, false, error);
+                    this.dispatchGroupAction(details, error);
                 }
             );
         }
@@ -511,7 +521,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         );
         suspension.end(seekTo);
 
-        this.dispatchUserAction({ action: "seekto", seekTime: seekTo });
+        waitUntilConnected(this._runtime).then((clientId: string) => {
+            this.dispatchUserAction({
+                action: "seekto",
+                clientId,
+                seekTime: seekTo,
+            });
+        });
     }
 
     /**
@@ -530,7 +546,10 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._expectedPlaybackState = "playing";
         await this._mediaSession.coordinator.play();
 
-        this.dispatchUserAction({ action: "play" });
+        this.dispatchUserAction({
+            action: "play",
+            clientId: await waitUntilConnected(this._runtime),
+        });
     }
 
     /**
@@ -549,7 +568,10 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._expectedPlaybackState = "paused";
         await this._mediaSession.coordinator.pause();
 
-        this.dispatchUserAction({ action: "pause" });
+        this.dispatchUserAction({
+            action: "pause",
+            clientId: await waitUntilConnected(this._runtime),
+        });
     }
 
     /**
@@ -574,7 +596,11 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         );
         await this._mediaSession.coordinator.seekTo(time);
 
-        this.dispatchUserAction({ action: "seekto", seekTime: time });
+        this.dispatchUserAction({
+            action: "seekto",
+            clientId: await waitUntilConnected(this._runtime),
+            seekTime: time,
+        });
     }
 
     /**
@@ -595,7 +621,11 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         );
         await this._mediaSession.coordinator.setTrack(track, waitPoints);
 
-        this.dispatchUserAction({ action: "settrack", metadata: track });
+        this.dispatchUserAction({
+            action: "settrack",
+            clientId: await waitUntilConnected(this._runtime),
+            metadata: track,
+        });
     }
 
     /**
@@ -614,52 +644,32 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._trackData = data;
         await this._mediaSession.coordinator.setTrackData(data);
 
-        this.dispatchUserAction({ action: "datachange", data: data });
+        this.dispatchUserAction({
+            action: "datachange",
+            clientId: await waitUntilConnected(this._runtime),
+            data: data,
+        });
     }
 
+    // TODO: what is delay useful for? we do not use, delete?
     private dispatchGroupAction(
         details: ExtendedMediaSessionActionDetails,
-        delay = false,
         error: Error | undefined
     ): void {
-        if (delay) {
-            setTimeout(
-                () =>
-                    this.emit(MediaPlayerSynchronizerEvents.groupaction, {
-                        type: MediaPlayerSynchronizerEvents.groupaction,
-                        details: details,
-                        playerError: error,
-                    }),
-                50
-            );
-        } else {
-            this.emit(MediaPlayerSynchronizerEvents.groupaction, {
-                type: MediaPlayerSynchronizerEvents.groupaction,
-                details: details,
-                error,
-            });
-        }
+        this.emit(MediaPlayerSynchronizerEvents.groupaction, {
+            type: MediaPlayerSynchronizerEvents.groupaction,
+            details: details,
+            error,
+        });
     }
 
     private dispatchUserAction(
-        details: ExtendedMediaSessionActionDetails,
-        delay = false
+        details: ExtendedMediaSessionActionDetails
     ): void {
-        if (delay) {
-            setTimeout(
-                () =>
-                    this.emit(MediaPlayerSynchronizerEvents.useraction, {
-                        type: MediaPlayerSynchronizerEvents.useraction,
-                        details: details,
-                    }),
-                50
-            );
-        } else {
-            this.emit(MediaPlayerSynchronizerEvents.useraction, {
-                type: MediaPlayerSynchronizerEvents.useraction,
-                details: details,
-            });
-        }
+        this.emit(MediaPlayerSynchronizerEvents.useraction, {
+            type: MediaPlayerSynchronizerEvents.useraction,
+            details: details,
+        });
     }
 
     private async catchupPlayer(time: number): Promise<void> {

package/src/MediaSessionActionThrottler.ts

@@ -3,14 +3,17 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { ExtendedMediaSessionActionDetails } from "./MediaSessionExtensions";
+import {
+    ExtendedMediaSessionActionDetails,
+    ExtendedMediaSessionActionHandler,
+} from "./MediaSessionExtensions";
 
 /**
  * Base class for action throttlers.
  */
 export abstract class MediaSessionActionThrottler {
     public abstract throttled(
-        details: ExtendedMediaSessionActionDetails,
-        handler?: MediaSessionActionHandler
+        details: MediaSessionActionDetails | ExtendedMediaSessionActionDetails,
+        handler?: MediaSessionActionHandler | ExtendedMediaSessionActionHandler
     ): void;
 }

package/src/MediaSessionExtensions.ts

@@ -42,6 +42,7 @@ export interface CoordinationWaitPoint {
 
 export interface ExtendedMediaSessionActionDetails {
     action: ExtendedMediaSessionAction;
+    clientId: string;
     fastSeek?: boolean | null;
     seekOffset?: number | null;
     seekTime?: number | null;
@@ -50,3 +51,7 @@ export interface ExtendedMediaSessionActionDetails {
     data?: object | null;
     blocked?: ExtendedMediaSessionAction | null;
 }
+
+export interface ExtendedMediaSessionActionHandler {
+    (details: ExtendedMediaSessionActionDetails): void;
+}

package/src/RepeatedActionThrottler.ts

@@ -33,7 +33,7 @@ export class RepeatedActionThrottler extends MediaSessionActionThrottler {
     }
 
     public throttled(
-        details: ExtendedMediaSessionActionDetails,
+        details: MediaSessionActionDetails | ExtendedMediaSessionActionDetails,
         handler?: MediaSessionActionHandler
     ): void {
         if (handler) {
@@ -63,7 +63,9 @@ export class RepeatedActionThrottler extends MediaSessionActionThrottler {
         }
     }
 
-    private getChangeKey(details: ExtendedMediaSessionActionDetails): string {
+    private getChangeKey(
+        details: MediaSessionActionDetails | ExtendedMediaSessionActionDetails
+    ): string {
         switch (details.action) {
             case "seekto":
                 return `seekto:${details.seekTime}`;

package/src/internals/GroupCoordinatorState.ts

@@ -36,6 +36,7 @@ import {
     IPlaybackTrackData,
 } from "./GroupPlaybackTrackData";
 import { TelemetryEvents } from "./consts";
+import { waitUntilConnected } from "@microsoft/live-share/bin/internals";
 
 /**
  * @hidden
@@ -149,7 +150,7 @@ export class GroupCoordinatorState extends EventEmitter {
                 this._logger.sendTelemetryEvent(
                     TelemetryEvents.GroupCoordinator.TrackChanged
                 );
-                this.emitSetTrack(evt.metadata!);
+                this.emitSetTrack(evt.clientId, evt.metadata!);
             } else {
                 this._logger.sendTelemetryEvent(
                     TelemetryEvents.GroupCoordinator.TrackChangeDelayed
@@ -168,6 +169,7 @@ export class GroupCoordinatorState extends EventEmitter {
                     this.emitTriggerAction({
                         action: "datachange",
                         data: evt.data,
+                        clientId: evt.clientId,
                     });
                 } else {
                     this._logger.sendTelemetryEvent(
@@ -196,6 +198,7 @@ export class GroupCoordinatorState extends EventEmitter {
                         case "play":
                             this.emitTriggerAction({
                                 action: "play",
+                                clientId: evt.clientId,
                                 seekTime: evt.seekTime,
                             });
                             break;
@@ -203,6 +206,7 @@ export class GroupCoordinatorState extends EventEmitter {
                         case "pause":
                             this.emitTriggerAction({
                                 action: "pause",
+                                clientId: evt.clientId,
                                 seekTime: evt.seekTime,
                             });
                             break;
@@ -210,6 +214,7 @@ export class GroupCoordinatorState extends EventEmitter {
                         case "seekto":
                             this.emitTriggerAction({
                                 action: "seekto",
+                                clientId: evt.clientId,
                                 seekTime: evt.seekTime,
                             });
                             break;
@@ -431,7 +436,7 @@ export class GroupCoordinatorState extends EventEmitter {
     }
 
     public handlePositionUpdate(
-        event: Omit<ILiveEvent<IPositionUpdateEvent>, "name">,
+        event: ILiveEvent<IPositionUpdateEvent>,
         local: boolean
     ): void {
         // Ensure change is for current track
@@ -522,7 +527,10 @@ export class GroupCoordinatorState extends EventEmitter {
                 this._logger.sendTelemetryEvent(
                     TelemetryEvents.GroupCoordinator.TrackOutOfSync
                 );
-                this.emitSetTrack(this.playbackTrack.metadata!);
+                this.emitSetTrack(
+                    this.playbackTrack.current.clientId,
+                    this.playbackTrack.metadata!
+                );
                 return;
             }
 
@@ -560,6 +568,7 @@ export class GroupCoordinatorState extends EventEmitter {
                     );
                     await this.emitTriggerAction({
                         action: "catchup",
+                        clientId: await waitUntilConnected(this._runtime),
                         seekTime: target,
                     });
                 }
@@ -576,10 +585,16 @@ export class GroupCoordinatorState extends EventEmitter {
                     );
                     switch (this.transportState.playbackState) {
                         case "playing":
-                            await this.emitTriggerAction({ action: "play" });
+                            await this.emitTriggerAction({
+                                action: "play",
+                                clientId: this.transportState.current.clientId,
+                            });
                             break;
                         case "paused":
-                            await this.emitTriggerAction({ action: "pause" });
+                            await this.emitTriggerAction({
+                                action: "pause",
+                                clientId: this.transportState.current.clientId,
+                            });
                             break;
                     }
                 }
@@ -594,6 +609,7 @@ export class GroupCoordinatorState extends EventEmitter {
                     );
                     await this.emitTriggerAction({
                         action: "datachange",
+                        clientId: this.playbackTrackData.current.clientId,
                         data: this.playbackTrackData.data,
                     });
                 }
@@ -601,12 +617,19 @@ export class GroupCoordinatorState extends EventEmitter {
         }
     }
 
-    private emitSetTrack(metadata: ExtendedMediaMetadata): void {
+    private emitSetTrack(
+        clientId: string,
+        metadata: ExtendedMediaMetadata
+    ): void {
         // Reset tracking states
         this._waitPoint = undefined;
 
         // Trigger settrack action
-        this.emitTriggerAction({ action: "settrack", metadata: metadata });
+        this.emitTriggerAction({
+            action: "settrack",
+            clientId,
+            metadata,
+        });
     }
 
     private emitTriggerAction(

package/src/internals/GroupPlaybackTrack.ts

@@ -147,6 +147,7 @@ export class GroupPlaybackTrack extends EventEmitter {
         // Notify listeners
         this.emit(GroupPlaybackTrackEvents.trackChange, {
             name: GroupPlaybackTrackEvents.trackChange,
+            clientId: track.clientId,
             metadata: track.metadata,
         });
 

package/src/internals/GroupPlaybackTrackData.ts

@@ -90,6 +90,7 @@ export class GroupPlaybackTrackData extends EventEmitter {
         // Notify listeners
         this.emit(PlaybackTrackDataEvents.dataChange, {
             type: PlaybackTrackDataEvents.dataChange,
+            clientId: event.clientId,
             data: event.data,
         });
 

package/src/internals/GroupTransportState.ts

@@ -3,11 +3,7 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import {
-    ILiveEvent,
-    LiveShareRuntime,
-    LiveShareClient,
-} from "@microsoft/live-share";
+import { ILiveEvent, LiveShareRuntime } from "@microsoft/live-share";
 import EventEmitter from "events";
 import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
 import {
@@ -140,6 +136,7 @@ export class GroupTransportState extends EventEmitter {
             this.emit(GroupTransportStateEvents.transportStateChange, {
                 type: GroupTransportStateEvents.transportStateChange,
                 action: "seekto",
+                clientId: state.clientId,
                 seekTime: state.startPosition,
             });
         } else if (state.playbackState == "playing") {
@@ -149,12 +146,14 @@ export class GroupTransportState extends EventEmitter {
             this.emit(GroupTransportStateEvents.transportStateChange, {
                 type: GroupTransportStateEvents.transportStateChange,
                 action: "play",
+                clientId: state.clientId,
                 seekTime: projectedPosition,
             });
         } else {
             this.emit(GroupTransportStateEvents.transportStateChange, {
                 type: GroupTransportStateEvents.transportStateChange,
                 action: "pause",
+                clientId: state.clientId,
                 seekTime: state.startPosition,
             });
         }