@microsoft/live-share-media 1.0.0-preview.9 → 1.0.1

package/src/LiveMediaSessionCoordinator.ts

@@ -7,18 +7,15 @@ import {
     LiveEventScope,
     LiveTelemetryLogger,
     LiveEventTarget,
-    ILiveEvent,
     IRuntimeSignaler,
     TimeInterval,
     UserMeetingRole,
+    LiveShareRuntime,
 } from "@microsoft/live-share";
 import {
     CoordinationWaitPoint,
-    ExtendedMediaSessionActionDetails,
     ExtendedMediaMetadata,
     ExtendedMediaSessionPlaybackState,
-    MediaSessionCoordinatorEvents,
-    MediaSessionCoordinatorState,
     MediaSessionCoordinatorSuspension,
 } from "./MediaSessionExtensions";
 import {
@@ -28,7 +25,6 @@ import {
     IPositionUpdateEvent,
     GroupCoordinatorState,
     GroupCoordinatorStateEvents,
-    ITriggerActionEvent,
     ISetTrackDataEvent,
 } from "./internals";
 import { LiveMediaSessionCoordinatorSuspension } from "./LiveMediaSessionCoordinatorSuspension";
@@ -69,6 +65,7 @@ export interface IMediaPlayerState {
  */
 export class LiveMediaSessionCoordinator extends EventEmitter {
     private readonly _runtime: IRuntimeSignaler;
+    private readonly _liveRuntime: LiveShareRuntime;
     private readonly _logger: LiveTelemetryLogger;
     private readonly _getPlayerState: () => IMediaPlayerState;
     private _positionUpdateInterval = new TimeInterval(2000);
@@ -83,22 +80,26 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
     private _setTrackEvent?: LiveEventTarget<ISetTrackEvent>;
     private _setTrackDataEvent?: LiveEventTarget<ISetTrackDataEvent>;
     private _positionUpdateEvent?: LiveEventTarget<IPositionUpdateEvent>;
-    private _joinedEvent?: LiveEventTarget<ILiveEvent>;
+    private _joinedEvent?: LiveEventTarget<undefined>;
 
     // Distributed state
     private _groupState?: GroupCoordinatorState;
 
+    private _allowedRoles?: UserMeetingRole[];
+
     /**
      * @hidden
      * Applications shouldn't directly create new coordinator instances.
      */
     constructor(
         runtime: IRuntimeSignaler,
+        liveRuntime: LiveShareRuntime,
         getPlayerState: () => IMediaPlayerState
     ) {
         super();
         this._runtime = runtime;
-        this._logger = new LiveTelemetryLogger(runtime);
+        this._liveRuntime = liveRuntime;
+        this._logger = new LiveTelemetryLogger(runtime, liveRuntime);
         this._getPlayerState = getPlayerState;
     }
 
@@ -201,8 +202,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * @remarks
      * Throws an exception if the session/coordinator hasn't been initialized, no track has been
      * loaded, or `canPlayPause` is false.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public play(): void {
+    public async play(): Promise<void> {
         if (!this._hasInitialized) {
             throw new Error(
                 `LiveMediaSessionCoordinator.play() called before initialize() called.`
@@ -230,7 +233,7 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             null,
             { position: position }
         );
-        this._playEvent!.sendEvent({
+        await this._playEvent!.sendEvent({
             track: this._groupState.playbackTrack.current,
             position: position,
         });
@@ -242,8 +245,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * @remarks
      * Throws an exception if the session/coordinator hasn't been initialized, no track has been
      * loaded, or `canPlayPause` is false.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public pause(): void {
+    public async pause(): Promise<void> {
         if (!this._hasInitialized) {
             throw new Error(
                 `LiveMediaSessionCoordinator.pause() called before initialize() called.`
@@ -271,7 +276,7 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             null,
             { position: position }
         );
-        this._pauseEvent!.sendEvent({
+        await this._pauseEvent!.sendEvent({
             track: this._groupState.playbackTrack.current,
             position: position,
         });
@@ -284,8 +289,9 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * Throws an exception if the session/coordinator hasn't been initialized, no track has been
      * loaded, or `canSeek` is false.
      * @param time Playback position in seconds to seek to.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public seekTo(time: number): void {
+    public async seekTo(time: number): Promise<void> {
         if (!this._hasInitialized) {
             throw new Error(
                 `LiveMediaSessionCoordinator.seekTo() called before initialize() called.`
@@ -310,10 +316,15 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             null,
             { position: time }
         );
-        this._seekToEvent!.sendEvent({
-            track: this._groupState.playbackTrack.current,
-            position: time,
-        });
+        try {
+            await this._seekToEvent!.sendEvent({
+                track: this._groupState.playbackTrack.current,
+                position: time,
+            });
+        } catch (err) {
+            await this._groupState!.syncLocalMediaSession();
+            throw err;
+        }
     }
 
     /**
@@ -324,11 +335,12 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * false.
      * @param metadata The track to load or `null` to indicate that the end of the track is reached.
      * @param waitPoints Optional. List of static wait points to configure for the track.  Dynamic wait points can be added via the `beginSuspension()` call.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public setTrack(
+    public async setTrack(
         metadata: ExtendedMediaMetadata | null,
         waitPoints?: CoordinationWaitPoint[]
-    ): void {
+    ): Promise<void> {
         if (!this._hasInitialized) {
             throw new Error(
                 `LiveMediaSessionCoordinator.setTrack() called before initialize() called.`
@@ -345,7 +357,7 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.SessionCoordinator.SetTrackCalled
         );
-        this._setTrackEvent!.sendEvent({
+        await this._setTrackEvent!.sendEvent({
             metadata: metadata,
             waitPoints: waitPoints || [],
         });
@@ -361,8 +373,9 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * Throws an exception if the session/coordinator hasn't been initialized or `canSetTrackData` is
      * false.
      * @param data New data object to sync with the group. This value will be synchronized using a last writer wins strategy.
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public setTrackData(data: object | null): void {
+    public async setTrackData(data: object | null): Promise<void> {
         if (!this._hasInitialized) {
             throw new Error(
                 `LiveMediaSessionCoordinator.setTrackData() called before initialize() called.`
@@ -379,7 +392,7 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.SessionCoordinator.SetTrackDataCalled
         );
-        this._setTrackDataEvent!.sendEvent({
+        await this._setTrackDataEvent!.sendEvent({
             data: data,
         });
     }
@@ -520,23 +533,51 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
         }
 
         // Send position update event
-        const evt = this._groupState!.createPositionUpdateEvent(state);
-        this._positionUpdateEvent?.sendEvent(evt);
+        this.verifyLocalUserRoles()
+            .then((valid) => {
+                const evt = this._groupState!.createPositionUpdateEvent(state);
+                if (!valid) {
+                    // We still need to update _groupState with the local user's position.
+                    // So we do this here rather than on the receiving end.
+                    this._groupState!.handlePositionUpdate(
+                        {
+                            clientId: this._runtime.clientId ?? "",
+                            timestamp: this._liveRuntime.getTimestamp(),
+                            data: evt,
+                        },
+                        true
+                    );
+                    return;
+                }
+                return this._positionUpdateEvent?.sendEvent(evt);
+            })
+            .catch((err) => {
+                this._logger.sendErrorEvent(
+                    TelemetryEvents.SessionCoordinator.PositionUpdateEventError,
+                    err
+                );
+            });
     }
 
     protected async createChildren(
         acceptTransportChangesFrom?: UserMeetingRole[]
     ): Promise<void> {
+        this._allowedRoles = acceptTransportChangesFrom;
         // Create event scopes
         const scope = new LiveEventScope(
             this._runtime,
+            this._liveRuntime,
             acceptTransportChangesFrom
         );
-        const unrestrictedScope = new LiveEventScope(this._runtime);
+        const unrestrictedScope = new LiveEventScope(
+            this._runtime,
+            this._liveRuntime
+        );
 
         // Initialize internal coordinator state
         this._groupState = new GroupCoordinatorState(
             this._runtime,
+            this._liveRuntime,
             this._maxPlaybackDrift,
             this._positionUpdateInterval,
             this._getPlayerState
@@ -596,14 +637,22 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
                     }
                 );
                 const state = this._getPlayerState();
-                const update =
-                    this._groupState!.createPositionUpdateEvent(state);
-                this._positionUpdateEvent?.sendEvent(update);
+                this.sendPositionUpdate(state);
             }
         );
 
-        // Send initial joined event
-        this._joinedEvent.sendEvent({});
+        this.verifyLocalUserRoles()
+            .then((verified) => {
+                if (!verified) return;
+                // Send initial joined event
+                return this._joinedEvent?.sendEvent(undefined);
+            })
+            .catch((err) => {
+                this._logger.sendErrorEvent(
+                    TelemetryEvents.SessionCoordinator.SendJoinedEventError,
+                    err
+                );
+            });
     }
 
     private getPlayerPosition(): number {
@@ -618,4 +667,27 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
                     : 0.0;
         }
     }
+
+    private async verifyLocalUserRoles(): Promise<boolean> {
+        const clientId = await this.waitUntilConnected();
+        return this._liveRuntime.verifyRolesAllowed(
+            clientId,
+            this._allowedRoles ?? []
+        );
+    }
+
+    private waitUntilConnected(): Promise<string> {
+        return new Promise((resolve) => {
+            const onConnected = (clientId: string) => {
+                this._runtime.off("connected", onConnected);
+                resolve(clientId);
+            };
+
+            if (this._runtime.clientId && this._runtime.connected) {
+                resolve(this._runtime.clientId);
+            } else {
+                this._runtime.on("connected", onConnected);
+            }
+        });
+    }
 }

package/src/MediaPlayerSynchronizer.ts

@@ -2,7 +2,7 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the Microsoft Live Share SDK License.
  */
-import { LiveTelemetryLogger, IEvent } from "@microsoft/live-share";
+import { LiveTelemetryLogger, ILiveEvent } from "@microsoft/live-share";
 import EventEmitter from "events";
 import {
     ExtendedMediaSessionAction,
@@ -21,7 +21,7 @@ import { TelemetryEvents } from "./internals";
 /**
  * Event data returned by `MediaPlayerSynchronizer` object.
  */
-export interface IMediaPlayerSynchronizerEvent extends IEvent {
+export interface IMediaPlayerSynchronizerEvent extends ILiveEvent {
     /**
      * Event details.
      */
@@ -82,6 +82,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
     private _seekSuspension?: MediaSessionCoordinatorSuspension;
     private _viewOnly = false;
     private _expectedPlaybackState: ExtendedMediaSessionPlaybackState = "none";
+    private _metadata: ExtendedMediaMetadata | null = null;
     private _trackData: object | null = null;
 
     /**
@@ -120,8 +121,15 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                 playbackState = "playing";
             }
 
+            // Metadata equality check in `GroupPlaybackTrack` would return false if only providing src.
+            // Use full metadata if this._metadata has same src
+            const metadata =
+                this._metadata && this._metadata.trackIdentifier === src
+                    ? this._metadata
+                    : ({ trackIdentifier: src } as ExtendedMediaMetadata);
+
             const state = {
-                metadata: { trackIdentifier: src } as ExtendedMediaMetadata,
+                metadata: metadata,
                 playbackState: playbackState,
                 positionState: {
                     position: this._player.currentTime,
@@ -164,7 +172,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                                 TelemetryEvents.MediaPlayerSynchronizer
                                     .UserTappedVideoToPlay
                             );
-                            this.play();
+                            this.play().catch((err) => {
+                                this._logger.sendErrorEvent(
+                                    TelemetryEvents.MediaPlayerSynchronizer
+                                        .UserTappedVideoToPlayError,
+                                    err
+                                );
+                            });
                         }
                     }
                     // block play if player state is playing when expected synced state is paused and coordinator is not suspended.
@@ -295,6 +309,14 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                                         .SetTrackAction
                                 );
                                 this._expectedPlaybackState = "none";
+                                this._metadata = details.metadata ?? null;
+                                if (
+                                    this._player.src ===
+                                    details.metadata?.trackIdentifier
+                                ) {
+                                    // Don't set duplicate src and load again.
+                                    break;
+                                }
                                 this._player.src =
                                     details.metadata!.trackIdentifier;
                                 this._player.load();
@@ -498,13 +520,15 @@ export class MediaPlayerSynchronizer extends EventEmitter {
      * @remarks
      * For proper operation apps should avoid calling `mediaSession.coordinator.play()` directly
      * and instead use the synchronizers `play()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public play(): void {
+    public async play(): Promise<void> {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.MediaPlayerSynchronizer.PlayCalled
         );
         this._expectedPlaybackState = "playing";
-        this._mediaSession.coordinator.play();
+        await this._mediaSession.coordinator.play();
 
         this.dispatchUserAction({ action: "play" });
     }
@@ -515,13 +539,15 @@ export class MediaPlayerSynchronizer extends EventEmitter {
      * @remarks
      * For proper operation apps should avoid calling `mediaSession.coordinator.pause()` directly
      * and instead use the synchronizers `pause()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public pause(): void {
+    public async pause(): Promise<void> {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.MediaPlayerSynchronizer.PauseCalled
         );
         this._expectedPlaybackState = "paused";
-        this._mediaSession.coordinator.pause();
+        await this._mediaSession.coordinator.pause();
 
         this.dispatchUserAction({ action: "pause" });
     }
@@ -532,8 +558,10 @@ export class MediaPlayerSynchronizer extends EventEmitter {
      * @remarks
      * For proper operation apps should avoid calling `mediaSession.coordinator.seekTo()` directly
      * and instead use the synchronizers `seekTo()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public seekTo(time: number): void {
+    public async seekTo(time: number): Promise<void> {
         // Always seek player to new time.
         // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
         //   location.
@@ -544,7 +572,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
             null,
             { position: time }
         );
-        this._mediaSession.coordinator.seekTo(time);
+        await this._mediaSession.coordinator.seekTo(time);
 
         this.dispatchUserAction({ action: "seekto", seekTime: time });
     }
@@ -555,15 +583,17 @@ export class MediaPlayerSynchronizer extends EventEmitter {
      * @remarks
      * For proper operation apps should avoid calling `mediaSession.coordinator.setTrack()` directly
      * and instead use the synchronizers `setTrack()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public setTrack(
+    public async setTrack(
         track: ExtendedMediaMetadata,
         waitPoints?: CoordinationWaitPoint[]
-    ): void {
+    ): Promise<void> {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.MediaPlayerSynchronizer.SetTrackCalled
         );
-        this._mediaSession.coordinator.setTrack(track, waitPoints);
+        await this._mediaSession.coordinator.setTrack(track, waitPoints);
 
         this.dispatchUserAction({ action: "settrack", metadata: track });
     }
@@ -574,13 +604,15 @@ export class MediaPlayerSynchronizer extends EventEmitter {
      * @remarks
      * For proper operation apps should avoid calling `mediaSession.coordinator.setTrackData()` directly
      * and instead use the synchronizers `setTrackData()` method.
+     *
+     * @returns a void promise that resolves once complete, throws if user does not have proper roles
      */
-    public setTrackData(data: object | null): void {
+    public async setTrackData(data: object | null): Promise<void> {
         this._logger.sendTelemetryEvent(
             TelemetryEvents.MediaPlayerSynchronizer.SetTrackDataCalled
         );
         this._trackData = data;
-        this._mediaSession.coordinator.setTrackData(data);
+        await this._mediaSession.coordinator.setTrackData(data);
 
         this.dispatchUserAction({ action: "datachange", data: data });
     }

package/src/VolumeManager.ts

@@ -161,7 +161,10 @@ export class VolumeManager {
         if (typeof requestAnimationFrame == "function") {
             requestAnimationFrame(callback);
         } else {
-            setTimeout(callback, 20);
+            setTimeout(
+                callback,
+                Math.min(this._volumeChangeDuration.milliseconds / 25, 20)
+            );
         }
     }