Synchronized now playing state on outside promise

Author: davidvedvick

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/playback/engine/PlaybackEngine.kt

@@ -22,7 +22,7 @@ import com.lasthopesoftware.bluewater.client.playback.nowplaying.storage.ManageN
 import com.lasthopesoftware.bluewater.client.playback.nowplaying.storage.NowPlaying
 import com.lasthopesoftware.bluewater.client.playback.playlist.ManagePlaylistPlayback
 import com.lasthopesoftware.bluewater.shared.lazyLogger
-import com.lasthopesoftware.policies.ratelimiting.PromisingRateLimiter
+import com.lasthopesoftware.bluewater.shared.tryUpdate
 import com.lasthopesoftware.promises.ContinuingResult
 import com.lasthopesoftware.promises.extensions.ProgressingPromise
 import com.lasthopesoftware.promises.extensions.keepPromise
@@ -69,7 +69,7 @@ class PlaybackEngine(
 
 	private val activeLibraryId = AtomicReference(markerLibraryId)
 
-	private val nowPlayingStateSync = PromisingRateLimiter<NowPlaying?>(1)
+	private val promisedNowPlayingState = AtomicReference(Promise.empty<NowPlaying?>())
 
 	private val promisedPlayback = AtomicReference<ProgressingPromise<PositionedPlayingFile, Unit>?>(null)
 
@@ -480,13 +480,9 @@ class PlaybackEngine(
 		return playlistPlayback.resume()
 	}
 
-	private fun serializedPlayerUpdate() = nowPlayingStateSync.limit {
-		playbackBootstrapper.updateFromState(activeLibraryId.get())
-	}
+	private fun serializedPlayerUpdate() = updateStateSynchronously { playbackBootstrapper.updateFromState(activeLibraryId.get()) }
 
-	private fun promiseActiveNowPlaying() = nowPlayingStateSync.limit {
-		nowPlayingRepository.promiseNowPlaying(activeLibraryId.get())
-	}
+	private fun promiseActiveNowPlaying() = updateStateSynchronously { nowPlayingRepository.promiseNowPlaying(activeLibraryId.get()) }
 
 	private fun saveState(
 		libraryId: LibraryId,
@@ -508,7 +504,7 @@ class PlaybackEngine(
 	private inline fun saveState(
 		libraryId: LibraryId,
 		crossinline updateFunc: NowPlaying.() -> NowPlaying
-	): Promise<NowPlaying?> = nowPlayingStateSync.limit {
+	): Promise<NowPlaying?> = updateStateSynchronously {
 		nowPlayingRepository.promiseNowPlaying(libraryId).eventually {
 			it?.let { np ->
 				val updatedNowPlaying = updateFunc(np)
@@ -519,7 +515,24 @@ class PlaybackEngine(
 	}
 
 	@Suppress("UNCHECKED_CAST")
-	private fun saveState(nowPlaying: NowPlaying): Promise<NowPlaying?> = nowPlayingStateSync.limit {
+	private fun saveState(nowPlaying: NowPlaying): Promise<NowPlaying?> = updateStateSynchronously {
 		nowPlayingRepository.updateNowPlaying(nowPlaying) as Promise<NowPlaying?>
 	}
+
+	/**
+     * Updates the `promisedNowPlayingState` with the result of the provided `updateFunc`.
+     *
+     * This function ensures that the `promisedNowPlayingState` is updated synchronously.
+     * Each new update is chained to the previous promise, guaranteeing that state
+     * updates are applied in the order they are initiated.
+     *
+     * @param updateFunc A function that returns a [Promise] for a nullable [NowPlaying] state.
+     *   This function is responsible for fetching or modifying the state.
+     * @return A [Promise] that resolves with the current [NowPlaying] state after the update
+     *   function has been scheduled. To wait for the update to complete, chain to the returned promise.
+     */
+    private inline fun updateStateSynchronously(crossinline updateFunc: () -> Promise<NowPlaying?>): Promise<NowPlaying?> {
+		promisedNowPlayingState.tryUpdate { prev -> prev.eventually { updateFunc() } }
+		return promisedNowPlayingState.get()
+	}
 }