@microsoft/live-share-media 0.1.2 → 0.2.2

package/src/MediaPlayerSynchronizer.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { EphemeralTelemetryLogger, IEvent, TimeInterval } from '@microsoft/live-share';
@@ -11,11 +11,23 @@ import { VolumeLimiter } from './VolumeLimiter';
 import { IMediaPlayer } from './IMediaPlayer';
 import { TelemetryEvents } from './internals';
 
+/**
+ * Event data returned by `MediaPlayerSynchronizer` object.
+ */
 export interface IMediaPlayerSynchronizerEvent extends IEvent {
+    /**
+     * Event details.
+     */
     details: ExtendedMediaSessionActionDetails;
 }
 
+/**
+ * Events supported by `MediaPlayerSynchronizer` object.
+ */
 export enum MediaPlayerSynchronizerEvents {
+    /**
+     * 
+     */
     coordinatorstatechange = 'coordinatorstatechange',
     groupaction = 'groupaction',
     useraction = 'useraction'
@@ -40,7 +52,6 @@ export class MediaPlayerSynchronizer extends EventEmitter {
     private _volumeLimiter: VolumeLimiter;
     private _onEnd?: () => void;
     private _onPlayerEvent: EventListener;
-    private _catchupFastSeekPeriod: TimeInterval = new TimeInterval(0);
     private _seekSuspension?: MediaSessionCoordinatorSuspension;
     private _viewOnly = false;
     private _expectedPlaybackState: ExtendedMediaSessionPlaybackState = 'none';
@@ -61,7 +72,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._onEnd = onEnd;
 
         // Listen for player state requests
-        mediaSession.onRequestPlayerState = () => {
+        mediaSession.setRequestPlayerStateHandler(() => {
             // Find playback state
             let playbackState: ExtendedMediaSessionPlaybackState;
             const src = this._player.currentSrc || this._player.src;
@@ -87,7 +98,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
             };
 
             return state;
-        }
+        });
 
         // Listen for player events
         this._onPlayerEvent = (evt: Event) => {
@@ -104,7 +115,7 @@ export class MediaPlayerSynchronizer extends EventEmitter {
                     // Handle case for YouTube player where user can pause/play video by clicking on it.
                     // - Videos don't always start at 0.0 seconds.
                     if (this._expectedPlaybackState != 'playing') {
-                        if (!this._viewOnly && this._player.currentTime < 1.0) {
+                        if (this._mediaSession.coordinator.canPlayPause && this._player.currentTime < 1.0) {
                             this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.UserTappedVideoToPlay);
                             this.play();
                         }
@@ -185,22 +196,30 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.SynchronizationStarted);
     }
 
-    public get catchupFastSeekPeriod(): number {
-        return this._catchupFastSeekPeriod.seconds;
-    }
-
-    public set catchupFastSeekPeriod(value: number) {
-        this._catchupFastSeekPeriod.seconds = value;
-    }
-
+    /**
+     * Media player being synchronized.
+     */
     public get player(): IMediaPlayer {
         return this._player;
     }
 
+    /**
+     * Synchronizers media session.
+     */
     public get mediaSession(): EphemeralMediaSession {
         return this._mediaSession;
     }
 
+    /**
+     * If true the client is in a view only mode.
+     * 
+     * @remarks
+     * Toggling this value to true results in `mediaSession.coordinator.canPlayPause`,
+     * `mediaSession.coordinator.canSeek`, `mediaSession.coordinator.canSetTrack`, and
+     * `mediaSession.coordinator.canSetTrackData` all being set to false.  For more fine
+     * grained control over the local clients policies, call the `mediaSession.coordinator`
+     * directly.
+     */
     public get viewOnly(): boolean {
         return this._viewOnly;
     }
@@ -209,22 +228,40 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._viewOnly = value;
         this.mediaSession.coordinator.canPlayPause = !value;
         this.mediaSession.coordinator.canSeek = !value;
+        this.mediaSession.coordinator.canSetTrack = !value;
+        this.mediaSession.coordinator.canSetTrackData = !value;
     }
 
+    /**
+     * Volume limiter used to temporarily reduce the videos volume when someone speaks in a meeting.
+     */
     public get volumeLimiter(): VolumeLimiter {
         return this._volumeLimiter;
     }
 
-    public addEventListener(event: MediaPlayerSynchronizerEvents, listener: () => void): this {
+    /**
+     * Registers a new event listener.
+     * @param event Name of the event to add.
+     * @param listener Function to call when the event is triggered.
+     */
+    public addEventListener(event: MediaPlayerSynchronizerEvents, listener: (evt: IMediaPlayerSynchronizerEvent) => void): this {
         this.on(event, listener);
         return this;
     }
 
-    public removeEventListener(event: MediaPlayerSynchronizerEvents, listener: () => void): this {
+    /**
+     * Un-registers an existing event listener.
+     * @param event Name of the event to remove.
+     * @param listener Function that was registered in call to `addEventListener()`.
+     */
+    public removeEventListener(event: MediaPlayerSynchronizerEvents, listener: (evt: IMediaPlayerSynchronizerEvent) => void): this {
         this.off(event, listener);
         return this;
     }
 
+    /**
+     * Ends synchronization of the current media player.
+     */
     public end(): void {
         if (this._onEnd) {
             try {
@@ -246,6 +283,15 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         }
     }
 
+    /**
+     * Begin a local seek operation.
+     * 
+     * @remarks
+     * UI can call this when a user grabs a timeline scrubber and starts scrubbing the video to a 
+     * new playback position. The synchronizer will being a new suspension which temporarily
+     * disconnects the client for the rest of the group for synchronization purposes. Calling
+     * `endSeek()` will end the suspension and seek the group to the users final seek position.
+     */
     public beginSeek(): void {
         if (this._seekSuspension) {
             throw new Error(`MediaPlayerSynchronizer: cannot begin seek. A seek is already in progress.`);
@@ -255,6 +301,10 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this._seekSuspension = this._mediaSession.coordinator.beginSuspension();
     }
 
+    /**
+     * Ends a seek operation that was started by calling `beginSeek()`.
+     * @param seekTo Playback position in seconds to seek the group to.
+     */
     public endSeek(seekTo: number): void {
         if (!this._seekSuspension) {
             throw new Error(`MediaPlayerSynchronizer: cannot end seek. No seek is in progress.`);
@@ -274,6 +324,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this.dispatchUserAction({action: 'seekto', seekTime: seekTo});
     }
 
+    /**
+     * Tells the group to begin playing the current video.
+     * 
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.play()` directly 
+     * and instead use the synchronizers `play()` method.  
+     */
     public play(): void {
         this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.PlayCalled);
         this._expectedPlaybackState = 'playing';
@@ -282,6 +339,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this.dispatchUserAction({action: 'play'});
     }
 
+    /**
+     * Tells the group to pause the current video.
+     * 
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.pause()` directly 
+     * and instead use the synchronizers `pause()` method.  
+     */
     public pause(): void {
         this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.PauseCalled);
         this._expectedPlaybackState = 'paused';
@@ -290,6 +354,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this.dispatchUserAction({action: 'pause'});
     }
 
+    /**
+     * Tells the group to seek the current video to a new playback position.
+     * 
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.seekTo()` directly 
+     * and instead use the synchronizers `seekTo()` method.  
+     */
     public seekTo(time: number): void {
         // Always seek player to new time.
         // - This resolves an issue where the timeline scrubber can temporarily snap back to the original
@@ -302,6 +373,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this.dispatchUserAction({action: 'seekto', seekTime: time});
     }
 
+    /**
+     * Tells the group to change to a new track.
+     * 
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrack()` directly 
+     * and instead use the synchronizers `setTrack()` method.  
+     */
     public setTrack(track: ExtendedMediaMetadata, waitPoints?: CoordinationWaitPoint[]): void {
         this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.SetTrackCalled);
         this._mediaSession.coordinator.setTrack(track, waitPoints);
@@ -309,6 +387,13 @@ export class MediaPlayerSynchronizer extends EventEmitter {
         this.dispatchUserAction({action: 'settrack', metadata: track});
     }
 
+    /**
+     * Updates the current tracks data object.
+     * 
+     * @remarks
+     * For proper operation apps should avoid calling `mediaSession.coordinator.setTrackData()` directly 
+     * and instead use the synchronizers `setTrackData()` method.  
+     */
     public setTrackData(data: object|null): void {
         this._logger.sendTelemetryEvent(TelemetryEvents.MediaPlayerSynchronizer.SetTrackDataCalled);
         this._trackData = data;
@@ -334,23 +419,6 @@ export class MediaPlayerSynchronizer extends EventEmitter {
     }
 
     private async catchupPlayer(time: number): Promise<void> {
-        // Only fast seek if:
-        // - more then 2 seconds behind.
-        // - fast seek hasn't been disabled.
-        // - the current playback rate is 1.0.
-        if (time >= (this._player.currentTime + 2.0) && this.catchupFastSeekPeriod > 0 && this._player.playbackRate == 1.0) {
-            // Fast seek to new position
-            const suspension = await this._mediaSession.coordinator.beginSuspension();
-            const seekPeriod = Math.min(time - this._player.currentTime, this.catchupFastSeekPeriod);
-            const startTime = time - seekPeriod;
-            this._player.currentTime = startTime;
-            this._player.playbackRate = 4.0;
-            setTimeout(async () => {
-                this._player.playbackRate = 1.0;
-                await suspension.end();
-            }, (seekPeriod * 0.25) * 1000)
-        } else {
-            this._player.currentTime = time;
-        }
+        this._player.currentTime = time;
     }
 }

package/src/MediaSessionActionThrottler.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { ExtendedMediaSessionActionDetails } from './MediaSessionExtensions';

package/src/MediaSessionExtensions.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 export interface MediaSessionCoordinatorSuspension {

package/src/RepeatedActionThrottler.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { TimeInterval } from '@microsoft/live-share';

package/src/VolumeLimiter.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
  import { TimeInterval } from '@microsoft/live-share';
@@ -33,7 +33,7 @@ export class VolumeLimiter {
      * Time, in seconds, that the volume should be lowered.
      * 
      * @remarks
-     * Applications should periodically call `lowerVolume()` to keep teh volume lowered. 
+     * Applications should periodically call `lowerVolume()` to keep the volume lowered. 
      */
     public get duration(): number {
         return this._duration.seconds;

package/src/index.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 

package/src/internals/GroupCoordinatorState.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { IEvent, IEphemeralEvent, EphemeralEvent, TimeInterval, IRuntimeSignaler, EphemeralTelemetryLogger } from '@microsoft/live-share';
@@ -14,6 +14,9 @@ import { GroupTransportStateEvents } from './GroupTransportState';
 import { GroupPlaybackTrackData, PlaybackTrackDataEvents, IPlaybackTrackData } from './GroupPlaybackTrackData';
 import { TelemetryEvents } from './consts';
 
+/**
+ * @hidden
+ */
 export interface IPositionUpdateEvent extends IEphemeralEvent {
     track: IPlaybackTrack;
     trackData: IPlaybackTrackData;
@@ -23,35 +26,53 @@ export interface IPositionUpdateEvent extends IEphemeralEvent {
     waitPoint?: CoordinationWaitPoint;
 }
 
+/**
+ * @hidden
+ */
 export interface ITransportCommandEvent extends IEphemeralEvent {
     track: IPlaybackTrack;
     position: number;
 }
 
+/**
+ * @hidden
+ */
 export interface ISetTrackEvent extends IEphemeralEvent {
     metadata: ExtendedMediaMetadata|null;
     waitPoints: CoordinationWaitPoint[];
 }
 
+/**
+ * @hidden
+ */
 export interface ISetTrackDataEvent extends IEphemeralEvent {
     data: object|null;
 }
 
-export interface ITriggerActionEvent extends IEvent {
+/**
+ * @hidden
+ */
+ export interface ITriggerActionEvent extends IEvent {
     details: ExtendedMediaSessionActionDetails;
 }
 
+/**
+ * @hidden
+ */
 export enum GroupCoordinatorStateEvents {
     newwaitpoint = 'newwaitpoint',
     triggeraction = 'triggeraction'
 }
 
-export class GroupCoordinatorState extends EventEmitter {
-    private readonly _runtime: IRuntimeSignaler; 
+/**
+ * @hidden
+ */
+ export class GroupCoordinatorState extends EventEmitter {
+    private readonly _runtime: IRuntimeSignaler;
     private readonly _logger: EphemeralTelemetryLogger;
     private readonly _maxPlaybackDrift: TimeInterval;
     private _getMediaPlayerState: () => IMediaPlayerState;
-    
+
     // Shared group state
     private _playbackTrack: GroupPlaybackTrack;
     private _playbackTrackData: GroupPlaybackTrackData;
@@ -65,7 +86,7 @@ export class GroupCoordinatorState extends EventEmitter {
     // "Soft Suspension" tracking
     // - Soft suspensions temporarily disconnect the local media session when transitioning between
     //   paused, playing, and none states. This is to give the local client time to finish any inprogress
-    //   operations like sending a transport command or ending a suspension.  
+    //   operations like sending a transport command or ending a suspension.
     private _lastStateChange: ExtendedMediaSessionPlaybackState = 'none';
     private _lastStateChangeTime: number = 0;
 
@@ -161,13 +182,13 @@ export class GroupCoordinatorState extends EventEmitter {
 
     public beginSuspension(waitPoint?: CoordinationWaitPoint): void {
         this._suspensionCnt++;
-    
+
         if (waitPoint) {
             // Save most recent wait point
             this._waitPoint = waitPoint;
 
             // Add to track state if dynamic wait point
-            this.playbackTrack.addWaitPoint(waitPoint); 
+            this.playbackTrack.addWaitPoint(waitPoint);
         }
     }
 
@@ -204,7 +225,7 @@ export class GroupCoordinatorState extends EventEmitter {
                 playbackState: this._waitPoint ? 'waiting' : playbackState,
                 position: positionState?.position || 0.0,
                 waitPoint: this._waitPoint
-            }; 
+            };
         }
     }
 
@@ -251,7 +272,7 @@ export class GroupCoordinatorState extends EventEmitter {
                 case 'pause':
                     playbackState = 'paused';
                     break;
-            } 
+            }
 
             // Try to update playback state
             const newState: ITransportState = {
@@ -312,7 +333,7 @@ export class GroupCoordinatorState extends EventEmitter {
                     // Begin a "soft suspension" on select state changes
                     // - This is needed because the catchup logic can try to sink the client with
                     //  the rest of the group while the local player is trying to to seek to a
-                    //  new position. 
+                    //  new position.
                     switch (event.playbackState) {
                         case 'none':
                         case 'paused':
@@ -349,7 +370,7 @@ export class GroupCoordinatorState extends EventEmitter {
         if (!this.isWaiting && softSuspensionDelta >= 1000) {
             let { metadata, trackData, positionState, playbackState } = this._getMediaPlayerState();
             this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.CheckingForSyncIssues);
-    
+
             // Check for track change
             if (!this.playbackTrack.compare(metadata)) {
                 this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.TrackOutOfSync);
@@ -359,7 +380,7 @@ export class GroupCoordinatorState extends EventEmitter {
 
             // Once local playback has ended there's no need to further sync the client. In fact
             // doing so could cause the player to loop.
-            // - The playbackPosition.trackEnded check is to catch late joiners and prevents syncing if everyone 
+            // - The playbackPosition.trackEnded check is to catch late joiners and prevents syncing if everyone
             //   else has finished the video.
             // - Should another user seek or press play after the video has ended that will cause
             //   a transport action to trigger which will take the player out of the ended state.
@@ -374,18 +395,18 @@ export class GroupCoordinatorState extends EventEmitter {
                 // - Target can return -1 in cases where there is no position tracking data
                 const target = this.playbackPosition.targetPosition;
                 if (target >= 0.0 && Math.abs(target - position) >= this._maxPlaybackDrift.seconds) {
-                    this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.PositionOutOfSync, null, { 
-                        current: position, 
-                        target: target 
+                    this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.PositionOutOfSync, null, {
+                        current: position,
+                        target: target
                     });
                     await this.emitTriggerAction({action: 'catchup', seekTime: target});
                 }
 
                 // Sync transport state
                 if (this.transportState.playbackState != playbackState) {
-                    this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.TransportOutOfSync, null, { 
+                    this._logger.sendTelemetryEvent(TelemetryEvents.GroupCoordinator.TransportOutOfSync, null, {
                         current: playbackState,
-                        target: this.transportState.playbackState  
+                        target: this.transportState.playbackState
                     });
                     switch (this.transportState.playbackState) {
                         case 'playing':

package/src/internals/GroupPlaybackPosition.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { EphemeralEvent, IRuntimeSignaler, TimeInterval } from '@microsoft/live-share';
@@ -8,7 +8,10 @@ import { GroupTransportState } from './GroupTransportState';
 import { GroupPlaybackTrackEvents } from './GroupPlaybackTrack';
 import { CoordinationWaitPoint, ExtendedMediaSessionPlaybackState } from '../MediaSessionExtensions';
 
-// Per client position
+/**
+ *Per client position
+ * @hidden
+ */
 export interface ICurrentPlaybackPosition {
     playbackState: ExtendedMediaSessionPlaybackState;
     waitPoint?: CoordinationWaitPoint
@@ -18,13 +21,16 @@ export interface ICurrentPlaybackPosition {
     clientId: string;
 }
 
+/**
+ * @hidden
+ */
 export class GroupPlaybackPosition {
     private _transportState: GroupTransportState;
     private _runtime: IRuntimeSignaler;
     private _updateInterval: TimeInterval;
     private _positions: Map<string, ICurrentPlaybackPosition>;
 
-    
+
     constructor(transportState: GroupTransportState, runtime: IRuntimeSignaler, updateInterval: TimeInterval) {
         this._transportState = transportState;
         this._runtime = runtime;
@@ -67,14 +73,14 @@ export class GroupPlaybackPosition {
                 case 'ended':
                     // not playing.
                     break;
-                default: 
+                default:
                     playing++;
                     break;
             }
         });
 
         return playing == 0;
-    } 
+    }
 
     /**
      * Returns the number of clients we're waiting for before we can stop waiting.
@@ -93,13 +99,13 @@ export class GroupPlaybackPosition {
         }
 
         return cnt;
-    } 
+    }
 
     /**
      * Returns the max playback position relative to the start position.
-     * 
+     *
      * @remarks
-     * This is called when calculating the current seekTo position. 
+     * This is called when calculating the current seekTo position.
      */
     public get maxPosition(): number {
         if (this._transportState.playbackState == 'playing') {
@@ -151,7 +157,7 @@ export class GroupPlaybackPosition {
         if (position.duration != undefined) {
             this.mediaDuration = position.duration;
         }
-        
+
         // Save last position
         if (this._positions.has(position.clientId)) {
             // Only update if newer position
@@ -166,7 +172,7 @@ export class GroupPlaybackPosition {
 
     private getMostProgressedPosition(): number {
         // Compute the max possible position for the current transport state.
-        // - This is needed to properly handle seeking backwards in time. Some playback heads may 
+        // - This is needed to properly handle seeking backwards in time. Some playback heads may
         //   not have performed their seek yet and will therefore be ahead of the local player.
         const maxPosition = this.maxPosition;
 

package/src/internals/GroupPlaybackTrack.ts

@@ -1,6 +1,6 @@
 /**
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
+ * Licensed under the Microsoft Live Share SDK License.
  */
 
 import { IEvent } from '@microsoft/live-share';
@@ -8,22 +8,35 @@ import EventEmitter from 'events';
 import { IMediaPlayerState } from '../EphemeralMediaSessionCoordinator';
 import { CoordinationWaitPoint, ExtendedMediaMetadata } from '../MediaSessionExtensions';
 
-export interface IPlaybackTrack {
+/**
+ * @hidden
+ */
+ export interface IPlaybackTrack {
     metadata: ExtendedMediaMetadata|null;
     waitPoints: CoordinationWaitPoint[];
     timestamp: number;
     clientId: string;
 }
 
-export enum GroupPlaybackTrackEvents {
+
+/**
+ * @hidden
+ */
+ export enum GroupPlaybackTrackEvents {
     trackChange = 'trackChange'
 }
 
-export interface IPlaybackTrackChangeEvent extends IEvent {
+/**
+ * @hidden
+ */
+ export interface IPlaybackTrackChangeEvent extends IEvent {
     metadata: ExtendedMediaMetadata|null;
 }
 
-export class GroupPlaybackTrack extends EventEmitter {
+/**
+ * @hidden
+ */
+ export class GroupPlaybackTrack extends EventEmitter {
     private readonly _getMediaPlayerState: () => IMediaPlayerState;
     private _current: IPlaybackTrack;
 
@@ -95,9 +108,9 @@ export class GroupPlaybackTrack extends EventEmitter {
             if (track.timestamp == current.timestamp && track.clientId == current.clientId) {
                 return false;
             }
-        }   
+        }
 
-        // Ignore state changes that are older 
+        // Ignore state changes that are older
         if (track.timestamp < current.timestamp) {
             return false;
         }
@@ -112,8 +125,8 @@ export class GroupPlaybackTrack extends EventEmitter {
         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;
     }