feat/room-music-player

.vscode/settings.json

@@ -16,8 +16,8 @@
   ],
   "typescript.surveys.enabled": false,
   "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": "explicit"
-    // "source.organizeImports": "explicit"
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "explicit"
   },
   "files.eol": "\n"
 }

backend/src/RoomStorage.ts

@@ -3,7 +3,8 @@ import Deezer from "./musicplatform/Deezer";
 import MusicPlatform from "./musicplatform/MusicPlatform";
 import SoundCloud from "./musicplatform/SoundCloud";
 import Spotify from "./musicplatform/Spotify";
-import { adminSupabase } from "./server";
+import { QueueableRemote } from "./musicplatform/remotes/Remote";
+import { adminSupabase, server } from "./server";
 import Room from "./socketio/Room";
 import { RoomWithForeignTable } from "./socketio/RoomDatabase";
 
@@ -12,6 +13,7 @@ const STREAMING_SERVICES = {
   SoundCloud: "c99631a2-f06c-4076-80c2-13428944c3a8",
   Deezer: "4f619f5d-4028-4724-87c4-f440df4659fe",
 };
+const MUSIC_ENDING_SOON_DELAY = 10000;
 
 function getMusicPlatform(serviceId: string): MusicPlatform | null {
   switch (serviceId) {
@@ -29,14 +31,94 @@ function getMusicPlatform(serviceId: string): MusicPlatform | null {
 export default class RoomStorage {
   private static singleton: RoomStorage;
   private readonly data: Map<string, Room>;
+  private readonly startedTimer: Map<string, boolean>;
 
   private constructor() {
     this.data = new Map();
+    this.startedTimer = new Map();
+  }
+
+  startTimer() {
+    setInterval(async () => {
+      const allRooms = await RoomStorage.getRoomStorage().getRooms();
+      allRooms.forEach(async (room) => {
+        const remote = room.getRemote();
+        if (!remote) return;
+
+        const lastKnownPlaybackState = room.getPlaybackState();
+        // Avoid spamming REST APIs
+        if (
+          lastKnownPlaybackState !== null &&
+          !room.getStreamingService().isClientSide()
+        ) {
+          if (Date.now() - lastKnownPlaybackState.updated_at < 5000) return;
+        }
+
+        // Fetching newest playback state and sending it to the room
+        const newPlaybackStateResponse = await remote.getPlaybackState();
+        server.io
+          .of(`/room/${room.uuid}`)
+          .emit("player:updatePlaybackState", newPlaybackStateResponse);
+
+        const newPlaybackState = newPlaybackStateResponse.data;
+        room.setPlaybackState(newPlaybackState);
+
+        if (!newPlaybackState) return console.debug("No music is playing");
+
+        const remainingTime =
+          newPlaybackState.duration - newPlaybackState.currentTime;
+        const hasTriggeredEndingSoonValue = this.startedTimer.get(room.uuid);
+
+        if (
+          remainingTime < MUSIC_ENDING_SOON_DELAY &&
+          !hasTriggeredEndingSoonValue &&
+          !(remote instanceof QueueableRemote)
+        ) {
+          console.debug(
+            `The track of the room ${room.uuid} is ending soon, and it doesn't support queueing`
+          );
+          this.startedTimer.set(room.uuid, true);
+
+          setTimeout(() => {
+            if (!newPlaybackStateResponse.data?.isPlaying)
+              return console.debug("The track is not playing anymore");
+            this.startedTimer.set(room.uuid, false);
+
+            const nextTrack = room.shiftQueue();
+            if (!nextTrack) return console.debug("No more tracks in the queue");
+
+            remote.playTrack(nextTrack.url);
+            console.debug(`The player will now play ${nextTrack.url}`);
+          }, remainingTime);
+        }
+
+        const previousPlaybackState = room.getPreviousPlaybackState();
+
+        // If the track has changed, we add the next track to the queue of the player
+        if (newPlaybackState.url != previousPlaybackState?.url) {
+          console.debug(`The track of room ${room.uuid} has changed`);
+
+          if (remote instanceof QueueableRemote) {
+            let nextTrack = room.getQueue().at(0);
+
+            if (nextTrack?.url === newPlaybackState.url) {
+              room.shiftQueue();
+              nextTrack = room.getQueue().at(0);
+            }
+            if (!nextTrack) return console.debug("No more tracks in the queue");
+
+            remote.addToQueue(nextTrack.url);
+            console.debug(`Just added ${nextTrack.url} to the queue`);
+          }
+        }
+      });
+    }, 1000);
   }
 
   static getRoomStorage(): RoomStorage {
     if (this.singleton === undefined) {
       this.singleton = new RoomStorage();
+      this.singleton.startTimer();
     }
     return this.singleton;
   }

backend/src/musicplatform/Deezer.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { JSONTrack } from "commons/backend-types";
 import MusicPlatform from "./MusicPlatform";
-import Remote from "./remotes/Remote";
+import { Remote } from "./remotes/Remote";
 import Room from "../socketio/Room";
 
 export default class Deezer extends MusicPlatform {

backend/src/musicplatform/MusicPlatform.ts

@@ -1,5 +1,5 @@
 import { JSONTrack } from "commons/backend-types";
-import Remote from "./remotes/Remote";
+import { Remote } from "./remotes/Remote";
 import Room from "../socketio/Room";
 
 export default abstract class MusicPlatform {

backend/src/musicplatform/SoundCloud.ts

@@ -1,7 +1,7 @@
-import { JSONTrack } from "commons/backend-types";
-import { Soundcloud, SoundcloudTrackV2 } from "soundcloud.ts";
+import { JSONTrack } from "commons/Backend-types";
+import Soundcloud, { SoundcloudTrackV2 } from "soundcloud.ts";
 import MusicPlatform from "./MusicPlatform";
-import Remote from "./remotes/Remote";
+import { Remote } from "./remotes/Remote";
 import SoundCloudRemote from "./remotes/SoundCloudRemote";
 import Room from "../socketio/Room";
 

backend/src/musicplatform/Spotify.ts

@@ -2,7 +2,7 @@
 import { JSONTrack } from "commons/backend-types";
 import { spotify } from "../server";
 import MusicPlatform from "./MusicPlatform";
-import Remote from "./remotes/Remote";
+import { Remote } from "./remotes/Remote";
 import SpotifyRemote from "./remotes/SpotifyRemote";
 import Room from "../socketio/Room";
 import { Track } from "@spotify/web-api-ts-sdk";

backend/src/musicplatform/remotes/Remote.ts

@@ -1,13 +1,18 @@
 import { JSONTrack, PlayingJSONTrack } from "commons/backend-types";
+import { Response } from "commons/socket.io-types";
 
-export default abstract class Remote {
-  abstract getPlaybackState(): Promise<PlayingJSONTrack | null>;
-  abstract getQueue(): Promise<JSONTrack[]>;
-  abstract playTrack(trackId: string): Promise<{ error?: string }>;
-  abstract setVolume(volume: number): Promise<void>;
-  abstract seekTo(position: number): Promise<void>;
-  abstract play(): Promise<void>;
-  abstract pause(): Promise<void>;
-  abstract previous(): Promise<void>;
-  abstract next(): Promise<void>;
+export abstract class Remote {
+  abstract getPlaybackState(): Promise<Response<PlayingJSONTrack | null>>;
+  abstract playTrack(trackId: string): Promise<Response<void>>;
+  abstract setVolume(volume: number): Promise<Response<void>>;
+  abstract seekTo(position: number): Promise<Response<void>>;
+  abstract play(): Promise<Response<void>>;
+  abstract pause(): Promise<Response<void>>;
+  abstract previous(): Promise<Response<void>>;
+  abstract next(): Promise<Response<void>>;
+}
+
+export abstract class QueueableRemote extends Remote {
+  abstract addToQueue(trackId: string): Promise<Response<void>>;
+  abstract getQueue(): Promise<Response<JSONTrack[]>>;
 }

backend/src/musicplatform/remotes/SoundCloudRemote.ts

@@ -1,6 +1,10 @@
 import { JSONTrack, PlayingJSONTrack } from "commons/backend-types";
 import MusicPlatform from "../MusicPlatform";
-import Remote from "./Remote";
+import { Remote } from "./Remote";
+import {
+  LocalPlayerServerToClientEvents,
+  Response,
+} from "commons/socket.io-types";
 import Room from "../../socketio/Room";
 
 export default class SoundCloudRemote extends Remote {
@@ -24,137 +28,57 @@ export default class SoundCloudRemote extends Remote {
     return this.room.getHostSocket();
   }
 
-  async getPlaybackState(): Promise<PlayingJSONTrack | null> {
-    const hostSocket = await this.getHostSocket();
+  async emitAndListen<T>(
+    event: keyof LocalPlayerServerToClientEvents,
+    data?: unknown
+  ): Promise<Response<T>> {
+    const hostSocket = this.getHostSocket();
     if (!hostSocket) {
-      return null;
+      return { data: null, error: "Host socket not available" };
     }
 
-    hostSocket.emit("player:getPlaybackState");
     return new Promise((resolve) => {
-      hostSocket.on(
-        "player:getPlaybackState",
-        (state: PlayingJSONTrack | null) => {
-          resolve(state);
-        }
-      );
+      const listener = (response: unknown) => {
+        hostSocket.off(event, listener);
+        resolve(response as never);
+      };
+
+      hostSocket.on(event, listener);
+      hostSocket.emit(event, data as never);
     });
   }
 
-  async getQueue(): Promise<JSONTrack[]> {
-    return [];
+  async getPlaybackState(): Promise<Response<PlayingJSONTrack | null>> {
+    return this.emitAndListen<PlayingJSONTrack | null>(
+      "player:playbackStateRequest"
+    );
   }
 
-  async playTrack(trackId: string): Promise<{ error?: string | undefined }> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return { error: "Host socket not available" };
-    }
-
-    hostSocket.emit("player:playTrack", trackId);
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:playTrack", (error: string | undefined) => {
-        if (error) {
-          resolve({ error });
-        } else {
-          resolve({});
-        }
-      });
-    });
+  async playTrack(trackId: string): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:playTrackRequest", trackId);
   }
 
-  async setVolume(volume: number): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:setVolume", {
-      volume,
-    });
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:setVolume", () => {
-        resolve();
-      });
-    });
+  async setVolume(volume: number): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:setVolumeRequest", volume);
   }
 
-  async seekTo(position: number): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:seekTo", {
-      position,
-    });
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:seekTo", () => {
-        resolve();
-      });
-    });
+  async seekTo(position: number): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:seekToRequest", position);
   }
 
-  async play(): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:play");
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:play", () => {
-        resolve();
-      });
-    });
+  async play(): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:playRequest");
   }
 
-  async pause(): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:pause");
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:pause", () => {
-        resolve();
-      });
-    });
+  async pause(): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:pauseRequest");
   }
 
-  async previous(): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:previous");
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:previous", () => {
-        resolve();
-      });
-    });
+  async previous(): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:previousRequest");
   }
 
-  async next(): Promise<void> {
-    const hostSocket = await this.getHostSocket();
-    if (!hostSocket) {
-      return;
-    }
-
-    hostSocket.emit("player:next");
-
-    return new Promise((resolve) => {
-      hostSocket.on("player:next", () => {
-        resolve();
-      });
-    });
+  async next(): Promise<Response<void>> {
+    return this.emitAndListen<void>("player:skipRequest");
   }
 }