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

package/src/internals/GroupCoordinatorState.ts

@@ -3,13 +3,13 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { IEvent, IEphemeralEvent, EphemeralEvent, TimeInterval, IRuntimeSignaler, EphemeralTelemetryLogger } from '@microsoft/live-share';
+import { IEvent, ILiveEvent, LiveEvent, TimeInterval, IRuntimeSignaler, LiveTelemetryLogger } from '@microsoft/live-share';
 import EventEmitter from 'events';
 import { ExtendedMediaMetadata, CoordinationWaitPoint, ExtendedMediaSessionPlaybackState, ExtendedMediaSessionActionDetails } from '../MediaSessionExtensions';
 import { GroupPlaybackTrack, GroupPlaybackTrackEvents, IPlaybackTrack } from './GroupPlaybackTrack';
 import { GroupTransportState, ITransportState } from './GroupTransportState';
 import { GroupPlaybackPosition, ICurrentPlaybackPosition } from './GroupPlaybackPosition';
-import { IMediaPlayerState } from '../EphemeralMediaSessionCoordinator';
+import { IMediaPlayerState } from '../LiveMediaSessionCoordinator';
 import { GroupTransportStateEvents } from './GroupTransportState';
 import { GroupPlaybackTrackData, PlaybackTrackDataEvents, IPlaybackTrackData } from './GroupPlaybackTrackData';
 import { TelemetryEvents } from './consts';
@@ -17,7 +17,7 @@ import { TelemetryEvents } from './consts';
 /**
  * @hidden
  */
-export interface IPositionUpdateEvent extends IEphemeralEvent {
+export interface IPositionUpdateEvent extends ILiveEvent {
     track: IPlaybackTrack;
     trackData: IPlaybackTrackData;
     transport: ITransportState;
@@ -29,7 +29,7 @@ export interface IPositionUpdateEvent extends IEphemeralEvent {
 /**
  * @hidden
  */
-export interface ITransportCommandEvent extends IEphemeralEvent {
+export interface ITransportCommandEvent extends ILiveEvent {
     track: IPlaybackTrack;
     position: number;
 }
@@ -37,7 +37,7 @@ export interface ITransportCommandEvent extends IEphemeralEvent {
 /**
  * @hidden
  */
-export interface ISetTrackEvent extends IEphemeralEvent {
+export interface ISetTrackEvent extends ILiveEvent {
     metadata: ExtendedMediaMetadata|null;
     waitPoints: CoordinationWaitPoint[];
 }
@@ -45,7 +45,7 @@ export interface ISetTrackEvent extends IEphemeralEvent {
 /**
  * @hidden
  */
-export interface ISetTrackDataEvent extends IEphemeralEvent {
+export interface ISetTrackDataEvent extends ILiveEvent {
     data: object|null;
 }
 
@@ -69,7 +69,7 @@ export enum GroupCoordinatorStateEvents {
  */
  export class GroupCoordinatorState extends EventEmitter {
     private readonly _runtime: IRuntimeSignaler;
-    private readonly _logger: EphemeralTelemetryLogger;
+    private readonly _logger: LiveTelemetryLogger;
     private readonly _maxPlaybackDrift: TimeInterval;
     private _getMediaPlayerState: () => IMediaPlayerState;
 
@@ -93,7 +93,7 @@ export enum GroupCoordinatorStateEvents {
     constructor (runtime: IRuntimeSignaler, maxPlaybackDrift: TimeInterval, positionUpdateInterval: TimeInterval, getMediaPlayerState: () => IMediaPlayerState) {
         super();
         this._runtime = runtime;
-        this._logger = new EphemeralTelemetryLogger(runtime);
+        this._logger = new LiveTelemetryLogger(runtime);
         this._maxPlaybackDrift = maxPlaybackDrift;
         this._playbackTrack = new GroupPlaybackTrack(getMediaPlayerState);
         this._playbackTrackData = new GroupPlaybackTrackData(this._playbackTrack);
@@ -240,7 +240,7 @@ export enum GroupCoordinatorStateEvents {
         });
 
         if (updated) {
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {correlationId: EphemeralTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp)});
+            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {correlationId: LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp)});
         }
     }
 
@@ -254,7 +254,7 @@ export enum GroupCoordinatorStateEvents {
         });
 
         if (updated) {
-            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {correlationId: EphemeralTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp)});
+            this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemoteSetTrackReceived, null, {correlationId: LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp)});
         }
     }
 
@@ -284,7 +284,7 @@ export enum GroupCoordinatorStateEvents {
             const updated = this.transportState.updateState(newState);
 
             if (updated) {
-                const correlationId = EphemeralTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp);
+                const correlationId = LiveTelemetryLogger.formatCorrelationId(event.clientId, event.timestamp);
                 switch (event.name) {
                     case 'play':
                         this._logger.sendTelemetryEvent(TelemetryEvents.SessionCoordinator.RemotePlayReceived, null, {correlationId: correlationId});
@@ -341,7 +341,7 @@ export enum GroupCoordinatorStateEvents {
                             if (event.playbackState != this._lastStateChange) {
                                 this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.BeginSoftSuspension, null, {playbackState: event.playbackState});
                                 this._lastStateChange = event.playbackState;
-                                this._lastStateChangeTime = EphemeralEvent.getTimestamp();
+                                this._lastStateChangeTime = LiveEvent.getTimestamp();
                             }
                             break;
                     }
@@ -366,7 +366,7 @@ export enum GroupCoordinatorStateEvents {
 
     public async syncLocalMediaSession(): Promise<void> {
         // Skip further syncs if we're waiting or in a "soft suspension".
-        const softSuspensionDelta = EphemeralEvent.getTimestamp() - this._lastStateChangeTime;
+        const softSuspensionDelta = LiveEvent.getTimestamp() - this._lastStateChangeTime;
         if (!this.isWaiting && softSuspensionDelta >= 1000) {
             let { metadata, trackData, positionState, playbackState } = this._getMediaPlayerState();
             this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.CheckingForSyncIssues);

package/src/internals/GroupPlaybackPosition.ts

@@ -3,7 +3,7 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { EphemeralEvent, IRuntimeSignaler, TimeInterval } from '@microsoft/live-share';
+import { LiveEvent, IRuntimeSignaler, TimeInterval } from '@microsoft/live-share';
 import { GroupTransportState } from './GroupTransportState';
 import { GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
 import { CoordinationWaitPoint, ExtendedMediaSessionPlaybackState } from '../MediaSessionExtensions';
@@ -109,7 +109,7 @@ export class GroupPlaybackPosition {
      */
     public get maxPosition(): number {
         if (this._transportState.playbackState == 'playing') {
-            const now = EphemeralEvent.getTimestamp();
+            const now = LiveEvent.getTimestamp();
             const projected = this._transportState.startPosition + ((now - this._transportState.timestamp) / 1000);
             return this.limitProjectedPosition(projected);
         } else {
@@ -136,7 +136,7 @@ export class GroupPlaybackPosition {
      * @param callbackFn Function applied to each position,
      */
      public forEach(callbackFn: (position: ICurrentPlaybackPosition, projectedPosition: number) => void): void {
-        const now = EphemeralEvent.getTimestamp();
+        const now = LiveEvent.getTimestamp();
         const ignoreBefore = now - (this._updateInterval.milliseconds * 2);
         const shouldProject = !this._transportState.track.metadata?.liveStream;
         this._positions.forEach((value, key) => {

package/src/internals/GroupPlaybackTrack.ts

@@ -5,7 +5,7 @@
 
 import { IEvent } from '@microsoft/live-share';
 import EventEmitter from 'events';
-import { IMediaPlayerState } from '../EphemeralMediaSessionCoordinator';
+import { IMediaPlayerState } from '../LiveMediaSessionCoordinator';
 import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExtensions';
 
 /**

package/src/internals/GroupTransportState.ts

@@ -3,9 +3,9 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { IEvent, EphemeralEvent } from '@microsoft/live-share';
+import { IEvent, LiveEvent } from '@microsoft/live-share';
 import EventEmitter from 'events';
-import { IMediaPlayerState } from '../EphemeralMediaSessionCoordinator';
+import { IMediaPlayerState } from '../LiveMediaSessionCoordinator';
 import { ExtendedMediaSessionPlaybackState, ExtendedMediaSessionAction } from '../MediaSessionExtensions';
 import { GroupPlaybackTrack, GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
 
@@ -115,7 +115,7 @@ export interface ITransportStateChangeEvent extends IEvent {
         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 = EphemeralEvent.getTimestamp();
+            const now = LiveEvent.getTimestamp();
             const projectedPosition = state.startPosition + ((now - state.timestamp) / 1000);
             this.emit(GroupTransportStateEvents.transportStateChange, { type: GroupTransportStateEvents.transportStateChange, action: 'play', seekTime: projectedPosition});
         } else {

package/src/test/SharedMediaSession.spec.ts

@@ -6,9 +6,9 @@
 import 'mocha';
 import { strict as assert } from 'assert';
 import { CollaborationSpace, CollaborationSpaceEvents, Deferred } from '@microsoft/teams-collaboration';
-import { LastMediaPositionState } from '../EphemeralMediaSessionCoordinator';
+import { LastMediaPositionState } from '../LiveMediaSessionCoordinator';
 import { ExtendedMediaMetadata, ExtendedMediaSessionActionDetails } from '../MediaSessionExtensions';
-import { SharedMediaSession } from '../EphemeralMediaSession';
+import { SharedMediaSession } from '../LiveMediaSession';
 
 export class TestMediaSession extends SharedMediaSession {
     private done = new Deferred<ExtendedMediaSessionActionDetails>();

package/src/test/VolumeManager.spec.ts

@@ -0,0 +1,212 @@
+import { strict as assert } from "assert";
+import { IMediaPlayer } from "../IMediaPlayer"
+import { LimitLevelType, VolumeManager } from "../VolumeManager"
+import { Deferred } from '@microsoft/live-share/src/test/Deferred';
+
+describe('VolumeManager', () => {
+    it('should ramp down volume', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+        const volumeManager = new VolumeManager(player);
+
+        assert(player.volume == 1.0);
+        volumeManager.startLimiting();
+        setTimeout(() => {
+            // check volume at halfway point
+            assert(player.volume > 0.4);
+            assert(player.volume < 0.6);
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        setTimeout(() => {
+            // check volume at end with 20ms of leeway
+            assert(player.volume == volumeManager.limitLevel);
+            testAwait.resolve();
+        }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        await testAwait.promise;
+    });
+
+    it('should ramp up volume', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+        const volumeManager = new VolumeManager(player);
+
+        // limit at start
+        volumeManager.startLimiting();
+
+        // when limited all the way, test ramp up
+        setTimeout(() => {
+            assert(player.volume == volumeManager.limitLevel);
+            volumeManager.stopLimiting();
+
+            setTimeout(() => {
+                // check volume at halfway point
+                assert(player.volume > 0.4);
+                assert(player.volume < 0.6);
+            }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+            setTimeout(() => {
+                // check volume at end with 20ms of leeway
+                assert(player.volume == volumeManager.volume);
+                testAwait.resolve();
+            }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        await testAwait.promise;
+    });
+
+    it('should ramp down halfway, then ramp up', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+
+        const volumeManager = new VolumeManager(player);
+
+        volumeManager.startLimiting();
+        setTimeout(() => {
+            // check volume at halfway point, begin ramping other direction
+            assert(player.volume > 0.4);
+            assert(player.volume < 0.6);
+            volumeManager.stopLimiting();
+
+            setTimeout(() => {
+                // check volume at end with 20ms of leeway
+                assert(player.volume == volumeManager.volume);
+                testAwait.resolve();
+            }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        await testAwait.promise;
+    });
+
+    it('ramp using selected volume', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+
+        const volumeManager = new VolumeManager(player);
+
+        volumeManager.volume = 0.3;
+        setTimeout(() => {
+            // check volume at halfway point
+            assert(player.volume > 0.6);
+            assert(player.volume < 0.7);
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        setTimeout(() => {
+            // check volume at end with 20ms of leeway
+            assert(player.volume == volumeManager.volume);
+            testAwait.resolve();
+        }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        await testAwait.promise;
+    });
+
+    it('enable limit, change selected volume, then disable limit', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+        const volumeManager = new VolumeManager(player);
+
+        volumeManager.startLimiting();
+        setTimeout(() => {
+            // check volume at halfway point, begin ramping other direction with lower selected volume
+            assert(player.volume > 0.4);
+            assert(player.volume < 0.6);
+
+            volumeManager.volume = 0.7;
+            volumeManager.stopLimiting();
+
+            setTimeout(() => {
+                // check volume at end with 20ms of leeway
+                assert(player.volume === volumeManager.volume);
+                testAwait.resolve();
+            }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        await testAwait.promise;
+    });
+
+    it('ramp down with selected volume to 0.3, then up to 0.8', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+
+        const volumeManager = new VolumeManager(player);
+        volumeManager.volume = 0.3;
+
+        setTimeout(() => {
+            // check volume at halfway point
+            assert(player.volume > 0.6);
+            assert(player.volume < 0.7);
+            volumeManager.volume = 0.8;
+
+            setTimeout(() => {
+                // check volume at end with 20ms of leeway
+                assert(player.volume == volumeManager.volume);
+                testAwait.resolve();
+            }, volumeManager.volumeChangeDuration * 1000 + 20);
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        await testAwait.promise;
+    });
+
+    it('test 50% limiting', async () => {
+        const testAwait = new Deferred();
+        const player = new TestMediaPlayer();
+        player.volume = 1.0
+
+        const volumeManager = new VolumeManager(player);
+        volumeManager.limitLevelType = LimitLevelType.percentage;
+        volumeManager.limitLevel = 0.5;
+
+        volumeManager.startLimiting();
+
+        setTimeout(() => {
+            // check volume at halfway point
+            assert(player.volume > 0.7);
+            assert(player.volume < 0.8);
+        }, volumeManager.volumeChangeDuration * 1000 / 2);
+
+        setTimeout(() => {
+            // check volume at end with 20ms of leeway
+            assert(player.volume == volumeManager.limitLevel * volumeManager.volume);
+            testAwait.resolve();
+        }, volumeManager.volumeChangeDuration * 1000 + 20);
+
+        await testAwait.promise;
+    });
+});
+
+// test implementation
+class TestMediaPlayer implements IMediaPlayer {
+    currentSrc: string;
+    currentTime: number;
+    duration: number;
+    ended: boolean;
+    muted: boolean;
+    paused: boolean;
+    playbackRate: number;
+    src: string;
+    volume: number;
+    load(): void {
+        throw new Error("Method not implemented.");
+    }
+    pause(): void {
+        throw new Error("Method not implemented.");
+    }
+    play(): Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void {
+        throw new Error("Method not implemented.");
+    }
+}

package/src/VolumeLimiter.ts

@@ -1,182 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
- import { TimeInterval } from '@microsoft/live-share';
- import { IMediaPlayer } from './IMediaPlayer';
-
-export enum LevelType { fixed, percentage }
-
-export class VolumeLimiter {
-    private readonly _player: IMediaPlayer;
-
-    // Settings
-    private readonly _duration = new TimeInterval(2000);
-    private readonly _rampDownDuration = new TimeInterval(500);
-    private readonly _rampUpDuration = new TimeInterval(500);
-    private _level: number = 0.1
-    private _levelType: LevelType = LevelType.fixed;
-
-    // Running state
-    private _running = false;
-    private _endTime = 0;
-    private _startTime = 0;
-    private _startVolume = 0;
-    private _inRamp = false;
-
-    constructor(player: IMediaPlayer) {
-        this._player = player;
-    }
-
-    /**
-     * Time, in seconds, that the volume should be lowered.
-     * 
-     * @remarks
-     * Applications should periodically call `lowerVolume()` to keep the volume lowered. 
-     */
-    public get duration(): number {
-        return this._duration.seconds;
-    }
-
-    public set duration(value: number) {
-        this._duration.seconds = Math.abs(value);
-    }
-
-    /**
-     * Target level to lower volume to.
-     * 
-     * @remarks
-     * Expressed as a value between 0.0 and 1.0. The value is applied based upon the configured
-     * `levelType`. The default value is 0.2.
-     * 
-     * For a level type of `LevelType.fixed` the value is the exact level the volume will be 
-     * lowered to. The default value of 0.2 would cause the volume to be lowered to 0.2.
-     * 
-     * For a level type of `LevelType.percentage` the value is the percentage by which the volume
-     * level should be lowered to. The default value of 0.2 would cause the volume to be lowered
-     * to 20% of its starting value.
-     */
-    public get level(): number {
-        return this._level;
-    }
-
-    public set level(value: number) {
-        if (value < 0 || value > 1.0) {
-            throw new Error(`VolumeLimiter: cannot set level to ${value}. Level must be between 0.0 and 1.0.`);
-        }
-
-        this._level = value;
-    }
-
-    /**
-     * The type of level represented by the `level` property.
-     */
-    public get levelType(): LevelType {
-        return this._levelType;
-    }
-
-    public set levelType(value: LevelType) {
-        this._levelType = value;
-    }
-
-    /**
-     * Amount of time, in seconds, it should take to ramp the volume down to the desired level.
-     */
-    public get rampDownDuration(): number {
-        return this._rampDownDuration.seconds;
-    }
-
-    public set rampDownDuration(value: number) {
-        this._rampDownDuration.seconds = Math.abs(value);
-    }
-
-    /**
-     * Amount of time, in seconds, it should take to ramp the volume back up to the original level.
-     */
-     public get rampUpDuration(): number {
-        return this._rampUpDuration.seconds;
-    }
-
-    public set rampUpDuration(value: number) {
-        this._rampUpDuration.seconds = Math.abs(value);
-    }
-
-    /**
-     * Temporarily lowers an audio sources volume.
-     */
-    public lowerVolume(): void {
-        this._endTime = new Date().getTime() + this._duration.milliseconds;
-        if (!this._running) {
-            this.startLimiter();
-        }
-    }
-
-    private startLimiter(): void {
-        const adjustVolume = () => {
-            const now = new Date().getTime();
-            if (now < this._endTime) {
-                // Make no adjustment if muted
-                if (!this._player.muted) {
-                    // Compute adjusted volume level
-                    let volume: number;
-                    const targetVolume = this.computeTargetVolume();
-                    const rampRange = this._startVolume - targetVolume;
-                    const rampUpStart = this._endTime - this._rampUpDuration.milliseconds;
-                    const rampDownEnd = this._startTime + this._rampDownDuration.milliseconds;
-                    if (now > rampUpStart) {
-                        // We're about to end so ramping up
-                        const progress = (now - rampUpStart) / this._rampUpDuration.milliseconds;
-                        volume = targetVolume + (rampRange * progress);
-                        this._player.volume = volume;
-                        this._inRamp = true;
-                    } else if (now < rampDownEnd) {
-                        // We just begun so ramping down
-                        const remaining = (rampDownEnd - now) / this._rampUpDuration.milliseconds;
-                        volume = targetVolume + (rampRange * remaining);
-                        this._player.volume = volume;
-                        this._inRamp = true;
-                    } else if (this._inRamp) {
-                        // We're at the end of a ramp
-                        volume = targetVolume;
-                        this._player.volume = volume;
-                        this._inRamp = false;
-                    }
-                }
-
-                // Schedule next animation frame
-                this.scheduleAnimationFrame(adjustVolume);
-            } else {
-                // Reset volume to original level
-                this._player.volume = this._startVolume;
-                this._running = false;
-                this._endTime = 0;
-                this._startTime = 0;
-                this._startVolume = 0;
-            }
-        };
-
-        this._running = true;
-        this._startTime = new Date().getTime();
-        this._startVolume = this._player.volume;
-        this.scheduleAnimationFrame(adjustVolume)
-    }
-
-    private scheduleAnimationFrame(callback: FrameRequestCallback): void {
-        if (requestAnimationFrame) {
-            requestAnimationFrame(callback);
-        } else {
-            setTimeout(callback, 20);
-        }
-    }
-
-    private computeTargetVolume(): number {
-        switch (this._levelType) {
-            case LevelType.percentage:
-                return this._startVolume * this._level;
-            case LevelType.fixed:
-            default:
-                return this._level;
-        }
-    }
-}