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

package/src/test/GroupPlaybackTrack.spec.ts

@@ -1,66 +1,122 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import 'mocha';
-import { strict as assert } from 'assert';
-import { IParticipant, ParticipantRole, Deferred } from '@microsoft/teams-collaboration';
-import { GroupPlaybackTrack, GroupPlaybackTrackEvents, ITrackChangeEvent } from '../internals/GroupPlaybackTrack';
-import { ExtendedMediaMetadata } from '../MediaSessionExtensions';
-
-describe('GroupPlaybackTrack', () => {
-    const user1: IParticipant = { participantId: 'user1', role: ParticipantRole.organizer };
-    const user2: IParticipant = { participantId: 'user2', role: ParticipantRole.participant };
-
-    const track1 = { trackIdentifier: 'track1', title: 'Test Track 1' } as ExtendedMediaMetadata;
-    const track2 = { trackIdentifier: 'track2', title: 'Test Track 2' } as ExtendedMediaMetadata;
-
-    it('should fire "trackChange" event when no media', async () => {
-        const done = new Deferred();
-        const playbackTrack = new GroupPlaybackTrack(() => null);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            try {
-                assert(event.metadata, `no metadata`);
-                assert(event.metadata.trackIdentifier == 'track1', `wrong track`);
-                done.resolve();
-            } catch(err) {
-                done.reject(err);
-            }
-
-        });
-
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 1, socketId: 'a'});
-
-        await done.promise;
-    });
-
-    it('should switch tracks', async () => {
-        let cnt = 0;
-        let metadata: ExtendedMediaMetadata = null;
-        const playbackTrack = new GroupPlaybackTrack(() => metadata);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            cnt++;
-            metadata = event.metadata;
-        });
-
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 1, socketId: 'a'});
-        await playbackTrack.updateTrack({ metadata: track2, waitPoints: [], timestamp: 2, socketId: 'b'});
-        assert(cnt == 2, `called trackChange event ${cnt} times`);
-        assert(metadata.trackIdentifier == 'track2', `wrong track set`);
-    });
-
-    it('should ignore track changes with older timestamps', async () => {
-        let cnt = 0;
-        let metadata: ExtendedMediaMetadata = null;
-        const playbackTrack = new GroupPlaybackTrack(() => metadata);
-        playbackTrack.addEventListener(GroupPlaybackTrackEvents.trackChange, (event: ITrackChangeEvent) => {
-            cnt++;
-            metadata = event.metadata;
-        });
-
-        await playbackTrack.updateTrack({ metadata: track1, waitPoints: [], timestamp: 3, socketId: 'a'});
-        await playbackTrack.updateTrack({ metadata: track2, waitPoints: [], timestamp: 2, socketId: 'b'});
-        assert(cnt == 1, `called trackChange event ${cnt} times`);
-    });
-});
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    IParticipant,
+    ParticipantRole,
+    Deferred,
+} from "@microsoft/teams-collaboration";
+import {
+    GroupPlaybackTrack,
+    GroupPlaybackTrackEvents,
+    ITrackChangeEvent,
+} from "../internals/GroupPlaybackTrack";
+import { ExtendedMediaMetadata } from "../MediaSessionExtensions";
+
+describe("GroupPlaybackTrack", () => {
+    const user1: IParticipant = {
+        participantId: "user1",
+        role: ParticipantRole.organizer,
+    };
+    const user2: IParticipant = {
+        participantId: "user2",
+        role: ParticipantRole.participant,
+    };
+
+    const track1 = {
+        trackIdentifier: "track1",
+        title: "Test Track 1",
+    } as ExtendedMediaMetadata;
+    const track2 = {
+        trackIdentifier: "track2",
+        title: "Test Track 2",
+    } as ExtendedMediaMetadata;
+
+    it('should fire "trackChange" event when no media', async () => {
+        const done = new Deferred();
+        const playbackTrack = new GroupPlaybackTrack(() => null);
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                try {
+                    assert(event.metadata, `no metadata`);
+                    assert(
+                        event.metadata.trackIdentifier == "track1",
+                        `wrong track`
+                    );
+                    done.resolve();
+                } catch (err) {
+                    done.reject(err);
+                }
+            }
+        );
+
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 1,
+            socketId: "a",
+        });
+
+        await done.promise;
+    });
+
+    it("should switch tracks", async () => {
+        let cnt = 0;
+        let metadata: ExtendedMediaMetadata = null;
+        const playbackTrack = new GroupPlaybackTrack(() => metadata);
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                cnt++;
+                metadata = event.metadata;
+            }
+        );
+
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 1,
+            socketId: "a",
+        });
+        await playbackTrack.updateTrack({
+            metadata: track2,
+            waitPoints: [],
+            timestamp: 2,
+            socketId: "b",
+        });
+        assert(cnt == 2, `called trackChange event ${cnt} times`);
+        assert(metadata.trackIdentifier == "track2", `wrong track set`);
+    });
+
+    it("should ignore track changes with older timestamps", async () => {
+        let cnt = 0;
+        let metadata: ExtendedMediaMetadata = null;
+        const playbackTrack = new GroupPlaybackTrack(() => metadata);
+        playbackTrack.addEventListener(
+            GroupPlaybackTrackEvents.trackChange,
+            (event: ITrackChangeEvent) => {
+                cnt++;
+                metadata = event.metadata;
+            }
+        );
+
+        await playbackTrack.updateTrack({
+            metadata: track1,
+            waitPoints: [],
+            timestamp: 3,
+            socketId: "a",
+        });
+        await playbackTrack.updateTrack({
+            metadata: track2,
+            waitPoints: [],
+            timestamp: 2,
+            socketId: "b",
+        });
+        assert(cnt == 1, `called trackChange event ${cnt} times`);
+    });
+});

package/src/test/SharedMediaSession.spec.ts

@@ -1,113 +1,149 @@
-/**
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the Microsoft Live Share SDK License.
- */
-
-import 'mocha';
-import { strict as assert } from 'assert';
-import { CollaborationSpace, CollaborationSpaceEvents, Deferred } from '@microsoft/teams-collaboration';
-import { LastMediaPositionState } from '../EphemeralMediaSessionCoordinator';
-import { ExtendedMediaMetadata, ExtendedMediaSessionActionDetails } from '../MediaSessionExtensions';
-import { SharedMediaSession } from '../EphemeralMediaSession';
-
-export class TestMediaSession extends SharedMediaSession {
-    private done = new Deferred<ExtendedMediaSessionActionDetails>();
-    private space: CollaborationSpace;
-    private playbackTimer: any;
-    private playbackStarted: number = 0;
-    private playbackPosition: number = 0.0;
-
-    constructor(space: CollaborationSpace,  metadata?: ExtendedMediaMetadata|null, playbackState?: MediaSessionPlaybackState, positionState?: LastMediaPositionState) {
-        super(space);
-        this.space = space;
-        if (metadata) { this.metadata = metadata; }
-        if (playbackState) { this.playbackState = playbackState; }
-        if (positionState) {
-            this.playbackPosition = positionState.position != undefined ? positionState.position : 0.0;
-            this.duration = positionState.duration;
-            this.playbackRate = positionState.playbackRate != undefined ? positionState.playbackRate : 1;
-        }
-
-        this.setActionHandler('play', details => {
-            this.play();
-            this.done.resolve(details);
-        });
-        this.setActionHandler('pause', details => {
-            this.pause();
-            this.done.resolve(details);
-        });
-        this.setActionHandler('seekto', details => {
-            this.currentTime = details.seekTime;
-            this.done.resolve(details);
-        });
-        this.setActionHandler('settrack', details => {
-            this.done.resolve(details);
-        });
-
-        this.space.addEventListener(CollaborationSpaceEvents.leftSpace, () => {
-            if (this.playbackTimer) {
-                clearInterval(this.playbackTimer);
-                this.playbackTimer = undefined;
-            }
-        });
-    }
-
-    public duration?: number;
-    public playbackRate: number = 1;
-
-    public get playing(): boolean {
-        return this.playbackState == 'playing';
-    }
-
-    public get paused(): boolean {
-        return this.playbackState != 'playing';
-    }
-
-    public get currentTime(): number {
-        if (this.playbackState == 'playing') {
-            const now = this.space.clock.getTime();
-            return this.playbackPosition + ((now - this.playbackStarted) / 1000);
-        } else {
-            return this.playbackPosition;
-        }
-    }
-
-    public set currentTime(value: number) {
-        const startState = this.playbackState;
-        this.pause();
-        this.playbackPosition = value;
-        if (startState == 'playing') {
-            this.play();
-        } else {
-            this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
-        }
-    }
-
-    public play(): void {
-        if (this.playbackState != 'playing') {
-            this.playbackStarted = this.space.clock.getTime();
-            this.playbackState = 'playing';
-            this.playbackTimer = setInterval(() => {
-                this.playbackState = 'playing';
-                this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
-            }, 60);
-        }
-    }
-
-    public pause(): void {
-        if (this.playbackTimer) {
-            clearInterval(this.playbackTimer);
-            this.playbackTimer = undefined;
-        }
-
-        this.playbackPosition = this.currentTime;
-        this.playbackState = 'paused';
-        this.setPositionState({position: this.currentTime, duration: this.duration, playbackRate: this.playbackRate});
-    }
-
-    public async waitForAction(handler: (details: ExtendedMediaSessionActionDetails) => Promise<void>): Promise<void> {
-        const details = await this.done.promise;
-        this.done = new Deferred<ExtendedMediaSessionActionDetails>();
-        await handler(details);
-    }
-}
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the Microsoft Live Share SDK License.
+ */
+
+import "mocha";
+import { strict as assert } from "assert";
+import {
+    CollaborationSpace,
+    CollaborationSpaceEvents,
+    Deferred,
+} from "@microsoft/teams-collaboration";
+import { LastMediaPositionState } from "../LiveMediaSessionCoordinator";
+import {
+    ExtendedMediaMetadata,
+    ExtendedMediaSessionActionDetails,
+} from "../MediaSessionExtensions";
+import { SharedMediaSession } from "../LiveMediaSession";
+
+export class TestMediaSession extends SharedMediaSession {
+    private done = new Deferred<ExtendedMediaSessionActionDetails>();
+    private space: CollaborationSpace;
+    private playbackTimer: any;
+    private playbackStarted: number = 0;
+    private playbackPosition: number = 0.0;
+
+    constructor(
+        space: CollaborationSpace,
+        metadata?: ExtendedMediaMetadata | null,
+        playbackState?: MediaSessionPlaybackState,
+        positionState?: LastMediaPositionState
+    ) {
+        super(space);
+        this.space = space;
+        if (metadata) {
+            this.metadata = metadata;
+        }
+        if (playbackState) {
+            this.playbackState = playbackState;
+        }
+        if (positionState) {
+            this.playbackPosition =
+                positionState.position != undefined
+                    ? positionState.position
+                    : 0.0;
+            this.duration = positionState.duration;
+            this.playbackRate =
+                positionState.playbackRate != undefined
+                    ? positionState.playbackRate
+                    : 1;
+        }
+
+        this.setActionHandler("play", (details) => {
+            this.play();
+            this.done.resolve(details);
+        });
+        this.setActionHandler("pause", (details) => {
+            this.pause();
+            this.done.resolve(details);
+        });
+        this.setActionHandler("seekto", (details) => {
+            this.currentTime = details.seekTime;
+            this.done.resolve(details);
+        });
+        this.setActionHandler("settrack", (details) => {
+            this.done.resolve(details);
+        });
+
+        this.space.addEventListener(CollaborationSpaceEvents.leftSpace, () => {
+            if (this.playbackTimer) {
+                clearInterval(this.playbackTimer);
+                this.playbackTimer = undefined;
+            }
+        });
+    }
+
+    public duration?: number;
+    public playbackRate: number = 1;
+
+    public get playing(): boolean {
+        return this.playbackState == "playing";
+    }
+
+    public get paused(): boolean {
+        return this.playbackState != "playing";
+    }
+
+    public get currentTime(): number {
+        if (this.playbackState == "playing") {
+            const now = this.space.clock.getTime();
+            return this.playbackPosition + (now - this.playbackStarted) / 1000;
+        } else {
+            return this.playbackPosition;
+        }
+    }
+
+    public set currentTime(value: number) {
+        const startState = this.playbackState;
+        this.pause();
+        this.playbackPosition = value;
+        if (startState == "playing") {
+            this.play();
+        } else {
+            this.setPositionState({
+                position: this.currentTime,
+                duration: this.duration,
+                playbackRate: this.playbackRate,
+            });
+        }
+    }
+
+    public play(): void {
+        if (this.playbackState != "playing") {
+            this.playbackStarted = this.space.clock.getTime();
+            this.playbackState = "playing";
+            this.playbackTimer = setInterval(() => {
+                this.playbackState = "playing";
+                this.setPositionState({
+                    position: this.currentTime,
+                    duration: this.duration,
+                    playbackRate: this.playbackRate,
+                });
+            }, 60);
+        }
+    }
+
+    public pause(): void {
+        if (this.playbackTimer) {
+            clearInterval(this.playbackTimer);
+            this.playbackTimer = undefined;
+        }
+
+        this.playbackPosition = this.currentTime;
+        this.playbackState = "paused";
+        this.setPositionState({
+            position: this.currentTime,
+            duration: this.duration,
+            playbackRate: this.playbackRate,
+        });
+    }
+
+    public async waitForAction(
+        handler: (details: ExtendedMediaSessionActionDetails) => Promise<void>
+    ): Promise<void> {
+        const details = await this.done.promise;
+        this.done = new Deferred<ExtendedMediaSessionActionDetails>();
+        await handler(details);
+    }
+}