Implement non-shuffle setting

app/src/main/java/com/anthonyla/paperize/core/SettingsConstants.kt

@@ -45,4 +45,5 @@ object SettingsConstants {
     const val CHANGE_START_TIME = "change_start_time"
     const val START_HOUR = "start_hour"
     const val START_MINUTE = "start_minute"
+    const val SHUFFLE = "shuffle"
 }

app/src/main/java/com/anthonyla/paperize/core/WallpaperUtil.kt

@@ -403,7 +403,7 @@ suspend fun getWallpaperFromFolder(folderUri: String, context: Context): List<Wa
                                     wallpaperUri = documentUri.toString().compress("content://com.android.externalstorage.documents/"),
                                     fileName = displayName.substringBeforeLast('.', displayName),
                                     dateModified = dateModified,
-                                    order = wallpapers.size + 1,
+                                    order = wallpapers.size,
                                     key = 0
                                 )
                             )

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/data/data_source/AlbumDao.kt

@@ -26,6 +26,9 @@ interface AlbumDao {
     @Query("SELECT * FROM album WHERE selected = 1")
     fun getSelectedAlbums(): Flow<List<AlbumWithWallpaperAndFolder>>
 
+    /*@Query("UPDATE album SET selected = :selected WHERE initialAlbumName = :albumName")
+    suspend fun updateAlbumSelection(albumName: String, selected: Boolean)*/
+
     @Query("UPDATE album SET selected = :selected WHERE initialAlbumName = :albumName")
     suspend fun updateAlbumSelection(albumName: String, selected: Boolean)
 

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/data/repository/AlbumRepositoryImpl.kt

@@ -22,7 +22,6 @@ class AlbumRepositoryImpl(
                 it.copy(
                     wallpapers = it.sortedWallpapers,
                     folders = it.sortedFolders,
-                    totalWallpapers = it.sortedTotalWallpapers
                 )
             }
         }
@@ -34,7 +33,6 @@ class AlbumRepositoryImpl(
                 it.copy(
                     wallpapers = it.sortedWallpapers,
                     folders = it.sortedFolders,
-                    totalWallpapers = it.sortedTotalWallpapers
                 )
             }
         }

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/domain/model/AlbumWithWallpaperAndFolder.kt

@@ -8,8 +8,7 @@ import androidx.room.Relation
  * @param album The album.
  * @param wallpapers The wallpapers.
  * @param folders The folders.
- * @param totalWallpapers The total wallpapers from wallpapers and folders
- */
+ * */
 data class AlbumWithWallpaperAndFolder(
     @Embedded val album: Album,
     @Relation(
@@ -24,19 +23,15 @@ data class AlbumWithWallpaperAndFolder(
         entity = Folder::class
     )
     val folders: List<Folder> = emptyList(),
-    @Relation(
-        parentColumn = "initialAlbumName",
-        entityColumn = "initialAlbumName",
-        entity = Wallpaper::class
-    )
-    val totalWallpapers: List<Wallpaper> = emptyList()
 ) {
+    val totalWallpapers: List<Wallpaper>
+        get() = folders.flatMap { it.wallpapers } + wallpapers
     val sortedFolders: List<Folder>
         get() = folders.map { folder ->
             folder.copy(wallpapers = folder.wallpapers.sortedBy { it.order })
         }.sortedBy { it.order }
     val sortedWallpapers: List<Wallpaper>
         get() = wallpapers.sortedBy { it.order }
     val sortedTotalWallpapers: List<Wallpaper>
-        get() = totalWallpapers.sortedBy { it.order }
+        get() = (folders.flatMap { it.wallpapers } + wallpapers).sortedBy { it.order }
 }

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/presentation/PaperizeApp.kt

@@ -198,36 +198,39 @@ fun PaperizeApp(
                     }
                 },
                 onSelectAlbum = { album, lock, home ->
-                    val currentSettings = settingsState.value.wallpaperSettings
+                    val currentSettings = settingsState.value
                     val albumName = album.album.initialAlbumName
-                    val notSameAlbum = currentSettings.homeAlbumName != currentSettings.lockAlbumName
+                    val notSameAlbum = currentSettings.wallpaperSettings.homeAlbumName != currentSettings.wallpaperSettings.lockAlbumName
                     val newHomeAlbum = if (home) albumName else null
                     val newLockAlbum = if (lock) albumName else null
                     settingsViewModel.onEvent(SettingsEvent.SetAlbum(
                         homeAlbumName = newHomeAlbum,
                         lockAlbumName = newLockAlbum
                     ))
                     val deselectName = when {
-                        notSameAlbum && home -> currentSettings.homeAlbumName
-                        notSameAlbum && lock -> currentSettings.lockAlbumName
+                        notSameAlbum && home -> currentSettings.wallpaperSettings.homeAlbumName
+                        notSameAlbum && lock -> currentSettings.wallpaperSettings.lockAlbumName
                         else -> null
                     }
-                    albumsViewModel.onEvent(AlbumsEvent.AddSelectedAlbum(
-                        album = album,
-                        deselectAlbumName = deselectName
-                    ))
+                    albumsViewModel.onEvent(
+                        AlbumsEvent.AddSelectedAlbum(
+                            album = album,
+                            deselectAlbumName = deselectName,
+                            shuffle = currentSettings.scheduleSettings.shuffle
+                        )
+                    )
 
-                    val shouldSchedule = (home && !currentSettings.lockAlbumName.isNullOrEmpty()) ||
-                            (lock && !currentSettings.homeAlbumName.isNullOrEmpty()) ||
+                    val shouldSchedule = (home && !currentSettings.wallpaperSettings.lockAlbumName.isNullOrEmpty()) ||
+                            (lock && !currentSettings.wallpaperSettings.homeAlbumName.isNullOrEmpty()) ||
                             (lock && home)
 
                     if (shouldSchedule) {
                         job = scope.scheduleWallpaperUpdate(
                             job = job,
                             settingsState = settingsState.value.copy(
-                                wallpaperSettings = currentSettings.copy(
-                                    homeAlbumName = newHomeAlbum ?: currentSettings.homeAlbumName,
-                                    lockAlbumName = newLockAlbum ?: currentSettings.lockAlbumName
+                                wallpaperSettings = currentSettings.wallpaperSettings.copy(
+                                    homeAlbumName = newHomeAlbum ?: currentSettings.wallpaperSettings.homeAlbumName,
+                                    lockAlbumName = newLockAlbum ?: currentSettings.wallpaperSettings.lockAlbumName
                                 )
                             ),
                             settingsViewModel = settingsViewModel,
@@ -490,6 +493,20 @@ fun PaperizeApp(
                         )
                     }
                 },
+                onShuffleCheck = { shuffle ->
+                    settingsViewModel.onEvent(SettingsEvent.SetShuffle(shuffle))
+                    if (settingsState.value.wallpaperSettings.enableChanger) {
+                        job = scope.updateWallpaperAlarm(
+                            job = job,
+                            settingsState = settingsState.value.copy(
+                                scheduleSettings = settingsState.value.scheduleSettings.copy(
+                                    shuffle = shuffle
+                                )
+                            ),
+                            scheduler = scheduler
+                        )
+                    }
+                },
             )
         }
 
@@ -697,7 +714,8 @@ private fun CoroutineScope.scheduleWallpaperUpdate(
             setHome = settingsState.wallpaperSettings.setHomeWallpaper,
             setLock = settingsState.wallpaperSettings.setLockWallpaper,
             changeStartTime = settingsState.scheduleSettings.changeStartTime,
-            startTime = settingsState.scheduleSettings.startTime
+            startTime = settingsState.scheduleSettings.startTime,
+            shuffle = settingsState.scheduleSettings.shuffle
         )
 
         scheduler.scheduleWallpaperAlarm(
@@ -726,7 +744,8 @@ private fun CoroutineScope.updateWallpaperAlarm(
             setHome = settingsState.wallpaperSettings.setHomeWallpaper,
             setLock = settingsState.wallpaperSettings.setLockWallpaper,
             changeStartTime = settingsState.scheduleSettings.changeStartTime,
-            startTime = settingsState.scheduleSettings.startTime
+            startTime = settingsState.scheduleSettings.startTime,
+            shuffle = settingsState.scheduleSettings.shuffle
         )
 
         scheduler.updateWallpaperAlarm(

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/presentation/add_album_screen/AddAlbumViewModel.kt

@@ -44,23 +44,25 @@ class AddAlbumViewModel @Inject constructor(
                             initialAlbumName = event.initialAlbumName,
                             key = event.initialAlbumName.hashCode() + it.wallpaperUri.hashCode()
                         )
-                    }.sortedBy { it.order }
+                    }
+                    var totalWallpapers = _state.value.wallpapers.size
                     val folders = _state.value.folders.map { folder ->
+                        val updatedWallpapers = folder.wallpapers.map {
+                            it.copy(
+                                initialAlbumName = event.initialAlbumName,
+                                key = event.initialAlbumName.hashCode() + folder.folderUri.hashCode() + it.wallpaperUri.hashCode(),
+                                order = it.order + totalWallpapers
+                            )
+                        }
+                        totalWallpapers += folder.wallpapers.size
                         folder.copy(
                             initialAlbumName = event.initialAlbumName,
                             key = event.initialAlbumName.hashCode() + folder.hashCode(),
-                            coverUri = folder.wallpapers.firstOrNull()?.wallpaperUri ?: folder.coverUri,
-                            wallpapers = folder.wallpapers.map {
-                                it.copy(
-                                    initialAlbumName = event.initialAlbumName,
-                                    key = event.initialAlbumName.hashCode() + folder.folderUri.hashCode() + it.wallpaperUri.hashCode(),
-                                    order = it.order + _state.value.wallpapers.size
-                                )
-                            }.sortedBy { it.order }
+                            coverUri = updatedWallpapers.firstOrNull()?.wallpaperUri ?: folder.coverUri,
+                            wallpapers = updatedWallpapers
                         )
-                    }.sortedBy { it.order }
+                    }
 
-                    val totalWallpapers = folders.flatMap { it.wallpapers } + wallpapers
                     val albumWithWallpaperAndFolder = AlbumWithWallpaperAndFolder(
                         album = Album(
                             initialAlbumName = event.initialAlbumName,
@@ -71,8 +73,7 @@ class AddAlbumViewModel @Inject constructor(
                             selected = false
                         ),
                         wallpapers = wallpapers,
-                        folders = folders,
-                        totalWallpapers = totalWallpapers
+                        folders = folders
                     )
                     repository.upsertAlbumWithWallpaperAndFolder(albumWithWallpaperAndFolder)
                     _state.update { AddAlbumState() }
@@ -145,7 +146,7 @@ class AddAlbumViewModel @Inject constructor(
                         wallpapers = wallpapers,
                         coverUri = wallpapers.firstOrNull()?.wallpaperUri ?: "",
                         dateModified = metadata.lastModified,
-                        order = _state.value.folders.size + 1,
+                        order = if (_state.value.folders.isEmpty()) 0 else _state.value.folders.size,
                         key = 0
                     )
                     _state.update {
@@ -162,13 +163,13 @@ class AddAlbumViewModel @Inject constructor(
             is AddAlbumEvent.SelectAll -> {
                 viewModelScope.launch {
                     if (!_state.value.selectionState.allSelected) {
-                        _state.update {
-                            it.copy(
+                        _state.update { state ->
+                            state.copy(
                                 selectionState = SelectionState(
-                                    selectedFolders = it.folders.map { it.folderUri },
-                                    selectedWallpapers = it.wallpapers.map { it.wallpaperUri },
+                                    selectedFolders = state.folders.map { it.folderUri },
+                                    selectedWallpapers = state.wallpapers.map { it.wallpaperUri },
                                     allSelected = true,
-                                    selectedCount = it.folders.size + it.wallpapers.size
+                                    selectedCount = state.folders.size + state.wallpapers.size
                                 )
                             )
                         }

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/presentation/album/AlbumsEvent.kt

@@ -7,6 +7,10 @@ sealed class AlbumsEvent {
     data object Reset: AlbumsEvent()
     data object Refresh: AlbumsEvent()
 
-    data class AddSelectedAlbum(val album: AlbumWithWallpaperAndFolder, val deselectAlbumName: String? = null): AlbumsEvent()
+    data class AddSelectedAlbum(
+        val album: AlbumWithWallpaperAndFolder,
+        val deselectAlbumName: String? = null,
+        val shuffle: Boolean = true
+    ): AlbumsEvent()
     data class RemoveSelectedAlbum(val deselectAlbumName: String): AlbumsEvent()
 }

app/src/main/java/com/anthonyla/paperize/feature/wallpaper/presentation/album/AlbumsViewModel.kt

@@ -2,6 +2,7 @@ package com.anthonyla.paperize.feature.wallpaper.presentation.album
 
 import android.app.Application
 import android.content.Context
+import androidx.compose.ui.util.fastMap
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.viewModelScope
 import com.anthonyla.paperize.core.findFirstValidUri
@@ -58,10 +59,18 @@ class AlbumsViewModel @Inject constructor (
         when (event) {
             is AlbumsEvent.AddSelectedAlbum -> {
                 viewModelScope.launch {
-                    event.deselectAlbumName?.let {
-                        repository.updateAlbumSelection(it, false)
-                    }
-                    repository.updateAlbumSelection(event.album.album.initialAlbumName, true)
+                    event.deselectAlbumName?.let { repository.updateAlbumSelection(it, false) }
+                    val homeWallpapers = if (event.shuffle) event.album.totalWallpapers.shuffled().map { it.wallpaperUri }
+                    else event.album.sortedTotalWallpapers.map { it.wallpaperUri }
+                    val lockWallpapers = if (event.shuffle) event.album.totalWallpapers.shuffled().map { it.wallpaperUri }
+                    else event.album.sortedTotalWallpapers.map { it.wallpaperUri }
+                    repository.updateAlbum(
+                        event.album.album.copy(
+                            selected = true,
+                            homeWallpapersInQueue = homeWallpapers,
+                            lockWallpapersInQueue = lockWallpapers
+                        )
+                    )
                 }
             }
 
@@ -99,7 +108,6 @@ class AlbumsViewModel @Inject constructor (
                     album.wallpapers
                         .asSequence()
                         .filter { isValidUri(context, it.wallpaperUri) }
-                        .sortedBy { it.order }
                         .mapIndexed { index, wallpaper -> wallpaper.copy(order = index) }
                         .toList()
                 }
@@ -131,7 +139,7 @@ class AlbumsViewModel @Inject constructor (
                                                             wallpaper.wallpaperUri.hashCode()
                                                 )
                                             }.toList()
-                                    val combinedWallpapers = (existingWallpapers + newWallpapers).sortedBy { it.order }
+                                    val combinedWallpapers = existingWallpapers + newWallpapers
                                     folder.copy(
                                         coverUri = combinedWallpapers.firstOrNull()?.wallpaperUri ?: "",
                                         wallpapers = combinedWallpapers,
@@ -146,16 +154,14 @@ class AlbumsViewModel @Inject constructor (
                         .awaitAll()
                 }
 
-                val folders = validFolders.await().sortedBy { it.order }
+                val folders = validFolders.await()
                 val wallpapers = validWallpapers.await()
                 val coverUri = findFirstValidUri(context, folders, wallpapers)
-                val totalWallpapers = folders.flatMap { it.wallpapers } + wallpapers
                 repository.upsertAlbumWithWallpaperAndFolder(
                     album.copy(
                         album = album.album.copy(coverUri = coverUri),
                         wallpapers = wallpapers,
-                        folders = folders,
-                        totalWallpapers = totalWallpapers
+                        folders = folders
                     )
                 )
             }