@microsoft/live-share-media 2.0.0-internal.1 → 2.0.0-internal.10

package/src/LiveMediaSession.ts

@@ -3,35 +3,39 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { DataObjectFactory } from "@fluidframework/aqueduct";
+import { DataObjectFactory } from "@fluidframework/aqueduct/legacy";
 import {
-    DynamicObjectRegistry,
-    LiveDataObject,
     LiveDataObjectInitializeNotNeededError,
     LiveDataObjectInitializeState,
     LiveTelemetryLogger,
     UserMeetingRole,
 } from "@microsoft/live-share";
-import { MediaPlayerSynchronizer } from "./MediaPlayerSynchronizer";
-import { ITriggerActionEvent, TelemetryEvents } from "./internals";
+import {
+    DynamicObjectRegistry,
+    LiveDataObject,
+} from "@microsoft/live-share/internal";
+import { MediaPlayerSynchronizer } from "./MediaPlayerSynchronizer.js";
+import { ITriggerActionEvent } from "./internals/GroupCoordinatorState.js";
 import {
     MediaSessionCoordinatorEvents,
     ExtendedMediaSessionAction,
     ExtendedMediaSessionActionDetails,
     ExtendedMediaSessionActionHandler,
-} from "./MediaSessionExtensions";
+} from "./MediaSessionExtensions.js";
 import {
     LiveMediaSessionCoordinator,
     IMediaPlayerState,
-} from "./LiveMediaSessionCoordinator";
-import { MediaSessionActionThrottler } from "./MediaSessionActionThrottler";
-import { RepeatedActionThrottler } from "./RepeatedActionThrottler";
-import { IMediaPlayer } from "./IMediaPlayer";
+} from "./LiveMediaSessionCoordinator.js";
+import { MediaSessionActionThrottler } from "./MediaSessionActionThrottler.js";
+import { RepeatedActionThrottler } from "./RepeatedActionThrottler.js";
+import { IMediaPlayer } from "./IMediaPlayer.js";
+import { SharedObjectKind } from "fluid-framework";
+import { TelemetryEvents } from "./internals/consts.js";
 
 /**
  * Live fluid object that synchronizes media playback across multiple clients.
  */
-export class LiveMediaSession extends LiveDataObject {
+export class LiveMediaSessionClass extends LiveDataObject {
     private _actionThrottler: MediaSessionActionThrottler =
         new RepeatedActionThrottler();
     private _logger?: LiveTelemetryLogger;
@@ -56,8 +60,8 @@ export class LiveMediaSession extends LiveDataObject {
      * The objects fluid type factory.
      */
     public static readonly factory = new DataObjectFactory(
-        LiveMediaSession.TypeName,
-        LiveMediaSession,
+        LiveMediaSessionClass.TypeName,
+        LiveMediaSessionClass,
         [],
         {}
     );
@@ -341,7 +345,18 @@ export class LiveMediaSession extends LiveDataObject {
 }
 
 /**
- * Register `LiveMediaSession` as an available `LoadableObjectClass` for use in packages that support dynamic object loading, such as `@microsoft/live-share-turbo`.
+ * Live fluid object that synchronizes media playback across multiple clients.
+ */
+export type LiveMediaSession = LiveMediaSessionClass;
+
+// eslint-disable-next-line no-redeclare
+export const LiveMediaSession = (() => {
+    const kind = LiveMediaSessionClass;
+    return kind as typeof kind & SharedObjectKind<LiveMediaSessionClass>;
+})();
+
+/**
+ * Register `LiveMediaSession` as an available `SharedObjectKind` for use in dynamic object loading.
  */
 DynamicObjectRegistry.registerObjectClass(
     LiveMediaSession,

package/src/LiveMediaSessionCoordinator.ts

@@ -4,40 +4,46 @@
  */
 
 import {
-    LiveEventScope,
     LiveTelemetryLogger,
-    LiveEventTarget,
-    IRuntimeSignaler,
     TimeInterval,
     UserMeetingRole,
-    LiveShareRuntime,
     LiveDataObjectInitializeState,
     LiveDataObjectInitializeNotNeededError,
     LiveDataObjectNotInitializedError,
-    LiveObjectSynchronizer,
     ILiveEvent,
 } from "@microsoft/live-share";
+import {
+    IRuntimeSignaler,
+    LiveEventScope,
+    LiveEventTarget,
+    LiveObjectSynchronizer,
+    LiveShareRuntime,
+    isErrorLike,
+} from "@microsoft/live-share/internal";
 import {
     CoordinationWaitPoint,
     ExtendedMediaMetadata,
     ExtendedMediaSessionPlaybackState,
     MediaSessionCoordinatorSuspension,
-} from "./MediaSessionExtensions";
+} from "./MediaSessionExtensions.js";
 import {
-    TelemetryEvents,
     ITransportCommandEvent,
     ISetTrackEvent,
     IPositionUpdateEvent,
     GroupCoordinatorState,
     GroupCoordinatorStateEvents,
     ISetTrackDataEvent,
+    IRateChangeCommandEvent,
+} from "./internals/GroupCoordinatorState.js";
+import { TelemetryEvents } from "./internals/consts.js";
+import {
     TrackMetadataNotSetError,
     ActionBlockedError,
-    IRateChangeCommandEvent,
-} from "./internals";
-import { LiveMediaSessionCoordinatorSuspension } from "./LiveMediaSessionCoordinatorSuspension";
-import EventEmitter from "events";
-import { isErrorLike } from "@microsoft/live-share/bin/internals";
+} from "./internals/errors.js";
+import { PriorityTimeInterval } from "./internals/PriorityTimeInterval.js";
+import { LiveMediaSessionCoordinatorSuspension } from "./LiveMediaSessionCoordinatorSuspension.js";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { IEvent } from "@fluidframework/core-interfaces";
 
 /**
  * Most recent state of the media session.
@@ -67,19 +73,51 @@ export interface IMediaPlayerState {
     positionState?: MediaPositionState;
 }
 
+/**
+ * @hidden
+ */
+export interface ILiveMediaSessionCoordinatorEvents extends IEvent {
+    /**
+     * Event listener for events emitted
+     * @param event update
+     * @param listener listener function
+     * @param listener.event the event instance
+     */
+    (event: string, listener: (event: any) => void): void;
+}
+
 /**
  * The `LiveMediaSessionCoordinator` tracks the playback & position state of all other
  * clients being synchronized with. It is responsible for keeping the local media player
  * in sync with the group.
  */
-export class LiveMediaSessionCoordinator extends EventEmitter {
+export class LiveMediaSessionCoordinator extends TypedEventEmitter<ILiveMediaSessionCoordinatorEvents> {
     private readonly _id: string;
     private readonly _runtime: IRuntimeSignaler;
     private readonly _liveRuntime: LiveShareRuntime;
     private readonly _logger: LiveTelemetryLogger;
     private readonly _getPlayerState: () => IMediaPlayerState;
-    private _positionUpdateInterval = new TimeInterval(2000);
-    private _maxPlaybackDrift = new TimeInterval(1000);
+    private _positionUpdateInterval = new PriorityTimeInterval(
+        2000,
+        // Scale by function
+        () => {
+            const audience = this._liveRuntime.audience;
+            if (!audience) return 1;
+            // As the audience size gets bigger, we relax the update interval, since more variance is expected
+            const count = audience.getMembers().size;
+            return 1 + count / 5;
+        }
+    );
+    private _maxPlaybackDrift = new PriorityTimeInterval(
+        1500, // Scale by function
+        () => {
+            const audience = this._liveRuntime.audience;
+            if (!audience) return 1;
+            // As the audience size gets bigger, we relax the playback drift, since more variance is expected
+            const count = audience.getMembers().size;
+            return 1 + count / 25;
+        }
+    );
     private _lastWaitPoint?: CoordinationWaitPoint;
     private initializeState: LiveDataObjectInitializeState =
         LiveDataObjectInitializeState.needed;
@@ -203,13 +241,29 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
     }
 
     /**
-     * Max amount of playback drift allowed in seconds.
+     * Controls whether or not to scale {@link maxPlaybackDrift} by the number of users in the session.
      *
      * @remarks
-     * Should the local clients playback position lag by more than the specified value, the
-     * coordinator will trigger a `catchup` action.
+     * As more clients join a session, it is more likely that some users will fall behind the presenter.
+     * It is also less likely that users will notice drift as more clients are added.
+     * It is usually helpful to be more lenient as more clients are added so everyone can watch all the content.
+     * Default value is true.
+     */
+    public get shouldScaleMaxPlaybackDrift(): boolean {
+        return this._maxPlaybackDrift.shouldPrioritize;
+    }
+
+    public set shouldScaleMaxPlaybackDrift(value: boolean) {
+        this._maxPlaybackDrift.shouldPrioritize = value;
+    }
+
+    /**
+     * Max amount of playback drift allowed in seconds.
+     * This will scale automatically according to the number of participants in the session when {@link shouldScaleMaxPlaybackDrift} is true.
      *
-     * Defaults to a value of `1` second.
+     * @remarks
+     * Should the local clients playback position lag by more than the specified value, the coordinator will trigger a `catchup` action.
+     * Default value is `1.5` seconds.
      */
     public get maxPlaybackDrift(): number {
         return this._maxPlaybackDrift.seconds;
@@ -220,11 +274,30 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
     }
 
     /**
-     * Frequency with which position updates are broadcast to the rest of the group in
-     * seconds.
+     * Controls whether or not to compute {@link positionUpdateInterval} based on whether user has initiated a playback command.
+     * Default value is true.
      *
      * @remarks
-     * Defaults to a value of `2` seconds.
+     * When true, users that are simply watching but not controlling playback will report their positions less frequently.
+     * When a user has sent a transport command, they will begin sending position updates more frequently.
+     * Most Live Share apps have a concept of a primary presenter, and don't allow anyone to pause/play for the group.
+     * By ensuring only one/few users broadcast updates frequently, the server load is reduced considerably.
+     */
+    public get shouldScalePositionUpdateInterval(): boolean {
+        return this._positionUpdateInterval.shouldPrioritize;
+    }
+
+    public set shouldScalePositionUpdateInterval(value: boolean) {
+        this._positionUpdateInterval.shouldPrioritize = value;
+    }
+
+    /**
+     * Frequency with which position updates are broadcast to the rest of the group in seconds.
+     * When {@link shouldScalePositionUpdateInterval} is set to `true`, the value set is the minimum value.
+     * The value returned is the actual value used to send updates by the local user, which may be larger than the value set.
+     *
+     * @remarks
+     * Defaults to a minimum value of `2` seconds.
      */
     public get positionUpdateInterval(): number {
         return this._positionUpdateInterval.seconds;
@@ -274,6 +347,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             track: this._groupState.playbackTrack.current,
             position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -316,6 +393,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             track: this._groupState.playbackTrack.current,
             position: position,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -356,12 +437,24 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
                 track: this._groupState.playbackTrack.current,
                 position: time,
             });
+            if (this.canSendPositionUpdates) {
+                // User has taken initiative to send event, give priority for sending position updates
+                this._positionUpdateInterval.hasPriority = true;
+            }
         } catch (err) {
             await this._groupState!.syncLocalMediaSession();
             throw err;
         }
     }
 
+    /**
+     * Sets the playback rate for everyone in the session.
+     *
+     * @param playbackRate the playback rate to set.
+     *
+     * @throws
+     * Throws an exception if the session/coordinator hasn't been initialized or {@link canSetPlaybackRate} is false.
+     */
     public async setPlaybackRate(playbackRate: number): Promise<void> {
         LiveDataObjectNotInitializedError.assert(
             "LiveMediaSessionCoordinator:setPlaybackRate",
@@ -381,6 +474,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             { playbackRate }
         );
         await this._rateChangeEvent!.sendEvent({ playbackRate });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -417,6 +514,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             metadata: metadata,
             waitPoints: waitPoints || [],
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -451,6 +552,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
         await this._setTrackDataEvent!.sendEvent({
             data: data,
         });
+        if (this.canSendPositionUpdates) {
+            // User has taken initiative to send event, give priority for sending position updates
+            this._positionUpdateInterval.hasPriority = true;
+        }
     }
 
     /**
@@ -570,13 +675,12 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
 
         try {
             // start needs to happen after setting initializedState to "succeeded"
-            await this._synchronizer?.start(
-                undefined,
-                async (evt, sender, local) => false,
-                async (connecting) => true,
-                false,
-                false
-            );
+            await this._synchronizer?.start({
+                initialState: undefined,
+                updateState: async (evt, sender, local) => false,
+                getLocalUserCanSend: async (connecting) => true,
+                enableBackgroundUpdates: false,
+            });
         } catch (error: unknown) {
             // not a fatal error for LiveMediaSession, only used for "connect" event to send new clients position updates.
             this._logger.sendErrorEvent(
@@ -603,7 +707,10 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
      * @hidden
      * Called by MediaSession to trigger the sending of a position update.
      */
-    public sendPositionUpdate(state: IMediaPlayerState): void {
+    public sendPositionUpdate(
+        state: IMediaPlayerState,
+        targetClientId?: string
+    ): void {
         LiveDataObjectNotInitializedError.assert(
             "LiveMediaSessionCoordinator:sendPositionUpdate",
             "sendPositionUpdate",
@@ -613,12 +720,15 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
         if (this.canSendPositionUpdates) {
             // Send position update event
             const evt = this._groupState!.createPositionUpdateEvent(state);
-            this._positionUpdateEvent?.sendEvent(evt).catch((err) => {
-                this._logger.sendErrorEvent(
-                    TelemetryEvents.SessionCoordinator.PositionUpdateEventError,
-                    err
-                );
-            });
+            this._positionUpdateEvent
+                ?.sendEvent(evt, targetClientId)
+                .catch((err) => {
+                    this._logger.sendErrorEvent(
+                        TelemetryEvents.SessionCoordinator
+                            .PositionUpdateEventError,
+                        err
+                    );
+                });
         } else if (this.isSuspended) {
             // send a local only position update event that was not sent as a signal, and use to handle local
             // position update for clients that have canSendPositionUpdates==false, but are suspending
@@ -730,7 +840,9 @@ export class LiveMediaSessionCoordinator extends EventEmitter {
             // Immediately send a position update
             try {
                 const state = this._getPlayerState();
-                this.sendPositionUpdate(state);
+                // Send only to the user that joined the session using the targetClientId prop.
+                // This ensures that only the user that connected receives this one-time position update, minimizing costs.
+                this.sendPositionUpdate(state, clientId);
             } catch (err: any) {
                 // if player is not setup yet, local client might have also just joined and can't send its position.
                 const playerNotSetup =

package/src/LiveMediaSessionCoordinatorSuspension.ts

@@ -6,7 +6,7 @@
 import {
     MediaSessionCoordinatorSuspension,
     CoordinationWaitPoint,
-} from "./MediaSessionExtensions";
+} from "./MediaSessionExtensions.js";
 
 export class LiveMediaSessionCoordinatorSuspension
     implements MediaSessionCoordinatorSuspension

package/src/MediaPlayerSynchronizer.ts

@@ -2,12 +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";
+    waitUntilConnected,
+} from "@microsoft/live-share/internal";
 import {
     ExtendedMediaSessionAction,
     ExtendedMediaSessionPlaybackState,
@@ -16,12 +15,14 @@ import {
     ExtendedMediaSessionActionDetails,
     MediaSessionCoordinatorEvents,
     MediaSessionCoordinatorSuspension,
-} from "./MediaSessionExtensions";
-import { VolumeManager } from "./VolumeManager";
-import { LiveMediaSession } from "./LiveMediaSession";
-import { IMediaPlayer } from "./IMediaPlayer";
-import { ITriggerActionEvent, TelemetryEvents } from "./internals";
-import { waitUntilConnected } from "@microsoft/live-share/bin/internals";
+} from "./MediaSessionExtensions.js";
+import { VolumeManager } from "./VolumeManager.js";
+import { LiveMediaSession } from "./LiveMediaSession.js";
+import { IMediaPlayer } from "./IMediaPlayer.js";
+import { TelemetryEvents } from "./internals/consts.js";
+import { ITriggerActionEvent } from "./internals/GroupCoordinatorState.js";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { IEvent } from "@fluidframework/core-interfaces";
 
 /**
  * Event data returned by `MediaPlayerSynchronizer` object.
@@ -49,6 +50,20 @@ export enum MediaPlayerSynchronizerEvents {
     useraction = "useraction",
 }
 
+/**
+ * @hidden
+ * Emitted events from the `MediaPlayerSynchronizer` class.
+ */
+export interface IMediaPlayerSynchronizerEvents extends IEvent {
+    /**
+     * Event listener for events emitted
+     * @param event update
+     * @param listener listener function
+     * @param listener.event the event instance
+     */
+    (event: string, listener: (event: any) => void): void;
+}
+
 /**
  * Synchronizes a local HTML Media Element with a group of remote HTML Media Elements.
  *
@@ -58,7 +73,7 @@ export enum MediaPlayerSynchronizerEvents {
  * to the local player. When the group session is joined the commands will be broadcast to the
  * group in addition to being applied to the local player.
  */
-export class MediaPlayerSynchronizer extends EventEmitter {
+export class MediaPlayerSynchronizer extends TypedEventEmitter<IMediaPlayerSynchronizerEvents> {
     private static SESSION_ACTIONS: ExtendedMediaSessionAction[] = [
         "play",
         "pause",

package/src/MediaSessionActionThrottler.ts

@@ -6,7 +6,7 @@
 import {
     ExtendedMediaSessionActionDetails,
     ExtendedMediaSessionActionHandler,
-} from "./MediaSessionExtensions";
+} from "./MediaSessionExtensions.js";
 
 /**
  * Base class for action throttlers.

package/src/RepeatedActionThrottler.ts

@@ -4,11 +4,11 @@
  */
 
 import { TimeInterval } from "@microsoft/live-share";
-import { MediaSessionActionThrottler } from "./MediaSessionActionThrottler";
+import { MediaSessionActionThrottler } from "./MediaSessionActionThrottler.js";
 import {
     ExtendedMediaSessionActionDetails,
     ExtendedMediaSessionAction,
-} from "./MediaSessionExtensions";
+} from "./MediaSessionExtensions.js";
 
 /**
  *  A Throttler that passes through all actions but will only let an action be repeated once every 2 seconds.

package/src/VolumeManager.ts

@@ -4,7 +4,7 @@
  */
 
 import { TimeInterval } from "@microsoft/live-share";
-import { IMediaPlayer } from "./IMediaPlayer";
+import { IMediaPlayer } from "./IMediaPlayer.js";
 
 export enum LimitLevelType {
     fixed,
@@ -61,12 +61,12 @@ export class VolumeManager {
      *
      * @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.1.
+     * @see LimitLevelType. The default value is 0.1.
      *
-     * For a level type of `LevelType.fixed` the value is the exact level the volume will be
+     * For a level type of @see LimitLevelType.fixed the value is the exact level the volume will be
      * lowered to. The default value of 0.1 would cause the volume to be lowered to 0.1.
      *
-     * For a level type of `LevelType.percentage` the value is the percentage by which the volume
+     * For a level type of @see LimitLevelType.percentage the value is the percentage by which the volume
      * level should be lowered to. The default value of 0.1 would cause the volume to be lowered
      * to 10% of its starting value.
      */
@@ -118,8 +118,8 @@ export class VolumeManager {
 
     /**
      * Limits volume based on `limitLevel` and `limitLevelType` properties.
-     * @see `limitLevel`
-     * @see `limitLevelType`
+     * @see limitLevel
+     * @see limitLevelType
      */
     public startLimiting(): void {
         this._isLimiting = true;

package/src/index.ts

@@ -3,12 +3,12 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-export * from "./LiveMediaSession";
-export * from "./LiveMediaSessionCoordinator";
-export * from "./LiveMediaSessionCoordinatorSuspension";
-export * from "./IMediaPlayer";
-export * from "./MediaPlayerSynchronizer";
-export * from "./MediaSessionActionThrottler";
-export * from "./MediaSessionExtensions";
-export * from "./RepeatedActionThrottler";
-export * from "./VolumeManager";
+export * from "./LiveMediaSession.js";
+export * from "./LiveMediaSessionCoordinator.js";
+export * from "./LiveMediaSessionCoordinatorSuspension.js";
+export * from "./IMediaPlayer.js";
+export * from "./MediaPlayerSynchronizer.js";
+export * from "./MediaSessionActionThrottler.js";
+export * from "./MediaSessionExtensions.js";
+export * from "./RepeatedActionThrottler.js";
+export * from "./VolumeManager.js";

package/src/internals/GroupCoordinatorState.ts

@@ -6,50 +6,54 @@
 import {
     ILiveEvent,
     TimeInterval,
-    IRuntimeSignaler,
     LiveTelemetryLogger,
-    LiveShareRuntime,
     IEvent,
 } from "@microsoft/live-share";
-import EventEmitter from "events";
+import {
+    IRuntimeSignaler,
+    LiveShareRuntime,
+    waitUntilConnected,
+} from "@microsoft/live-share/internal";
 import {
     ExtendedMediaMetadata,
     CoordinationWaitPoint,
     ExtendedMediaSessionPlaybackState,
     ExtendedMediaSessionActionDetails,
     ExtendedMediaSessionActionSource,
-} from "../MediaSessionExtensions";
+} from "../MediaSessionExtensions.js";
 import {
     GroupPlaybackTrack,
     GroupPlaybackTrackEvents,
     IPlaybackTrack,
     IPlaybackTrackChangeEvent,
-} from "./GroupPlaybackTrack";
+} from "./GroupPlaybackTrack.js";
 import {
     GroupTransportState,
     ITransportState,
     ITransportStateChangeEvent,
-} from "./GroupTransportState";
+} from "./GroupTransportState.js";
 import {
     GroupPlaybackPosition,
     ICurrentPlaybackPosition,
-} from "./GroupPlaybackPosition";
-import { IMediaPlayerState } from "../LiveMediaSessionCoordinator";
-import { GroupTransportStateEvents } from "./GroupTransportState";
+} from "./GroupPlaybackPosition.js";
+import { IMediaPlayerState } from "../LiveMediaSessionCoordinator.js";
+import { GroupTransportStateEvents } from "./GroupTransportState.js";
 import {
     GroupPlaybackTrackData,
     PlaybackTrackDataEvents,
     IPlaybackTrackData,
     IPlaybackTrackDataChangeEvent,
-} from "./GroupPlaybackTrackData";
-import { TelemetryEvents } from "./consts";
-import { waitUntilConnected } from "@microsoft/live-share/bin/internals";
+} from "./GroupPlaybackTrackData.js";
+import { TelemetryEvents } from "./consts.js";
 import {
     GroupPlaybackRate,
     IPlaybackRate,
     IPlaybackRateChangeEvent,
     PlaybackRateEvents,
-} from "./GroupPlaybackRate";
+} from "./GroupPlaybackRate.js";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { IGenericTypedEvents } from "./interfaces.js";
+import { PriorityTimeInterval } from "./PriorityTimeInterval.js";
 
 /**
  * @hidden
@@ -113,7 +117,7 @@ export enum GroupCoordinatorStateEvents {
 /**
  * @hidden
  */
-export class GroupCoordinatorState extends EventEmitter {
+export class GroupCoordinatorState extends TypedEventEmitter<IGenericTypedEvents> {
     private readonly _runtime: IRuntimeSignaler;
     private readonly _liveRuntime: LiveShareRuntime;
     private readonly _logger: LiveTelemetryLogger;
@@ -142,7 +146,7 @@ export class GroupCoordinatorState extends EventEmitter {
         runtime: IRuntimeSignaler,
         liveRuntime: LiveShareRuntime,
         maxPlaybackDrift: TimeInterval,
-        positionUpdateInterval: TimeInterval,
+        positionUpdateInterval: PriorityTimeInterval,
         getMediaPlayerState: () => IMediaPlayerState
     ) {
         super();