Merge pull request #552 from namehillsoftware/bugfix/empty-connection-settings

[Bugfix] Empty Connection Settings

Author: davidvedvick

projectBlueWater/build.gradle

@@ -199,7 +199,7 @@ dependencies {
 	implementation "androidx.media3:media3-datasource-okhttp:$media3_version"
 	implementation 'com.squareup.okio:okio:3.10.2'
 	implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.14'
-	implementation 'com.namehillsoftware:querydroid:0.5.0'
+	implementation 'com.namehillsoftware:querydroid:0.5.2'
 	implementation "androidx.compose.ui:ui:$compose_version"
 	implementation "androidx.compose.material:material:$compose_version"
 	implementation "androidx.compose.ui:ui-tooling:$compose_version"

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/browsing/library/access/LibraryRepository.kt

@@ -103,20 +103,17 @@ class LibraryRepository(private val context: Context) : ManageLibraries, Provide
 			if (cancellationSignal.isCancelled) throw CancellationException("Cancelled while saving library")
 
 			return RepositoryAccessHelper(context).use { repositoryAccessHelper ->
-				repositoryAccessHelper.beginTransaction().use { closeableTransaction ->
-					val isLibraryExists = library.id > -1
+				val isLibraryExists = library.id > -1
 
-					val returnLibrary =
-						if (isLibraryExists) repositoryAccessHelper.update(tableName, library)
-						else repositoryAccessHelper.insert(tableName, library)
+				val returnLibrary =
+					if (isLibraryExists) repositoryAccessHelper.update(tableName, library)
+					else repositoryAccessHelper.insert(tableName, library)
 
-					if (BuildConfig.DEBUG) {
-						logger.debug("Library saved.")
-					}
-
-					closeableTransaction.setTransactionSuccessful()
-					returnLibrary
+				if (BuildConfig.DEBUG) {
+					logger.debug("Library saved.")
 				}
+
+				returnLibrary
 			}
 		}
 	}
@@ -137,18 +134,14 @@ class LibraryRepository(private val context: Context) : ManageLibraries, Provide
 			if (libraryInt < 0) return
 
 			RepositoryAccessHelper(context).use { repositoryAccessHelper ->
-				repositoryAccessHelper.beginTransaction().use { closeableTransaction ->
-					val result = SqLiteAssistants.updateValue(repositoryAccessHelper.writableDatabase, tableName, values)
+				val result = SqLiteAssistants.updateValue(repositoryAccessHelper.writableDatabase, tableName, values)
 
-					if (result == 0L) {
-						throw IOException("Updating $tableName for id ${values.id} returned 0 rows.")
-					}
-
-					if (BuildConfig.DEBUG) {
-						logger.debug("Now Playing updated for library {}.", libraryInt)
-					}
+				if (result == 0L) {
+					throw IOException("Updating $tableName for id ${values.id} returned 0 rows.")
+				}
 
-					closeableTransaction.setTransactionSuccessful()
+				if (BuildConfig.DEBUG) {
+					logger.debug("Now Playing updated for library {}.", libraryInt)
 				}
 			}
 		}

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

@@ -1,6 +1,5 @@
 package com.lasthopesoftware.bluewater.client.playback.engine
 
-import androidx.lifecycle.AtomicReference
 import com.lasthopesoftware.bluewater.client.browsing.files.ServiceFile
 import com.lasthopesoftware.bluewater.client.browsing.library.repository.LibraryId
 import com.lasthopesoftware.bluewater.client.playback.engine.bootstrap.BootstrapPlayback
@@ -35,6 +34,7 @@ import com.namehillsoftware.handoff.promises.Promise
 import org.jetbrains.annotations.Contract
 import org.joda.time.Duration
 import java.util.concurrent.CancellationException
+import java.util.concurrent.atomic.AtomicReference
 import kotlin.math.max
 
 class PlaybackEngine(

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

@@ -1,6 +1,5 @@
 package com.lasthopesoftware.bluewater.client.playback.engine.bootstrap
 
-import androidx.lifecycle.AtomicReference
 import com.lasthopesoftware.bluewater.client.browsing.library.repository.LibraryId
 import com.lasthopesoftware.bluewater.client.playback.engine.preparation.ManagePlaybackQueues
 import com.lasthopesoftware.bluewater.client.playback.file.PositionedPlayableFile
@@ -18,6 +17,7 @@ import com.lasthopesoftware.promises.extensions.toPromise
 import com.lasthopesoftware.resources.closables.PromisingCloseable
 import com.namehillsoftware.handoff.promises.Promise
 import org.joda.time.Duration
+import java.util.concurrent.atomic.AtomicReference
 
 class ManagedPlaylistPlayer(
 	private val volumeManagement: PlaylistVolumeManager,

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/playback/file/exoplayer/ExoPlayerPlaybackHandler.kt

@@ -1,7 +1,6 @@
 package com.lasthopesoftware.bluewater.client.playback.file.exoplayer
 
 import androidx.annotation.OptIn
-import androidx.lifecycle.AtomicReference
 import androidx.media3.common.ParserException
 import androidx.media3.common.PlaybackException
 import androidx.media3.common.Player
@@ -24,6 +23,7 @@ import org.joda.time.Duration
 import org.joda.time.format.PeriodFormatterBuilder
 import java.io.EOFException
 import java.net.ProtocolException
+import java.util.concurrent.atomic.AtomicReference
 import kotlin.coroutines.cancellation.CancellationException
 
 class ExoPlayerPlaybackHandler(private val exoPlayer: PromisingExoPlayer) :

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/shared/android/ui/UiCalculations.kt

@@ -1,11 +1,5 @@
 package com.lasthopesoftware.bluewater.shared.android.ui
 
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.gestures.AnchoredDraggableState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.State
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.ui.unit.Dp
 
 fun linearInterpolation(initial: Dp, final: Dp, progress: Float): Dp =
@@ -16,8 +10,3 @@ fun linearInterpolation(initial: Float, final: Float, progress: Float): Float =
 
 fun calculateProgress(initial: Float, final: Float, currentPosition: Float): Float =
 	((currentPosition - initial) / (final - initial)).coerceIn(0f, 1f)
-
-@OptIn(ExperimentalFoundationApi::class)
-val <T> AnchoredDraggableState<T>.absoluteProgressState: State<Float>
-	@Composable
-	get() = remember { derivedStateOf { (requireOffset() - anchors.minAnchor()) / anchors.maxAnchor() } }

projectBlueWater/src/test/java/com/lasthopesoftware/bluewater/client/playback/engine/GivenAPlayingPlaybackEngine/AndPlaybackErrors/When Playback is Resumed.kt

@@ -20,6 +20,7 @@ import com.lasthopesoftware.bluewater.client.playback.nowplaying.storage.NowPlay
 import com.lasthopesoftware.bluewater.client.playback.nowplaying.storage.NowPlayingRepository
 import com.lasthopesoftware.bluewater.client.playback.volume.PlaylistVolumeManager
 import com.lasthopesoftware.bluewater.shared.promises.extensions.toExpiringFuture
+import com.lasthopesoftware.promises.extensions.toPromise
 import com.namehillsoftware.handoff.Messenger
 import com.namehillsoftware.handoff.promises.Promise
 import io.mockk.every
@@ -35,12 +36,28 @@ class `When Playback is Resumed` {
 	private val finalPlaybackPreparer = FinalPlaybackPreparer()
 
 	private val mut by lazy {
-		val deferredPlaybackPreparer = DeferredPlaybackPreparer()
-
 		val fakePlaybackPreparerProvider = mockk<IPlayableFilePreparationSourceProvider> {
-			every { providePlayableFilePreparationSource() } returns deferredPlaybackPreparer andThen finalPlaybackPreparer
-
-			every { maxQueueSize } returns 1
+			every { providePlayableFilePreparationSource() } returns mockk {
+				every { promisePreparedPlaybackFile(LibraryId(libraryId), ServiceFile("1"), Duration.ZERO) } returns
+					FakePreparedPlayableFile(
+						ResolvablePlaybackHandler().apply { resolve() }
+					).toPromise()
+
+				every { promisePreparedPlaybackFile(LibraryId(libraryId), ServiceFile("2"), Duration.ZERO) } returns
+					FakePreparedPlayableFile(
+						ResolvablePlaybackHandler().apply { resolve() }
+					).toPromise()
+
+				every { promisePreparedPlaybackFile(LibraryId(libraryId), ServiceFile("3"), Duration.ZERO) } returns
+					FakePreparedPlayableFile(
+						ResolvablePlaybackHandler().apply {
+							setCurrentPosition(164)
+							reject(Exception("f"))
+						}
+					).toPromise()
+			} andThen finalPlaybackPreparer
+
+			every { maxQueueSize } returns 0
 		}
 
 		val library = Library(id = libraryId)
@@ -69,7 +86,7 @@ class `When Playback is Resumed` {
 			playbackBootstrapper,
 		)
 
-		Triple(deferredPlaybackPreparer, nowPlayingRepository, playbackEngine)
+		Pair(nowPlayingRepository, playbackEngine)
 	}
 
 	private var error: PlaybackException? = null
@@ -79,13 +96,15 @@ class `When Playback is Resumed` {
 
 	@BeforeAll
 	fun act() {
-		val (deferredErrorPlaybackPreparer, nowPlayingRepository, playbackEngine) = mut
+		val (nowPlayingRepository, playbackEngine) = mut
 
 		val promisedError = Promise {
 			playbackEngine
 				.setOnPlaylistError { e ->
 					if (e is PlaybackException) {
 						it.sendResolution(e)
+					} else {
+						it.sendRejection(e)
 					}
 				}
 		}
@@ -105,14 +124,6 @@ class `When Playback is Resumed` {
 			.toExpiringFuture()
 			.get()
 
-		deferredErrorPlaybackPreparer.resolve().resolve()
-
-		deferredErrorPlaybackPreparer.resolve().resolve()
-		with (deferredErrorPlaybackPreparer.resolve()) {
-			setCurrentPosition(164)
-			reject(Exception("f"))
-		}
-
 		error = promisedError.toExpiringFuture().get()
 		nowPlaying = nowPlayingRepository.promiseNowPlaying(LibraryId(libraryId)).toExpiringFuture().get()
 		isPlayingBeforeResume = playbackEngine.isPlaying
@@ -122,10 +133,10 @@ class `When Playback is Resumed` {
 				.setOnPlayingFileChanged { _, p ->
 					it.sendResolution(p)
 				}
-		}
 
-		playbackEngine.resume().toExpiringFuture().get()
-		finalPlaybackPreparer.resolve()
+			playbackEngine.resume().toExpiringFuture().get()
+			finalPlaybackPreparer.resolve()
+		}
 
 		positionedPlayingFile = promisedFile.toExpiringFuture().get()
 	}
@@ -155,23 +166,6 @@ class `When Playback is Resumed` {
 		assertThat(isPlayingBeforeResume).isFalse()
 	}
 
-	private open class DeferredPlaybackPreparer : PlayableFilePreparationSource {
-		private var messenger: Messenger<PreparedPlayableFile?>? = null
-
-		fun resolve(): ResolvablePlaybackHandler {
-			val playbackHandler = ResolvablePlaybackHandler()
-			messenger?.sendResolution(FakePreparedPlayableFile(playbackHandler))
-			return playbackHandler
-		}
-
-		override fun promisePreparedPlaybackFile(
-			libraryId: LibraryId,
-			serviceFile: ServiceFile,
-			preparedAt: Duration): Promise<PreparedPlayableFile?> = Promise { messenger ->
-				this.messenger = messenger
-			}
-	}
-
 	private class FinalPlaybackPreparer : PlayableFilePreparationSource {
 
 		val playbackHandler = ResolvablePlaybackHandler()

projectBlueWater/src/test/java/com/lasthopesoftware/bluewater/client/playback/engine/GivenAPlayingPlaybackEngine/AndPlaybackIsPaused/AndTheTrackIsChanged/When Playback Is Resumed.kt

@@ -50,7 +50,7 @@ class `When Playback Is Resumed` {
 		val preparedPlaybackQueueResourceManagement =
             PreparedPlaybackQueueResourceManagement(
                 fakePlaybackPreparerProvider,
-                FakePlaybackQueueConfiguration()
+                FakePlaybackQueueConfiguration(maxQueueSize = 0)
             )
 		val playbackBootstrapper = ManagedPlaylistPlayer(
             PlaylistVolumeManager(1.0f),
@@ -77,17 +77,19 @@ class `When Playback Is Resumed` {
 	fun before() {
 		val (fakePlaybackPreparerProvider, nowPlayingRepository, playbackEngine) = mut
 
+		val deferredResume = DeferredPromise(Unit)
+
 		fakePlaybackPreparerProvider.preparationSourceBeingProvided { serviceFile, deferredPreparedPlayableFile ->
 			val playbackHandler = deferredPreparedPlayableFile.resolve()
 			if (serviceFile == ServiceFile("1"))
 				playbackHandler.setCurrentPosition(450)
 
-			if (serviceFile == ServiceFile("2"))
+			if (serviceFile == ServiceFile("2")) {
 				preparedAt = deferredPreparedPlayableFile.preparedAt
+				deferredResume.resolve()
+			}
 		}
 
-		val deferredResume = DeferredPromise(Unit)
-
 		val promisedCollectedFiles = Promise {
 			val collectedFiles = mutableListOf<PositionedPlayingFile?>()
 			playbackEngine.setOnPlayingFileChanged { _, f ->
@@ -112,8 +114,6 @@ class `When Playback Is Resumed` {
 
 		playbackEngine.resume().toExpiringFuture().get()
 
-		deferredResume.resolve()
-
 		positionedFiles = promisedCollectedFiles.toExpiringFuture().get()
 
 		nowPlaying = nowPlayingRepository.promiseNowPlaying(LibraryId(libraryId)).toExpiringFuture().get()
@@ -163,6 +163,11 @@ class `When Playback Is Resumed` {
         ).isEqualTo(Duration.ZERO)
 	}
 
+	@Test
+	fun `then the observed playlist position is correct`() {
+		assertThat(positionedFiles?.last()?.playlistPosition).isEqualTo(1)
+	}
+
 	@Test
 	fun `then the first skipped file is only observed once`() {
 		assertThat(positionedFiles?.map { it?.asPositionedFile() })