Merge pull request #604 from namehillsoftware/feature/downloading-item-as-top-item

[Feature] Downloading Item as Top Item

Author: davidvedvick

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/browsing/files/details/FileDetailsViewModel.kt

@@ -22,7 +22,7 @@ import com.lasthopesoftware.bluewater.shared.messages.registerReceiver
 import com.lasthopesoftware.observables.LiftedInteractionState
 import com.lasthopesoftware.observables.MutableInteractionState
 import com.lasthopesoftware.observables.mapNotNull
-import com.lasthopesoftware.observables.toMaybeObservable
+import com.lasthopesoftware.observables.toSingleObservable
 import com.lasthopesoftware.promises.extensions.keepPromise
 import com.lasthopesoftware.promises.extensions.preparePromise
 import com.lasthopesoftware.promises.extensions.unitResponse
@@ -82,7 +82,7 @@ class FileDetailsViewModel(
 	override val isLoading = mutableIsLoading.asInteractionState()
 	override val coverArt = LiftedInteractionState(
 		promisedDefaultCoverArt
-			.toMaybeObservable()
+			.toSingleObservable()
 			.toObservable()
 			.concatWith(mutableCoverArt.mapNotNull()),
 		emptyByteArray

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/browsing/navigation/NavigateToLibraryDestination.kt

@@ -2,6 +2,7 @@ package com.lasthopesoftware.bluewater.client.browsing.navigation
 
 import LoadedItemListView
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -39,7 +40,13 @@ fun ScreenDimensionsScope.NavigateToLibraryDestination(
 					applicationNavigation = applicationNavigation,
                 )
 
-				activeFileDownloadsViewModel.loadActiveDownloads(destination.libraryId)
+				DisposableEffect(destination) {
+					val promise = activeFileDownloadsViewModel.loadActiveDownloads(destination.libraryId)
+
+					onDispose {
+						promise.cancel()
+					}
+				}
 			}
 		}
 

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/playback/nowplaying/view/viewmodels/NowPlayingCoverArtViewModel.kt

@@ -16,7 +16,7 @@ import com.lasthopesoftware.bluewater.shared.messages.application.RegisterForApp
 import com.lasthopesoftware.bluewater.shared.messages.registerReceiver
 import com.lasthopesoftware.observables.LiftedInteractionState
 import com.lasthopesoftware.observables.MutableInteractionState
-import com.lasthopesoftware.observables.toMaybeObservable
+import com.lasthopesoftware.observables.toSingleObservable
 import com.lasthopesoftware.promises.extensions.toPromise
 import com.lasthopesoftware.resources.emptyByteArray
 import com.namehillsoftware.handoff.promises.Promise
@@ -52,7 +52,7 @@ class NowPlayingCoverArtViewModel(
 	val isNowPlayingImageLoading = isNowPlayingImageLoadingState.asInteractionState()
 	val nowPlayingImage = LiftedInteractionState(
 		promisedDefaultImage
-			.toMaybeObservable()
+			.toSingleObservable()
 			.toObservable()
 			.concatWith(nowPlayingImageState.filter { it.value.isNotEmpty() }.map { it.value }),
 		emptyByteArray)

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/playback/service/PlaybackService.kt

@@ -97,7 +97,7 @@ import com.lasthopesoftware.bluewater.shared.lazyLogger
 import com.lasthopesoftware.bluewater.shared.messages.application.ApplicationMessageBus.Companion.getApplicationMessageBus
 import com.lasthopesoftware.bluewater.shared.messages.application.getScopedMessageBus
 import com.lasthopesoftware.bluewater.shared.messages.registerReceiver
-import com.lasthopesoftware.observables.toMaybeObservable
+import com.lasthopesoftware.observables.toSingleObservable
 import com.lasthopesoftware.policies.retries.RetryOnRejectionLazyPromise
 import com.lasthopesoftware.promises.ForwardedResponse.Companion.forward
 import com.lasthopesoftware.promises.PromiseDelay.Companion.delay
@@ -927,7 +927,7 @@ import java.util.concurrent.TimeoutException
 		val promisedPlayedFile = playingFile.promisePlayedFile()
 		val localSubscription = trackPositionBroadcaster.run {
 			Observable.interval(1, TimeUnit.SECONDS, lazyObservationScheduler.value)
-				.flatMapMaybe { promisedPlayedFile.progress.toMaybeObservable() }
+				.flatMapSingle { promisedPlayedFile.progress.toSingleObservable() }
 				.distinctUntilChanged()
 				.subscribe(observeUpdates(playingFile))
 		}

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/stored/library/items/files/job/StoredFileJobProcessor.kt

@@ -8,7 +8,7 @@ import com.lasthopesoftware.bluewater.client.stored.library.items.files.job.exce
 import com.lasthopesoftware.bluewater.client.stored.library.items.files.repository.StoredFile
 import com.lasthopesoftware.bluewater.client.stored.library.items.files.updates.UpdateStoredFiles
 import com.lasthopesoftware.bluewater.shared.lazyLogger
-import com.lasthopesoftware.observables.observeProgress
+import com.lasthopesoftware.observables.observeBufferedProgress
 import com.lasthopesoftware.policies.ratelimiting.PromisingRateLimiter
 import com.lasthopesoftware.promises.extensions.ProgressingPromiseProxy
 import com.lasthopesoftware.promises.extensions.toPromise
@@ -39,7 +39,7 @@ class StoredFileJobProcessor(
 			.flatMap { (libraryId, _, storedFile) ->
 				Observable
 					.just(StoredFileJobStatus(storedFile, StoredFileJobState.Queued))
-					.concatWith(rateLimiter.enqueueProgressingPromise { StoredFileDownloadPromise(libraryId, storedFile) }.observeProgress())
+					.concatWith(rateLimiter.enqueueProgressingPromise { StoredFileDownloadPromise(libraryId, storedFile) }.observeBufferedProgress())
 			}
 	}
 

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/stored/library/items/files/view/ActiveFileDownloadsView.kt

@@ -78,6 +78,7 @@ import com.lasthopesoftware.bluewater.client.browsing.files.list.TrackTitleItemV
 import com.lasthopesoftware.bluewater.client.browsing.files.list.ViewFileItem
 import com.lasthopesoftware.bluewater.client.browsing.items.list.ItemListContentType
 import com.lasthopesoftware.bluewater.client.playback.nowplaying.view.ScreenDimensionsScope
+import com.lasthopesoftware.bluewater.client.stored.library.items.files.job.StoredFileJobState
 import com.lasthopesoftware.bluewater.client.stored.library.items.files.repository.StoredFile
 import com.lasthopesoftware.bluewater.client.stored.library.sync.SyncIcon
 import com.lasthopesoftware.bluewater.shared.android.viewmodels.PooledCloseablesViewModel
@@ -141,9 +142,9 @@ private fun SyncMenu(
 fun RenderTrackHeaderItem(
 	activeFileDownloadsViewModel: ActiveFileDownloadsViewModel,
 	trackHeadlineViewModelProvider: PooledCloseablesViewModel<ViewFileItem>,
-	storedFile: StoredFile
+	storedFile: StoredFile,
+	isActive: Boolean
 ) {
-	val downloadingFileId by activeFileDownloadsViewModel.downloadingFileId.subscribeAsState()
 	val fileItemViewModel = remember(trackHeadlineViewModelProvider::getViewModel)
 
 	DisposableEffect(storedFile.serviceId) {
@@ -160,7 +161,7 @@ fun RenderTrackHeaderItem(
 
 	TrackTitleItemView(
 		itemName = fileName,
-		isActive = downloadingFileId == storedFile.id,
+		isActive = isActive,
 	)
 }
 
@@ -171,7 +172,7 @@ fun DownloadingFilesList(
 	modifier: Modifier = Modifier,
 	headerHeight: Dp = 0.dp,
 ) {
-	val files by activeFileDownloadsViewModel.downloadingFiles.subscribeAsState()
+	val files by activeFileDownloadsViewModel.syncingFiles.subscribeAsState()
 	val lazyListState = rememberLazyListState()
 
 	LazyColumn(
@@ -199,12 +200,13 @@ fun DownloadingFilesList(
 
 		itemsIndexed(
 			files,
-			{ _, f -> f.id },
-			contentType = { _, _ -> ItemListContentType.File }) { i, f ->
+			{ _, (f, _) -> f.id },
+			contentType = { _, _ -> ItemListContentType.File }) { i, (f, s) ->
 			RenderTrackHeaderItem(
 				activeFileDownloadsViewModel,
 				trackHeadlineViewModelProvider,
 				f,
+				s == StoredFileJobState.Downloading
 			)
 
 			if (i < files.lastIndex)

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/stored/library/items/files/view/ActiveFileDownloadsViewModel.kt

@@ -4,6 +4,7 @@ import androidx.lifecycle.ViewModel
 import com.lasthopesoftware.bluewater.client.browsing.TrackLoadedViewState
 import com.lasthopesoftware.bluewater.client.browsing.library.repository.LibraryId
 import com.lasthopesoftware.bluewater.client.stored.library.items.files.AccessStoredFiles
+import com.lasthopesoftware.bluewater.client.stored.library.items.files.job.StoredFileJobState
 import com.lasthopesoftware.bluewater.client.stored.library.items.files.repository.StoredFile
 import com.lasthopesoftware.bluewater.client.stored.sync.ScheduleSyncs
 import com.lasthopesoftware.bluewater.client.stored.sync.StoredFileMessage
@@ -13,86 +14,105 @@ import com.lasthopesoftware.bluewater.shared.messages.registerReceiver
 import com.lasthopesoftware.observables.LiftedInteractionState
 import com.lasthopesoftware.observables.MutableInteractionState
 import com.lasthopesoftware.observables.mapNotNull
+import com.lasthopesoftware.promises.extensions.regardless
+import com.lasthopesoftware.promises.extensions.toPromise
 import com.namehillsoftware.handoff.promises.Promise
+import java.util.LinkedList
+import java.util.concurrent.atomic.AtomicReference
 
 class ActiveFileDownloadsViewModel(
 	private val storedFileAccess: AccessStoredFiles,
 	applicationMessages: RegisterForApplicationMessages,
 	private val scheduler: ScheduleSyncs,
 ) : ViewModel(), TrackLoadedViewState {
-	private val mutableIsLoading = MutableInteractionState(false)
 
+	@Volatile
+	private var isPartiallyUpdating = false
+	private val lastPromisedFileUpdate = AtomicReference(Unit.toPromise())
+
+	private val mutableIsLoading = MutableInteractionState(false)
 	private val mutableIsSyncing = MutableInteractionState(false)
 	private val mutableIsSyncStateChangeEnabled = MutableInteractionState(false)
-	private val mutableDownloadingFiles = MutableInteractionState(emptyMap<Int, StoredFile>())
-	private val mutableDownloadingFileId = MutableInteractionState<Int?>(null)
-	private val fileDownloadedRegistration = applicationMessages.registerReceiver { message: StoredFileMessage.FileDownloaded ->
-		mutableDownloadingFiles.value -= message.storedFileId
-	}
-
-	private val fileQueuedRegistration = applicationMessages.registerReceiver { message: StoredFileMessage.FileQueued ->
-		message.storedFileId
-			.takeUnless(mutableDownloadingFiles.value::containsKey)
-			?.let(storedFileAccess::promiseStoredFile)
-			?.then { storedFile ->
-				if (storedFile != null && storedFile.libraryId == activeLibraryId?.id) {
-					mutableDownloadingFiles.value += Pair(storedFile.id, storedFile)
-				}
-			}
-	}
-
-	private val fileDownloadingRegistration = applicationMessages.registerReceiver { message: StoredFileMessage.FileDownloading ->
-		mutableDownloadingFileId.value = message.storedFileId
-	}
-
-	private val syncStartedReceiver = applicationMessages.registerReceiver { _ : SyncStateMessage.SyncStarted ->
-		mutableIsSyncing.value = true
-	}
-
-	private val syncStoppedReceiver = applicationMessages.registerReceiver { _ : SyncStateMessage.SyncStopped ->
-		mutableIsSyncing.value = false
-	}
+	private val mutableSyncingFilesWithState = MutableInteractionState(emptyMap<Int, Pair<StoredFile, StoredFileJobState>>())
 
 	var activeLibraryId: LibraryId? = null
 		private set
 
 	val isSyncing = mutableIsSyncing.asInteractionState()
 	val isSyncStateChangeEnabled = mutableIsSyncStateChangeEnabled.asInteractionState()
-	val downloadingFiles = LiftedInteractionState(
-		mutableDownloadingFiles.mapNotNull().map { it.values.toList() },
+
+	val syncingFiles = LiftedInteractionState(
+		mutableSyncingFilesWithState
+			.mapNotNull()
+			.filter { !isPartiallyUpdating }
+			.map { m ->
+				val downloadingArray = ArrayList<Pair<StoredFile, StoredFileJobState>>()
+				val returnList = LinkedList<Pair<StoredFile, StoredFileJobState>>()
+				val addedFiles = HashSet<Int>(m.values.size)
+
+				for ((k, p) in m) {
+					val (f, s) = p
+					if (!addedFiles.add(f.id)) continue
+					if (s == StoredFileJobState.Downloading) downloadingArray.add(p)
+					else returnList.add(p)
+				}
+
+				returnList.addAll(0, downloadingArray)
+				returnList
+			},
 		emptyList()
 	)
-	val downloadingFileId = mutableDownloadingFileId.asInteractionState()
+
 	override val isLoading = mutableIsLoading.asInteractionState()
 
 	init {
+		addCloseable(applicationMessages.registerReceiver { message: StoredFileMessage.FileDownloaded ->
+			mutableSyncingFilesWithState.value -= message.storedFileId
+		})
+
+		addCloseable(applicationMessages.registerReceiver { message: StoredFileMessage.FileQueued ->
+			updateStoredFileState(message.storedFileId, StoredFileJobState.Queued)
+		})
+
+		addCloseable(applicationMessages.registerReceiver { message: StoredFileMessage.FileDownloading ->
+			updateStoredFileState(message.storedFileId, StoredFileJobState.Downloading)
+		})
+
+		addCloseable(applicationMessages.registerReceiver { message: StoredFileMessage.FileWriteError ->
+			updateStoredFileState(message.storedFileId, StoredFileJobState.Queued)
+		})
+
+		addCloseable(applicationMessages.registerReceiver { message: StoredFileMessage.FileReadError ->
+			updateStoredFileState(message.storedFileId, StoredFileJobState.Queued)
+		})
+
+		addCloseable(applicationMessages.registerReceiver { _ : SyncStateMessage.SyncStarted ->
+			mutableIsSyncing.value = true
+		})
+
+		addCloseable(applicationMessages.registerReceiver { _ : SyncStateMessage.SyncStopped ->
+			mutableIsSyncing.value = false
+		})
+
 	    scheduler
 			.promiseIsSyncing()
-			.then { it ->
+			.then {
 				mutableIsSyncing.value = it
 				mutableIsSyncStateChangeEnabled.value = true
 			}
 	}
 
-	override fun onCleared() {
-		fileDownloadedRegistration.close()
-		fileQueuedRegistration.close()
-		syncStartedReceiver.close()
-		syncStoppedReceiver.close()
-		fileDownloadingRegistration.close()
-	}
-
 	fun loadActiveDownloads(libraryId: LibraryId): Promise<*> {
 		mutableIsLoading.value = true
 		activeLibraryId = libraryId
 		return storedFileAccess
 			.promiseDownloadingFiles()
 			.then { storedFiles ->
-				mutableDownloadingFiles.value = storedFiles
-						.filter { sf -> sf.libraryId == libraryId.id }
-						.associateBy { sf -> sf.id }
+				mutableSyncingFilesWithState.value = storedFiles
+					.filter { sf -> sf.libraryId == libraryId.id }
+					.associate { sf -> sf.id to (sf to StoredFileJobState.Queued) }
 			}
-			.must {  _ -> mutableIsLoading.value = false }
+			.must { _ -> mutableIsLoading.value = false }
 	}
 
 	fun toggleSync() {
@@ -109,4 +129,26 @@ class ActiveFileDownloadsViewModel(
 				mutableIsSyncStateChangeEnabled.value = true
 			}
 	}
+
+	private fun updateStoredFileState(storedFileId: Int, state: StoredFileJobState) {
+		lastPromisedFileUpdate.getAndUpdate { prior ->
+			prior.regardless {
+				mutableSyncingFilesWithState.value[storedFileId]
+					?.let { (storedFile, currentState) ->
+						if (currentState != state) {
+							isPartiallyUpdating = true
+							mutableSyncingFilesWithState.value -= storedFile.id
+							isPartiallyUpdating = false
+							mutableSyncingFilesWithState.value += storedFile.id to (storedFile to state)
+						}
+					}
+					?.toPromise()
+					?: storedFileAccess.promiseStoredFile(storedFileId).then { storedFile ->
+						if (storedFile != null && storedFile.libraryId == activeLibraryId?.id) {
+							mutableSyncingFilesWithState.value += storedFile.id to (storedFile to state)
+						}
+					}
+			}
+		}
+	}
 }

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/stored/library/sync/LibrarySyncsHandler.kt

@@ -44,7 +44,7 @@ class LibrarySyncsHandler(
 			.flatMapMaybe { serviceFile ->
 				storedFileUpdater
 					.promiseStoredFileUpdate(libraryId, serviceFile)
-					.then<StoredFileJob?>({ storedFile ->
+					.then({ storedFile ->
 						storedFile
 							?.takeUnless { sf -> sf.isDownloadComplete }
 							?.let { sf -> StoredFileJob(libraryId, serviceFile, sf) }

projectBlueWater/src/main/java/com/lasthopesoftware/bluewater/client/stored/sync/StoredFileMessage.kt

@@ -2,7 +2,7 @@ package com.lasthopesoftware.bluewater.client.stored.sync
 
 import com.lasthopesoftware.bluewater.shared.messages.application.ApplicationMessage
 
-interface StoredFileMessage : ApplicationMessage {
+sealed interface StoredFileMessage : ApplicationMessage {
 	val storedFileId: Int
 
 	class FileQueued(override val storedFileId: Int) : StoredFileMessage