implemented "dislike" by long-tap & related fixes

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/Database.kt

@@ -62,6 +62,7 @@ import it.fast4x.rimusic.models.SortedSongPlaylistMap
 import it.fast4x.rimusic.service.LOCAL_KEY_PREFIX
 import it.fast4x.rimusic.utils.isExplicit
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.map
 import org.intellij.lang.annotations.MagicConstant
 import kotlin.collections.sortedBy
@@ -196,19 +197,19 @@ interface Database {
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY artistsText")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY artistsText")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByArtistAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY artistsText DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY artistsText DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByArtistDesc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY totalPlayTimeMs")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY totalPlayTimeMs")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByPlayTimeAsc(): Flow<List<SongEntity>>
 
@@ -224,7 +225,7 @@ interface Database {
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY totalPlayTimeMs DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY totalPlayTimeMs DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByPlayTimeDesc(): Flow<List<SongEntity>>
 
@@ -240,63 +241,67 @@ interface Database {
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY title COLLATE NOCASE ASC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY title COLLATE NOCASE ASC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByTitleAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY title COLLATE NOCASE DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY title COLLATE NOCASE DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByTitleDesc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY ROWID")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY ROWID")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByRowIdAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY ROWID DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY ROWID DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByRowIdDesc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY likedAt")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY likedAt")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByLikedAtAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY likedAt DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY likedAt DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByLikedAtDesc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT DISTINCT S.* FROM Song S LEFT JOIN Event E ON E.songId=S.id " +
-            "WHERE likedAt IS NOT NULL " +
-            "ORDER BY E.timestamp DESC")
+    @Query(
+        "SELECT DISTINCT S.* FROM Song S LEFT JOIN Event E ON E.songId=S.id " +
+                "WHERE likedAt IS NOT NULL AND likedAt > 0 " +
+                "ORDER BY E.timestamp DESC"
+    )
     fun songsFavoritesByDatePlayedDesc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT DISTINCT S.* FROM Song S LEFT JOIN Event E ON E.songId=S.id " +
-            "WHERE likedAt IS NOT NULL " +
-            "ORDER BY E.timestamp")
+    @Query(
+        "SELECT DISTINCT S.* FROM Song S LEFT JOIN Event E ON E.songId=S.id " +
+                "WHERE likedAt IS NOT NULL AND likedAt > 0 " +
+                "ORDER BY E.timestamp"
+    )
     fun songsFavoritesByDatePlayedAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY durationText")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY durationText")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByDurationAsc(): Flow<List<SongEntity>>
 
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
-    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL ORDER BY durationText DESC")
+    @Query("SELECT * FROM Song WHERE likedAt IS NOT NULL AND likedAt > 0 ORDER BY durationText DESC")
     @RewriteQueriesToDropUnusedColumns
     fun songsFavoritesByDurationDesc(): Flow<List<SongEntity>>
 
@@ -337,6 +342,122 @@ interface Database {
         }
     }
 
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1 " +
+            " ORDER BY "+
+            "    CASE :sortOrder WHEN 'ASC' THEN totalPlayTimeMs END ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN totalPlayTimeMs END DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByPlayTime(sortOrder: String): Flow<List<SongEntity>>
+
+    fun songsDislikedByRelativePlayTime(sortOrder: SortOrder): Flow<List<SongEntity>> {
+        val songs = songsDislikedByPlayTime(sortOrder.toSQLString())
+        songs.map { it }
+        return songs.map {
+            when(sortOrder) {
+               SortOrder.Ascending -> it.sortedBy { se -> se.relativePlayTime() }
+                else -> it.sortedByDescending { se -> se.relativePlayTime() }
+            }
+        }
+    }
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1 " +
+            " ORDER BY "+
+            "    CASE :sortOrder WHEN 'ASC' THEN Song.title END COLLATE NOCASE ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN Song.title END COLLATE NOCASE DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByTitle(sortOrder: String): Flow<List<SongEntity>>
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1 " +
+            " ORDER BY "+
+            "    CASE :sortOrder WHEN 'ASC' THEN Song.ROWID END ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN Song.ROWID END DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByRowId(sortOrder: String): Flow<List<SongEntity>>
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "LEFT JOIN Event E ON E.songId=Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1" +
+            " ORDER BY "+
+            "    CASE :sortOrder WHEN 'ASC' THEN E.timestamp END ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN E.timestamp END DESC")
+    fun songsDislikedByDatePlayed(sortOrder: String): Flow<List<SongEntity>>
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1" +
+            " ORDER BY " +
+            "    CASE :sortOrder WHEN 'ASC' THEN artistsText END ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN artistsText END DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByArtist(sortOrder: String): Flow<List<SongEntity>>
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE likedAt IS NOT NULL AND likedAt = -1 "+
+            "ORDER BY " +
+            "    CASE :sortOrder WHEN 'ASC' THEN durationText END ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN durationText END DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByDuration(sortOrder: String): Flow<List<SongEntity>>
+
+    @Transaction
+    @Query("SELECT DISTINCT Song.*, Format.contentLength, Album.title FROM Song " +
+            "LEFT JOIN SongAlbumMap ON Song.id = SongAlbumMap.songId " +
+            "LEFT JOIN Album ON Album.id = SongAlbumMap.albumId " +
+            "LEFT JOIN Format ON Format.songId = Song.id " +
+            "WHERE Song.likedAt = -1 AND Song.id NOT LIKE '$LOCAL_KEY_PREFIX%' " +
+            "ORDER BY " +
+            "    CASE :sortOrder WHEN 'ASC' THEN Album.title END COLLATE NOCASE ASC," +
+            "    CASE :sortOrder WHEN 'DESC' THEN Album.title END COLLATE NOCASE DESC")
+    @RewriteQueriesToDropUnusedColumns
+    fun songsDislikedByAlbumName(sortOrder: String): Flow<List<SongEntity>>
+
+    fun SortOrder.toSQLString(): String {
+        return when(this){
+            SortOrder.Ascending -> "ASC"
+            SortOrder.Descending -> "DESC"
+        }
+    }
+
+    fun songsDisliked(sortBy: SongSortBy, sortOrder: SortOrder): Flow<List<SongEntity>> {
+        return when(sortBy){
+            SongSortBy.PlayTime -> songsDislikedByPlayTime(sortOrder.toSQLString())
+            SongSortBy.RelativePlayTime -> songsDislikedByRelativePlayTime(sortOrder)
+            SongSortBy.Title -> songsDislikedByTitle(sortOrder.toSQLString())
+            SongSortBy.DateAdded -> songsDislikedByRowId(sortOrder.toSQLString())
+            SongSortBy.DatePlayed -> songsDislikedByDatePlayed(sortOrder.toSQLString())
+            SongSortBy.DateLiked -> flowOf(emptyList()) // TODO correct text, method
+            SongSortBy.Artist -> songsDislikedByArtist(sortOrder.toSQLString())
+            SongSortBy.Duration -> songsDislikedByDuration(sortOrder.toSQLString())
+            SongSortBy.AlbumName -> songsDislikedByAlbumName(sortOrder.toSQLString())
+        }
+    }
+
     @SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
     @Transaction
     @Query("SELECT DISTINCT Song.*, Album.title as albumTitle FROM Song " +
@@ -1346,7 +1467,7 @@ interface Database {
     @Query("UPDATE Playlist SET name = REPLACE(name,'${PINNED_PREFIX}','') WHERE id = :playlistId")
     fun unPinPlaylist(playlistId: Long): Int
 
-    @Query("SELECT count(id) FROM Song WHERE id = :songId and likedAt IS NOT NULL")
+    @Query("SELECT count(id) FROM Song WHERE id = :songId and likedAt IS NOT NULL and likedAt > 0")
     fun songliked(songId: String): Int
 
     @Query("SELECT * FROM Song WHERE id = :id")

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/enums/BuiltInPlaylist.kt

@@ -6,5 +6,6 @@ enum class BuiltInPlaylist {
     Offline,
     Downloaded,
     Top,
-    OnDevice
+    OnDevice,
+    Disliked
 }

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/models/Song.kt

@@ -5,6 +5,7 @@ import androidx.room.Entity
 import androidx.room.PrimaryKey
 import it.fast4x.rimusic.cleanPrefix
 import it.fast4x.rimusic.utils.durationTextToMillis
+import it.fast4x.rimusic.utils.setDisLikeState
 import it.fast4x.rimusic.utils.setLikeState
 import kotlinx.serialization.Serializable
 
@@ -40,6 +41,12 @@ data class Song(
         )
     }
 
+    fun toggleDislike(): Song {
+        return copy(
+            likedAt = setDisLikeState(likedAt)
+        )
+    }
+
     fun cleanTitle() = cleanPrefix( this.title )
 
     fun relativePlayTime(): Double {

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/ui/components/SwipeableContent.kt

@@ -35,6 +35,7 @@ import it.fast4x.innertube.Innertube
 import it.fast4x.rimusic.Database
 import it.fast4x.rimusic.R
 import it.fast4x.rimusic.appContext
+import it.fast4x.rimusic.cleanPrefix
 import it.fast4x.rimusic.enums.AlbumSwipeAction
 import it.fast4x.rimusic.enums.DownloadedStateMedia
 import it.fast4x.rimusic.enums.PlaylistSwipeAction
@@ -189,7 +190,7 @@ fun SwipeableQueueItem(
         } else if (!isYouTubeSyncEnabled()){
             mediaItemToggleLike(mediaItem)
             val message: String
-            val mTitle: String = mediaItem.mediaMetadata.title?.toString() ?: ""
+            val mTitle: String = cleanPrefix(mediaItem.mediaMetadata.title?.toString() ?: "")
             val mArtist: String = mediaItem.mediaMetadata.artist?.toString() ?: ""
             if (likedAt == -1L) {
                 message =
@@ -275,7 +276,7 @@ fun SwipeablePlaylistItem(
         } else if (!isYouTubeSyncEnabled()){
             mediaItemToggleLike(mediaItem)
             val message: String
-            val mTitle: String = mediaItem.mediaMetadata.title?.toString() ?: ""
+            val mTitle: String = cleanPrefix(mediaItem.mediaMetadata.title?.toString() ?: "")
             val mArtist: String = mediaItem.mediaMetadata.artist?.toString() ?: ""
             if (likedAt == -1L) {
                 message =

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/ui/components/themed/IconButton.kt

@@ -1,9 +1,11 @@
 package it.fast4x.rimusic.ui.components.themed
 
 import androidx.annotation.DrawableRes
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.Indication
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -39,9 +41,11 @@ fun HeaderIconButton(
     )
 }
 
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 fun IconButton(
     onClick: () -> Unit,
+    onLongClick: (() -> Unit)? = null,
     @DrawableRes icon: Int,
     color: Color,
     modifier: Modifier = Modifier,
@@ -53,11 +57,12 @@ fun IconButton(
         contentDescription = null,
         colorFilter = ColorFilter.tint(color),
         modifier = Modifier
-            .clickable(
+            .combinedClickable(
                 indication = indication ?: ripple(bounded = false),
                 interactionSource = remember { MutableInteractionSource() },
                 enabled = enabled,
-                onClick = onClick
+                onClick = onClick,
+                onLongClick = onLongClick
             )
             .then(modifier)
     )

composeApp/src/androidMain/kotlin/it/fast4x/rimusic/ui/components/themed/MediaItemGridMenu.kt

@@ -96,12 +96,16 @@ import kotlinx.coroutines.withContext
 import it.fast4x.rimusic.colorPalette
 import it.fast4x.rimusic.context
 import it.fast4x.rimusic.enums.PopupType
+import it.fast4x.rimusic.models.Song
 import it.fast4x.rimusic.service.MyDownloadHelper
 import it.fast4x.rimusic.typography
 import it.fast4x.rimusic.ui.screens.settings.isYouTubeSyncEnabled
 import it.fast4x.rimusic.utils.addSongToYtPlaylist
 import it.fast4x.rimusic.utils.addToYtLikedSong
 import it.fast4x.rimusic.utils.isNetworkConnected
+import it.fast4x.rimusic.utils.getLikeState
+import it.fast4x.rimusic.utils.setDisLikeState
+import it.fast4x.rimusic.utils.unlikeYtVideoOrSong
 
 @OptIn(UnstableApi::class)
 @Composable
@@ -448,7 +452,7 @@ fun MediaItemGridMenu (
 
             Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
                 IconButton(
-                    icon = if (likedAt == null) R.drawable.heart_outline else R.drawable.heart,
+                    icon = getLikeState(mediaItem.mediaId),
                     color = colorPalette().favoritesIcon,
                     onClick = {
                         if (!isNetworkConnected(appContext()) && isYouTubeSyncEnabled()) {
@@ -462,6 +466,25 @@ fun MediaItemGridMenu (
                             }
                         }
                     },
+                    onLongClick = {
+                        if (!isNetworkConnected(appContext()) && isYouTubeSyncEnabled()) {
+                            SmartMessage(appContext().resources.getString(R.string.no_connection), context = appContext(), type = PopupType.Error)
+                        } else if (!isYouTubeSyncEnabled()){
+                            Database.asyncTransaction {
+                                if (like(mediaItem.mediaId, setDisLikeState(likedAt)) == 0){
+                                    insert(mediaItem, Song::toggleDislike)
+                                }
+                                MyDownloadHelper.autoDownloadWhenLiked(context, mediaItem)
+                                updateData = !updateData
+                            }
+                        } else {
+                            CoroutineScope(Dispatchers.IO).launch {
+                                // currently can not implement dislike for sync so only unliking song
+                                unlikeYtVideoOrSong(mediaItem)
+                                updateData = !updateData
+                            }
+                        }
+                    },
                     modifier = Modifier
                         .padding(all = 4.dp)
                         .size(24.dp)