Unofficial YouTube Music / Spotify Premium client for Android, built in Liquid Glass. Audio effects, Spotify Connect, listening history, 8 languages. Rust core on librespot.
Kotlin alternativeandroidandroid-applicationclientglassmorphisminnertubelibrespotliquid-glassspotifyspotify-connectspotifyapiyoutube-musicyoutube-playerytdlnis
Release 2.4.6 with Smart Shuffle and monthly listening recap
Lelonioba6657596b94
diff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex 3941e2b..47c58f9 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -50,8 +50,8 @@ android {// cpal's Android host is AAudio, which the ndk crate gates at API 26.minSdk = 26targetSdk = 35- versionCode = 46- versionName = "2.4.5"+ versionCode = 47+ versionName = "2.4.6"buildConfigField("boolean", "VERBOSE_LOG", "false")// Bungee only for the ABIs that ship; see the splits below.diff --git a/app/src/main/java/dev/lelonio/square/SquareApplication.kt b/app/src/main/java/dev/lelonio/square/SquareApplication.ktindex 8807a3d..dd07d33 100644--- a/app/src/main/java/dev/lelonio/square/SquareApplication.kt+++ b/app/src/main/java/dev/lelonio/square/SquareApplication.kt@@ -146,6 +146,7 @@ class SquareApplication : Application(), ImageLoaderFactory {get() = tokenStore.isLoggedIn ||dev.lelonio.square.auth.EngineCredentials.exist(this)val recentStore: RecentStore by lazy { RecentStore(this) }+ val listeningStore by lazy { dev.lelonio.square.data.ListeningStore(this) }/** Songs found by searching and then played; see [SearchHistoryStore]. */val searchHistory: dev.lelonio.square.data.SearchHistoryStore by lazy {diff --git a/app/src/main/java/dev/lelonio/square/data/Catalog.kt b/app/src/main/java/dev/lelonio/square/data/Catalog.ktindex 840c60a..9b77182 100644--- a/app/src/main/java/dev/lelonio/square/data/Catalog.kt+++ b/app/src/main/java/dev/lelonio/square/data/Catalog.kt@@ -51,6 +51,7 @@ data class CatalogTrack(val year: String = "",val durationMs: Long = 0,val explicit: Boolean = false,+ val smartRecommended: Boolean = false,val artworkUrl: String? = null,/*** When the track was added to the playlist it was read from, ISO-8601.diff --git a/app/src/main/java/dev/lelonio/square/data/ListeningHistory.kt b/app/src/main/java/dev/lelonio/square/data/ListeningHistory.ktnew file mode 100644index 0000000..a3b7a53--- /dev/null+++ b/app/src/main/java/dev/lelonio/square/data/ListeningHistory.kt@@ -0,0 +1,106 @@+package dev.lelonio.square.data++import kotlinx.serialization.Serializable+import java.time.Instant+import java.time.YearMonth+import java.time.ZoneId++@Serializable+data class ListeningEvent(+ val id: String,+ val track: CatalogTrack,+ val startedAt: Long,+ val endedAt: Long = startedAt,+ val listenedMs: Long = 0,+ val qualified: Boolean = false,+ val measuredMonths: Map<String, Long> = emptyMap(),+ val spotifyAt: Long? = null,+)++data class MonthlyListening(+ val month: YearMonth,+ val plays: Int,+ val minutes: Long,+ val tracks: List<Pair<CatalogTrack, Int>>,+ val artists: List<Pair<String, Int>>,+)++/** Pure aggregation and reconciliation, shared by the store and regression tests. */+object ListeningHistory {+ fun record(events: List<ListeningEvent>, event: ListeningEvent): List<ListeningEvent> {+ val old = events.firstOrNull { it.id == event.id }+ if (old != null && old.listenedMs > event.listenedMs) return events+ if (old != null && old.listenedMs == event.listenedMs && old.track == event.track &&+ old.qualified == event.qualified) return events+ // The API may return an in-progress listen before the next local flush.+ val imported = if (old?.spotifyAt == null) events.firstOrNull {+ it.id.startsWith("spotify:") && it.track.uri == event.track.uri &&+ it.startedAt in (event.startedAt - 15_000)..(event.endedAt + 15_000)+ } else null+ val spotifyAt = old?.spotifyAt ?: imported?.spotifyAt ?: event.spotifyAt+ return events.filterNot { it.id == event.id || it.id == imported?.id } + event.copy(+ spotifyAt = spotifyAt, qualified = event.qualified || spotifyAt != null,+ )+ }++ fun merge(events: List<ListeningEvent>, track: CatalogTrack, at: Long): List<ListeningEvent> {+ if (events.any { it.spotifyAt == at && it.track.uri == track.uri }) return events+ // Match a local play only once. Repeated listens to the same song stay distinct.+ val match = events.filter { it.spotifyAt == null && it.id.startsWith("local:") &&+ it.track.uri == track.uri && at in (it.startedAt - 15_000)..(it.endedAt + 15_000) }+ .minByOrNull { kotlin.math.abs(it.startedAt - at) }+ return if (match != null) events.map {+ if (it.id == match.id) it.copy(spotifyAt = at, qualified = true) else it+ } else events + ListeningEvent("spotify:$at:${track.uri}", track, at, qualified = true, spotifyAt = at)+ }++ fun summarize(events: List<ListeningEvent>, month: YearMonth, zone: ZoneId = ZoneId.systemDefault()): MonthlyListening {+ val start = month.atDay(1).atStartOfDay(zone).toInstant().toEpochMilli()+ val end = month.plusMonths(1).atDay(1).atStartOfDay(zone).toInstant().toEpochMilli()+ val counted = events.filter { it.qualified && (it.spotifyAt ?: it.startedAt) in start until end }+ val tracks = counted.groupBy { it.track.uri }.values.map { it.last().track to it.size }+ .sortedWith(compareByDescending<Pair<CatalogTrack, Int>> { it.second }.thenBy { it.first.name })+ val artists = counted.flatMap { event ->+ event.track.artists.map { it.name }.ifEmpty { listOf(event.track.artist) }.filter { it.isNotBlank() }.distinct()+ }.groupingBy { it }.eachCount().toList().sortedWith(compareByDescending<Pair<String, Int>> { it.second }.thenBy { it.first })+ val ms = events.sumOf { it.measuredMonths[month.toString()] ?: 0L }+ return MonthlyListening(month, counted.size, ms / 60_000, tracks, artists)+ }+}++/** Measures elapsed audible time, never the seek position or the nominal song length. */+class ListeningSampler {+ private var event: ListeningEvent? = null+ private var lastTick: Long? = null+ private var wasPlaying = false+ fun sample(track: CatalogTrack?, playing: Boolean, now: Long, tick: Long): ListeningEvent? {+ val previous = event+ if (track == null || previous?.track?.uri != track.uri) {+ event = track?.takeIf { playing }?.let { ListeningEvent("local:$now:${it.uri}", it, now) }+ lastTick = tick+ wasPlaying = playing+ return previous+ }+ val delta = if (playing && wasPlaying) (tick - (lastTick ?: tick)).coerceIn(0, 2_000) else 0+ val updated = (previous ?: return null).copy(track = track, endedAt = now, listenedMs = previous.listenedMs + delta)+ val threshold = if (track.durationMs > 0) minOf(track.durationMs / 2, 240_000) else 30_000+ val measured = previous.measuredMonths.toMutableMap()+ if (delta > 0) {+ val zone = ZoneId.systemDefault()+ var from = now - delta+ while (from < now) {+ val local = Instant.ofEpochMilli(from).atZone(zone)+ val month = YearMonth.from(local)+ val boundary = month.plusMonths(1).atDay(1).atStartOfDay(zone).toInstant().toEpochMilli()+ val until = minOf(now, boundary)+ measured[month.toString()] = (measured[month.toString()] ?: 0L) + until - from+ from = until+ }+ }+ event = updated.copy(qualified = updated.listenedMs >= threshold, measuredMonths = measured)+ lastTick = tick+ wasPlaying = playing+ return event+ }+ fun reset() { event = null; lastTick = null; wasPlaying = false }+}diff --git a/app/src/main/java/dev/lelonio/square/data/ListeningStore.kt b/app/src/main/java/dev/lelonio/square/data/ListeningStore.ktnew file mode 100644index 0000000..91a2fc8--- /dev/null+++ b/app/src/main/java/dev/lelonio/square/data/ListeningStore.kt@@ -0,0 +1,46 @@+package dev.lelonio.square.data++import android.content.Context+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.MutableStateFlow+import kotlinx.coroutines.flow.asStateFlow+import kotlinx.coroutines.sync.Mutex+import kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.withContext+import kotlinx.serialization.builtins.ListSerializer+import kotlinx.serialization.json.Json++class ListeningStore(context: Context) {+ private val prefs = context.getSharedPreferences("square_listening", Context.MODE_PRIVATE)+ private val json = Json { ignoreUnknownKeys = true }+ private val serializer = ListSerializer(ListeningEvent.serializer())+ private val lock = Mutex()+ private val mutable = MutableStateFlow(runCatching {+ json.decodeFromString(serializer, prefs.getString("events", "[]")!!)+ }.getOrDefault(emptyList()))+ val events = mutable.asStateFlow()+ val account get() = prefs.getString("account", null)++ suspend fun useAccount(id: String) = withContext(Dispatchers.IO) { lock.withLock {+ if (account != id) {+ mutable.value = emptyList()+ prefs.edit().putString("account", id).remove("events").apply()+ }+ } }+ suspend fun record(event: ListeningEvent, owner: String) = withContext(Dispatchers.IO) { lock.withLock {+ if (account != owner) return@withLock+ save(ListeningHistory.record(mutable.value, event))+ } }+ suspend fun import(plays: List<Pair<CatalogTrack, Long>>, owner: String) = withContext(Dispatchers.IO) { lock.withLock {+ if (account != owner) return@withLock+ save(plays.fold(mutable.value) { events, (track, at) -> ListeningHistory.merge(events, track, at) })+ } }+ suspend fun clear() = withContext(Dispatchers.IO) { lock.withLock {+ prefs.edit().clear().apply(); mutable.value = emptyList()+ } }+ private fun save(events: List<ListeningEvent>) {+ if (events == mutable.value) return+ mutable.value = events+ prefs.edit().putString("events", json.encodeToString(serializer, events)).apply()+ }+}diff --git a/app/src/main/java/dev/lelonio/square/data/PlaybackStore.kt b/app/src/main/java/dev/lelonio/square/data/PlaybackStore.ktindex 27c5a0e..046067f 100644--- a/app/src/main/java/dev/lelonio/square/data/PlaybackStore.kt+++ b/app/src/main/java/dev/lelonio/square/data/PlaybackStore.kt@@ -26,6 +26,7 @@ data class SavedPlayback(val contextOrdered: Boolean = false,/** What the player shows as the source: "Playlist · Estate 2025". */val contextLabel: String = "",+ val smartShuffle: Boolean = false,)/**diff --git a/app/src/main/java/dev/lelonio/square/data/SmartShuffle.kt b/app/src/main/java/dev/lelonio/square/data/SmartShuffle.ktnew file mode 100644index 0000000..bc5740d--- /dev/null+++ b/app/src/main/java/dev/lelonio/square/data/SmartShuffle.kt@@ -0,0 +1,33 @@+package dev.lelonio.square.data++/** Spotify's enhanced playlist context, rather than songs drawn from a track radio. */+object SmartShuffle {+ const val COMMAND = "dev.lelonio.square.SMART_SHUFFLE"+ const val MODE = "dev.lelonio.square.SMART_SHUFFLE_ACTIVE"+ const val RECOMMENDED = "dev.lelonio.square.SMART_RECOMMENDED"++ suspend fun recommendations(context: String, excluded: Set<String>): List<CatalogTrack> {+ require(context.startsWith("spotify:playlist:") || context.startsWith("spotify:user:") && context.endsWith(":collection"))+ val originals = Catalog.contextTrackUris(context).toSet()+ val enhanced = Catalog.contextTrackUris("$context?spotify-apply-lenses=enhance")+ val uris = candidates(enhanced, originals + excluded)+ android.util.Log.i("SquareSmartShuffle", "enhanced=${enhanced.size}, original=${originals.size}, recommendations=${uris.size}")+ return Catalog.tracks(uris.take(50))+ }++ fun candidates(enhanced: List<String>, excluded: Set<String>): List<String> =+ enhanced.filter { it.startsWith("spotify:track:") && it !in excluded }.distinct()++ /** Positions in the existing order; explicit play-next entries are never displaced. */+ fun insertionPoints(queued: List<Boolean>, current: Int, count: Int): List<Int> {+ if (current !in queued.indices || count <= 0) return emptyList()+ var songs = 1+ val points = mutableListOf<Int>()+ for (index in current + 1 until queued.size) {+ if (!queued[index]) songs+++ if (!queued[index] && songs % 3 == 0 && points.size < count) points += index + 1+ }+ if (points.isEmpty()) points += queued.size+ return points.take(count)+ }+}diff --git a/app/src/main/java/dev/lelonio/square/data/SpotifyApi.kt b/app/src/main/java/dev/lelonio/square/data/SpotifyApi.ktindex 4fe4613..33d77f3 100644--- a/app/src/main/java/dev/lelonio/square/data/SpotifyApi.kt+++ b/app/src/main/java/dev/lelonio/square/data/SpotifyApi.kt@@ -135,7 +135,10 @@ interface SpotifyApi {* Needs `user-read-recently-played`.*/@GET("v1/me/player/recently-played")- suspend fun recentlyPlayed(@Query("limit") limit: Int = 30): PageDto<PlayHistoryDto>+ suspend fun recentlyPlayed(+ @Query("limit") limit: Int = 30,+ @Query("before") before: Long? = null,+ ): PageDto<PlayHistoryDto>/*** An artist's most-played tracks.diff --git a/app/src/main/java/dev/lelonio/square/playback/LibrespotPlayer.kt b/app/src/main/java/dev/lelonio/square/playback/LibrespotPlayer.ktindex c40cd63..af45abd 100644--- a/app/src/main/java/dev/lelonio/square/playback/LibrespotPlayer.kt+++ b/app/src/main/java/dev/lelonio/square/playback/LibrespotPlayer.kt@@ -1,6 +1,7 @@package dev.lelonio.square.playbackimport android.os.Looper+import android.net.Uriimport androidx.media3.common.MediaItemimport androidx.media3.common.MediaMetadataimport dev.lelonio.square.ui.EXTRA_CONTEXT_LABEL@@ -257,6 +258,7 @@ class LibrespotPlayer(* PlaybackService.*/private var remote: dev.lelonio.square.data.RemotePlayback? = null+ val isRemotePlayback: Boolean get() = remote != null/*** Called with a track the engine is playing that this queue does not hold.@@ -1224,6 +1226,7 @@ class LibrespotPlayer(* back looking as though nothing had ever been playing.*/handOverNow: Boolean = true,+ smartShuffle: Boolean = false,) {if (tracks.isEmpty()) return@@ -1237,6 +1240,7 @@ class LibrespotPlayer(engineIndex = -1sounding = falseshuffleOrder?.let(queue::applyShuffleOrder)+ queue.smartShuffle = smartShuffle && shuffleOrder != nullqueue.currentIndex = index.coerceIn(0, queue.items.lastIndex)shuffleEnabled = shuffleOrder != null@@ -1340,7 +1344,59 @@ class LibrespotPlayer(/*** Reorders the queue rather than only recording a flag; see [PlayQueue].*/+ private var smartLoading = false+ private var smartUnavailableContext: String? = null++ suspend fun cycleShuffle() {+ if (smartLoading || released || isRemotePlayback) return+ if (queue.smartShuffle) {+ queue.disableSmartShuffle()+ shuffleEnabled = false+ onQueueChanged()+ pushOrder()+ invalidateState()+ return+ }+ if (!shuffleEnabled) {+ shuffleModeEnabled = true+ return+ }+ val context = queue.contextUri+ if (context != null && smartUnavailableContext == context) {+ smartUnavailableContext = null+ shuffleModeEnabled = false+ return+ }+ if (context == null || !(context.startsWith("spotify:playlist:") || context.endsWith(":collection"))) {+ shuffleModeEnabled = false+ return+ }+ smartLoading = true+ val initialTracks = queue.items.toList()+ try {+ val recommendations = dev.lelonio.square.data.SmartShuffle.recommendations(context, initialTracks.mapTo(mutableSetOf()) { it.uri })+ // A new playlist, a reorder, a remote transfer or shuffle off cancels this result.+ if (released || isRemotePlayback || queue.contextUri != context || queue.items != initialTracks || !shuffleEnabled) return+ check(recommendations.isNotEmpty()) { "No enhanced recommendations returned" }+ queue.enableSmartShuffle(recommendations.map { track -> PlayQueue.Track(+ uri = track.uri, title = track.name, artist = track.artist,+ artistUri = track.artistUri, artists = track.artists,+ album = track.album, albumUri = track.albumUri,+ durationMs = track.durationMs, artworkUri = track.artworkUrl?.let(Uri::parse),+ explicit = track.explicit, recommended = true,+ ) })+ onQueueChanged()+ pushOrder()+ invalidateState()+ android.util.Log.i("SquareSmartShuffle", "enabled, queue=${queue.items.size}")+ } catch (e: Exception) {+ if (e !is kotlinx.coroutines.CancellationException) smartUnavailableContext = context+ throw e+ } finally { smartLoading = false }+ }+override fun handleSetShuffleModeEnabled(shuffleModeEnabled: Boolean): ListenableFuture<*> {+ if (queue.smartShuffle) queue.disableSmartShuffle()shuffleEnabled = shuffleModeEnabledqueue.setShuffled(shuffleModeEnabled)onQueueChanged()@@ -1779,7 +1835,7 @@ class LibrespotPlayer(* "Duplicate MediaItemData UID in playlist".*/private fun toMediaItemData(index: Int, track: PlayQueue.Track) =- MediaItemData.Builder("$index ${track.uri}")+ MediaItemData.Builder("$index ${track.uri} smart=${queue.smartShuffle}").setMediaItem(MediaItem.Builder().setMediaId(track.uri)@@ -1796,6 +1852,8 @@ class LibrespotPlayer(// moment the queue was rebuilt..setExtras(android.os.Bundle().apply {+ putBoolean(dev.lelonio.square.data.SmartShuffle.MODE, queue.smartShuffle)+ putBoolean(dev.lelonio.square.data.SmartShuffle.RECOMMENDED, track.recommended)queue.contextLabel.takeIf { it.isNotEmpty() }?.let {putString(EXTRA_CONTEXT_LABEL, it)}diff --git a/app/src/main/java/dev/lelonio/square/playback/MediaBrowseTree.kt b/app/src/main/java/dev/lelonio/square/playback/MediaBrowseTree.ktindex 86ee57f..26d10ab 100644--- a/app/src/main/java/dev/lelonio/square/playback/MediaBrowseTree.kt+++ b/app/src/main/java/dev/lelonio/square/playback/MediaBrowseTree.kt@@ -171,6 +171,7 @@ class MediaBrowseTree(val commands = MediaSession.ConnectionResult.DEFAULT_SESSION_AND_LIBRARY_COMMANDS.buildUpon().add(SessionCommand(CMD_SHUFFLE, Bundle.EMPTY))+ .add(SessionCommand(dev.lelonio.square.data.SmartShuffle.COMMAND, Bundle.EMPTY)).add(SessionCommand(CMD_REPEAT, Bundle.EMPTY)).add(SessionCommand(CMD_RADIO, Bundle.EMPTY)).add(SessionCommand(CMD_LIKE, Bundle.EMPTY))@@ -195,6 +196,20 @@ class MediaBrowseTree(): ListenableFuture<SessionResult> {val player = session.playerwhen (customCommand.customAction) {+ dev.lelonio.square.data.SmartShuffle.COMMAND -> {+ return scope.future {+ try {+ if (player is LibrespotPlayer) player.cycleShuffle()+ else player.shuffleModeEnabled = !player.shuffleModeEnabled+ SessionResult(SessionResult.RESULT_SUCCESS)+ } catch (e: Exception) {+ if (e is kotlinx.coroutines.CancellationException) throw e+ android.util.Log.w("SquareSmartShuffle", "cannot enable: ${e.message}")+ android.widget.Toast.makeText(app, R.string.smart_shuffle_unavailable, android.widget.Toast.LENGTH_LONG).show()+ SessionResult(SessionResult.RESULT_ERROR_NOT_SUPPORTED)+ }+ }+ }CMD_SHUFFLE -> player.shuffleModeEnabled = !player.shuffleModeEnabledCMD_REPEAT -> player.repeatMode = when (player.repeatMode) {androidx.media3.common.Player.REPEAT_MODE_OFF ->diff --git a/app/src/main/java/dev/lelonio/square/playback/PlayQueue.kt b/app/src/main/java/dev/lelonio/square/playback/PlayQueue.ktindex bf0ce20..21898da 100644--- a/app/src/main/java/dev/lelonio/square/playback/PlayQueue.kt+++ b/app/src/main/java/dev/lelonio/square/playback/PlayQueue.kt@@ -61,12 +61,14 @@ class PlayQueue {* item it holds, and what it does not carry never reaches the player.*/val explicit: Boolean = false,+ val recommended: Boolean = false,)private val _items = mutableListOf<Track>()val items: List<Track> get() = _itemsvar currentIndex: Int = 0+ var smartShuffle: Boolean = false/** Unshuffled queue, kept so the order can be restored exactly. */private var originalOrder: List<Track>? = null@@ -99,6 +101,7 @@ class PlayQueue {}fun replace(tracks: List<Track>, startIndex: Int) {+ smartShuffle = false_items.clear()_items.addAll(tracks)currentIndex = startIndex.coerceIn(0, maxOf(0, _items.lastIndex))@@ -137,6 +140,36 @@ class PlayQueue {}}+ fun enableSmartShuffle(recommendations: List<Track>) {+ val excluded = items.mapTo(mutableSetOf()) { it.uri }+ val candidates = recommendations.filter { it.uri !in excluded }.distinctBy { it.uri }+ val points = dev.lelonio.square.data.SmartShuffle.insertionPoints(items.map { it.queued }, currentIndex, candidates.size)+ points.zip(candidates).asReversed().forEach { (at, track) ->+ add(at, listOf(track.copy(recommended = true, queued = false)))+ }+ smartShuffle = points.isNotEmpty()+ if (smartShuffle) contextIsOrdered = false+ }++ fun disableSmartShuffle() {+ val current = items.getOrNull(currentIndex)+ val nextOriginal = items.drop(currentIndex + 1).firstOrNull { !it.recommended && !it.queued }+ for (index in items.indices.reversed()) {+ val track = items[index]+ if (track.recommended && !track.queued && index != currentIndex) remove(index, index + 1)+ }+ smartShuffle = false+ setShuffled(false)+ // A recommended song already playing remains immediately before its successor.+ if (current?.recommended == true && nextOriginal != null) {+ val successor = items.indexOfFirst { it === nextOriginal }+ if (successor >= 0 && successor != currentIndex) {+ val target = if (currentIndex < successor) successor - 1 else successor+ if (target != currentIndex) move(currentIndex, currentIndex + 1, target)+ }+ }+ }+private fun clearShuffle() {originalOrder = nulloriginalIndices = null@@ -405,6 +438,7 @@ class PlayQueue {artworkUri = metadata.artworkUri,queued = metadata.extras?.getBoolean(EXTRA_PLAY_NEXT) == true,explicit = metadata.extras?.getBoolean(dev.lelonio.square.ui.EXTRA_EXPLICIT) == true,+ recommended = metadata.extras?.getBoolean(dev.lelonio.square.data.SmartShuffle.RECOMMENDED) == true,)}}diff --git a/app/src/main/java/dev/lelonio/square/playback/PlaybackService.kt b/app/src/main/java/dev/lelonio/square/playback/PlaybackService.ktindex 5d2291f..220b4a8 100644--- a/app/src/main/java/dev/lelonio/square/playback/PlaybackService.kt+++ b/app/src/main/java/dev/lelonio/square/playback/PlaybackService.kt@@ -285,6 +285,7 @@ class PlaybackService : MediaLibraryService() {crossfade = container.crossfadeplayer = buildPlayer(container.preferences.backend.value)+ startListeningRecorder()browseTree = MediaBrowseTree(this, scope, ::ensurePlayerFor)session = MediaLibrarySession.Builder(this, player, browseTree)// Without this the notification is inert to a tap: Media3 has no way@@ -1484,6 +1485,7 @@ class PlaybackService : MediaLibraryService() {contextIsOrdered = saved.contextOrdered,contextLabel = saved.contextLabel,handOverNow = handOverNow,+ smartShuffle = saved.smartShuffle,)android.util.Log.i(TAG, "restored ${saved.tracks.size} tracks at ${saved.index}")}@@ -1524,6 +1526,64 @@ class PlaybackService : MediaLibraryService() {}}+ /** Measures only playback on this device, independently of the activity. */+ private fun startListeningRecorder() {+ val sampler = dev.lelonio.square.data.ListeningSampler()+ scope.launch {+ var owner: String? = null+ var sampledPlayer: androidx.media3.common.Player? = null+ var lastSaved = 0L+ var previouslyPlaying = false+ val listener = object : androidx.media3.common.Player.Listener {+ override fun onMediaItemTransition(item: androidx.media3.common.MediaItem?, reason: Int) {+ sampler.sample(null, false, System.currentTimeMillis(), android.os.SystemClock.elapsedRealtime())?.let { event ->+ owner?.let { account -> scope.launch { container.listeningStore.record(event, account) } }+ }+ }+ }+ try {+ while (true) {+ val account = container.listeningStore.account+ if (account != owner) { sampler.reset(); owner = account }+ if (sampledPlayer !== player) {+ sampledPlayer?.removeListener(listener)+ sampledPlayer = player+ player.addListener(listener)+ }+ val spotify = container.preferences.backend.value == dev.lelonio.square.backend.BackendId.SPOTIFY+ val remote = (player as? LibrespotPlayer)?.isRemotePlayback == true+ val item = player.currentMediaItem+ val metadata = item?.mediaMetadata+ val track = if (spotify && !remote && account != null && item != null &&+ !metadata?.title.isNullOrBlank()) CatalogTrack(+ uri = item.mediaId,+ name = metadata?.title.toString(),+ artist = metadata?.artist?.toString().orEmpty(),+ artists = creditedArtists(metadata?.extras),+ album = metadata?.albumTitle?.toString().orEmpty(),+ albumUri = metadata?.extras?.getString(dev.lelonio.square.ui.EXTRA_ALBUM_URI),+ durationMs = metadata?.durationMs ?: player.duration.coerceAtLeast(0),+ artworkUrl = metadata?.artworkUri?.toString(),+ ) else null+ val tick = android.os.SystemClock.elapsedRealtime()+ val event = sampler.sample(track, player.isPlaying && !remote, System.currentTimeMillis(), tick)+ if (event != null && (tick - lastSaved >= 10_000 || previouslyPlaying != player.isPlaying || event.track.uri != track?.uri)) {+ account?.let { container.listeningStore.record(event, it) }+ lastSaved = tick+ }+ previouslyPlaying = player.isPlaying+ delay(1_000)+ }+ } finally {+ sampledPlayer?.removeListener(listener)+ val event = sampler.sample(null, false, System.currentTimeMillis(), android.os.SystemClock.elapsedRealtime())+ if (event != null && owner != null) kotlinx.coroutines.withContext(kotlinx.coroutines.NonCancellable) {+ container.listeningStore.record(event, owner!!)+ }+ }+ }+ }+/*** Snapshots the queue.*@@ -1546,6 +1606,7 @@ class PlaybackService : MediaLibraryService() {SavedPlayback(tracks = queue.originalTracks.map(::toCatalogTrack),shuffleOrder = queue.shuffleOrder,+ smartShuffle = queue.smartShuffle,index = queue.currentIndex,positionMs = player.currentPosition.coerceAtLeast(0),repeatMode = player.repeatMode,@@ -1693,6 +1754,7 @@ class PlaybackService : MediaLibraryService() {artists = track.artists,durationMs = track.durationMs,artworkUrl = track.artworkUri?.toString(),+ smartRecommended = track.recommended,)private fun toQueueTrack(track: CatalogTrack) = PlayQueue.Track(@@ -1706,6 +1768,7 @@ class PlaybackService : MediaLibraryService() {durationMs = track.durationMs,artworkUri = track.artworkUrl?.let(android.net.Uri::parse),explicit = track.explicit,+ recommended = track.smartRecommended,)/** The two parallel lists put back together; see EXTRA_ARTIST_NAMES. */diff --git a/app/src/main/java/dev/lelonio/square/ui/MainViewModel.kt b/app/src/main/java/dev/lelonio/square/ui/MainViewModel.ktindex 4f63920..6591e59 100644--- a/app/src/main/java/dev/lelonio/square/ui/MainViewModel.kt+++ b/app/src/main/java/dev/lelonio/square/ui/MainViewModel.kt@@ -1965,6 +1965,38 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {_videoMode.value = !_videoMode.value && _videoFileId.value != null}+ val listeningEvents = container.listeningStore.events+ private var listeningSync: kotlinx.coroutines.Job? = null+ private var lastListeningSync = 0L++ fun syncListeningHistory() {+ if (container.preferences.backend.value != dev.lelonio.square.backend.BackendId.SPOTIFY ||+ listeningSync?.isActive == true || System.currentTimeMillis() - lastListeningSync < 60_000) return+ listeningSync = viewModelScope.launch {+ runCatching {+ val owner = meId ?: runCatching { dev.lelonio.square.nativecore.NativeBridge.username() }+ .getOrNull()?.takeIf { it.isNotBlank() }+ ?: container.api.me().id.also { meId = it }+ container.listeningStore.useAccount(owner)+ var before: Long? = null+ // Spotify exposes recent history, not a complete monthly archive.+ // Preserve each import so the archive grows on later visits.+ repeat(5) {+ val page = container.api.recentlyPlayed(50, before)+ val plays = page.items.mapNotNull { play ->+ val at = runCatching { java.time.Instant.parse(play.playedAt).toEpochMilli() }.getOrNull()+ at?.let { play.track.toCatalogTrack() to it }+ }+ container.listeningStore.import(plays, owner)+ val oldest = plays.minOfOrNull { it.second } ?: return@runCatching+ if (page.next == null || oldest == before) return@runCatching+ before = oldest+ }+ }.onSuccess { lastListeningSync = System.currentTimeMillis() }+ .onFailure { android.util.Log.w(TAG, "listening history unavailable: ${describe(it)}") }+ }+ }+val recent: StateFlow<List<CatalogTrack>> =combine(container.recentStore.tracks, container.preferences.backend) { tracks, _ ->// A nameless row is one that was recorded before the session had@@ -2138,6 +2170,9 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {// back in with it and signing out would mean nothing.dev.lelonio.square.auth.EngineCredentials.clear(getApplication())container.recentStore.clear()+ listeningSync?.cancel()+ lastListeningSync = 0L+ viewModelScope.launch { container.listeningStore.clear() }container.playlistOrder.clear()// Somebody else's library must not be sitting in the cache when the// next account signs in.@@ -2453,6 +2488,7 @@ class MainViewModel(app: Application) : AndroidViewModel(app) {// answered sooner left it unset for the whole run, every// playlist's "mine" unknown, and what hangs on it hidden.meId = profile.id+ container.listeningStore.useAccount(profile.id)val ready = _state.value as? UiState.Ready ?: return@onSuccess_state.value = ready.copy(displayName = profile.displayName?.takeIf(String::isNotBlank)diff --git a/app/src/main/java/dev/lelonio/square/ui/SquareApp.kt b/app/src/main/java/dev/lelonio/square/ui/SquareApp.ktindex 3cf49a7..00a69ac 100644--- a/app/src/main/java/dev/lelonio/square/ui/SquareApp.kt+++ b/app/src/main/java/dev/lelonio/square/ui/SquareApp.kt@@ -421,6 +421,13 @@ fun SquareApp(viewModel: MainViewModel = viewModel(),) {val state by viewModel.state.collectAsStateWithLifecycle()+ val listeningEvents by viewModel.listeningEvents.collectAsStateWithLifecycle()+ LaunchedEffect(state is MainViewModel.UiState.Ready) {+ if (state is MainViewModel.UiState.Ready) while (true) {+ viewModel.syncListeningHistory()+ kotlinx.coroutines.delay(300_000)+ }+ }val playlist by viewModel.playlist.collectAsStateWithLifecycle()val takenOut by viewModel.takenOut.collectAsStateWithLifecycle()val context = LocalContext.current@@ -1553,6 +1560,13 @@ fun SquareApp(onLoadMoreYouTube = viewModel::loadMoreYouTubeHome,youtubeSignedIn = youtubeAccountName != null,onYouTubeSignIn = { showYouTubeLogin = true },+ onSwitchSource = {+ preferences.setBackend(+ if (backend == dev.lelonio.square.backend.BackendId.SPOTIFY)+ dev.lelonio.square.backend.BackendId.YOUTUBE_MUSIC+ else dev.lelonio.square.backend.BackendId.SPOTIFY,+ )+ },onUseYouTube = {preferences.setBackend(dev.lelonio.square.backend.BackendId.YOUTUBE_MUSIC)},@@ -1730,6 +1744,7 @@ fun SquareApp(}composable(Routes.LIBRARY) {+ LaunchedEffect(backend, state is MainViewModel.UiState.Ready) { viewModel.syncListeningHistory() }LibraryScreen(state = state,contentPadding = listPadding,@@ -1737,6 +1752,7 @@ fun SquareApp(onRetry = { viewModel.retryFailed() },onLogOut = viewModel::logOut,onOpenPlaylist = { navController.openPlaylist(viewModel, it) },+ listeningEvents = if (backend == dev.lelonio.square.backend.BackendId.SPOTIFY) listeningEvents else null,playlistOrder = playlistOrder,pinned = pinnedPlaylists,canEdit = viewModel.canEditPlaylists,@@ -2900,7 +2916,9 @@ fun SquareApp(val wanted = remote?.shuffle != trueonRemote { id -> RemoteConnect.setShuffle(id, wanted) }} else {- player?.let { it.shuffleModeEnabled = !it.shuffleModeEnabled }+ if (backend == dev.lelonio.square.backend.BackendId.SPOTIFY && player is androidx.media3.session.MediaController) {+ player.sendCustomCommand(androidx.media3.session.SessionCommand(dev.lelonio.square.data.SmartShuffle.COMMAND, android.os.Bundle.EMPTY), android.os.Bundle.EMPTY)+ } else player?.let { it.shuffleModeEnabled = !it.shuffleModeEnabled }}},onCycleRepeat = {@@ -3561,11 +3579,8 @@ fun SquareApp(Box(Modifier.fillMaxSize()- // A colour of its own: the theme's background is- // transparent, because every page in this app is- // drawn over the blurred artwork. A curtain has to- // be opaque or it is not a curtain.- .background(Color(0xFF0A0A0A)),+ // Opaque, using the same light/dark ground as the pages.+ .background(dev.lelonio.square.ui.theme.pageGround()),contentAlignment = Alignment.Center,) {Column(diff --git a/app/src/main/java/dev/lelonio/square/ui/home/HomeScreen.kt b/app/src/main/java/dev/lelonio/square/ui/home/HomeScreen.ktindex 9cc76d3..4b7ac42 100644--- a/app/src/main/java/dev/lelonio/square/ui/home/HomeScreen.kt+++ b/app/src/main/java/dev/lelonio/square/ui/home/HomeScreen.kt@@ -1,6 +1,7 @@package dev.lelonio.square.ui.homeimport androidx.annotation.StringRes+import androidx.compose.foundation.clickableimport androidx.compose.foundation.backgroundimport androidx.compose.foundation.layout.Arrangementimport androidx.compose.foundation.layout.aspectRatio@@ -62,6 +63,7 @@ import androidx.compose.ui.unit.lerpimport dev.lelonio.square.ui.glass.backdrop.Backdropimport com.adamglin.PhosphorIconsimport com.adamglin.phosphoricons.Regular+import com.adamglin.phosphoricons.regular.ArrowsLeftRightimport com.adamglin.phosphoricons.regular.SpotifyLogoimport com.adamglin.phosphoricons.regular.YoutubeLogoimport androidx.compose.foundation.layout.Spacer@@ -164,6 +166,7 @@ fun HomeScreen(onYouTubeSignIn: () -> Unit = {},/** Signed out of Spotify: play from the other source instead. */onUseYouTube: () -> Unit = {},+ onSwitchSource: () -> Unit = {},/*** Spotify's own personalised shelves, empty when the gateway said nothing.*@@ -184,6 +187,7 @@ fun HomeScreen(onPlayTrending = onPlayTrending,onOpenPlaylist = onOpenPlaylist,onOpenSettings = onOpenSettings,+ onSwitchSource = onSwitchSource,onPickChip = onPickYouTubeChip,onLoadMore = onLoadMoreYouTube,signedIn = youtubeSignedIn,@@ -301,6 +305,7 @@ fun HomeScreen(avatarUrl = state.avatarUrl,service = R.string.backend_spotify,serviceIcon = PhosphorIcons.Regular.SpotifyLogo,+ onSwitchSource = onSwitchSource,collapse = { collapse },// The chip that is lit is the one that was tapped. It used// to follow whichever section the scroll had reached, which@@ -571,6 +576,7 @@ private fun Header(@StringRes service: Int,/** Its mark, so the source is recognisable before the line is read. */serviceIcon: androidx.compose.ui.graphics.vector.ImageVector,+ onSwitchSource: () -> Unit,/*** How far collapsed, as a lambda rather than a value.*@@ -652,6 +658,10 @@ private fun Header(Row(verticalAlignment = Alignment.CenterVertically,modifier = Modifier+ .clickable(+ onClickLabel = stringResource(if (service == R.string.backend_spotify) R.string.backend_youtube else R.string.backend_spotify),+ onClick = onSwitchSource,+ ).layout { measurable, constraints ->val placeable = measurable.measure(constraints)val height = ((1f - collapse()) * placeable.height).toInt()@@ -676,11 +686,18 @@ private fun Header(stringResource(service),name.takeIf { it.isNotBlank() },).joinToString(" · "),+ modifier = Modifier.weight(1f, fill = false),style = MaterialTheme.typography.labelLarge,color = InkDim,maxLines = 1,overflow = TextOverflow.Ellipsis,)+ Icon(+ PhosphorIcons.Regular.ArrowsLeftRight,+ contentDescription = null,+ tint = InkDim,+ modifier = Modifier.padding(start = 6.dp).size(14.dp),+ )}// The app's own name, at the size the account name used to be.// It is what the page is, and unlike the account it is worth@@ -1257,6 +1274,7 @@ private fun YouTubeHome(onPlayTrending: (List<CatalogTrack>, Int) -> Unit,onOpenPlaylist: (CatalogPlaylist) -> Unit,onOpenSettings: () -> Unit,+ onSwitchSource: () -> Unit,onPickChip: (dev.lelonio.square.backend.HomeChip?) -> Unit,onLoadMore: () -> Unit,signedIn: Boolean,@@ -1290,6 +1308,7 @@ private fun YouTubeHome(// Nothing scrolls under it here, so it stays as it opens.collapse = { 0f },onOpenSettings = onOpenSettings,+ onSwitchSource = onSwitchSource,)}return@@ -1314,6 +1333,7 @@ private fun YouTubeHome(backdrop = backdrop,collapse = { collapse },onOpenSettings = onOpenSettings,+ onSwitchSource = onSwitchSource,)LazyColumn(@@ -1530,6 +1550,7 @@ private fun YouTubeHeader(backdrop: Backdrop,collapse: () -> Float,onOpenSettings: () -> Unit,+ onSwitchSource: () -> Unit,modifier: Modifier = Modifier,) {Header(@@ -1538,6 +1559,7 @@ private fun YouTubeHeader(avatarUrl = null,service = R.string.backend_youtube,serviceIcon = PhosphorIcons.Regular.YoutubeLogo,+ onSwitchSource = onSwitchSource,collapse = collapse,highlighted = Feed.entries.first(),backdrop = backdrop,diff --git a/app/src/main/java/dev/lelonio/square/ui/library/LibraryScreen.kt b/app/src/main/java/dev/lelonio/square/ui/library/LibraryScreen.ktindex df65972..fd44bf1 100644--- a/app/src/main/java/dev/lelonio/square/ui/library/LibraryScreen.kt+++ b/app/src/main/java/dev/lelonio/square/ui/library/LibraryScreen.kt@@ -75,6 +75,7 @@ import com.adamglin.phosphoricons.fill.PushPinimport com.adamglin.phosphoricons.Regularimport com.adamglin.phosphoricons.regular.ArrowsDownUpimport com.adamglin.phosphoricons.regular.ListBullets+import com.adamglin.phosphoricons.regular.ChartBarimport com.adamglin.phosphoricons.regular.Plusimport com.adamglin.phosphoricons.regular.SquaresFour@@ -145,6 +146,7 @@ fun LibraryScreen(/** Signed out of Spotify: the other source, and the settings; see SignedOutOptions. */onUseYouTube: () -> Unit = {},onOpenSettings: () -> Unit = {},+ listeningEvents: List<dev.lelonio.square.data.ListeningEvent>? = null,backdrop: Backdrop,) {when (state) {@@ -197,6 +199,7 @@ fun LibraryScreen(}var filter by remember { mutableStateOf(Filter.ALL) }var sortOpen by remember { mutableStateOf(false) }+ var recapOpen by remember { mutableStateOf(false) }// Recorded so the menu has the tiles behind it to blur, rather than// the page colour: over a flat fill glass has nothing to bend and// comes out looking like a hole. Safe to record — the menu is drawn@@ -293,6 +296,7 @@ fun LibraryScreen(onSortAnchor = { sortAnchor = it },canEdit = canEdit,onCreatePlaylist = onCreatePlaylist,+ onOpenRecap = if (listeningEvents != null) ({ recapOpen = true }) else null,)val listPadding = PaddingValues(@@ -417,6 +421,10 @@ fun LibraryScreen(}}+ if (recapOpen && listeningEvents != null) {+ MonthlyListeningDialog(listeningEvents, backdrop, onDismiss = { recapOpen = false })+ }+// The app's own menu rather than Material's card: see GlassMenu.// The same one the track sort on a playlist page opens, for the// same reason — a menu that arrives from another design system is@@ -497,6 +505,7 @@ private fun Header(onSortAnchor: (androidx.compose.ui.unit.IntOffset) -> Unit,canEdit: Boolean,onCreatePlaylist: () -> Unit,+ onOpenRecap: (() -> Unit)? = null,) {Column(Modifier@@ -521,6 +530,18 @@ private fun Header()}+ if (onOpenRecap != null) {+ LiquidButton(+ onClick = onOpenRecap, backdrop = backdrop,+ modifier = Modifier.padding(end = 8.dp).size(42.dp),+ contentHeight = 42.dp, contentPadding = 0.dp,+ ) {+ Icon(PhosphorIcons.Regular.ChartBar,+ contentDescription = stringResource(R.string.recap_title),+ tint = Ink, modifier = Modifier.size(20.dp))+ }+ }+// Only where a playlist can actually be made: on a source with no// account signed in, a plus that always failed would be worse than// no plus at all.diff --git a/app/src/main/java/dev/lelonio/square/ui/library/MonthlyListeningDialog.kt b/app/src/main/java/dev/lelonio/square/ui/library/MonthlyListeningDialog.ktnew file mode 100644index 0000000..03612b6--- /dev/null+++ b/app/src/main/java/dev/lelonio/square/ui/library/MonthlyListeningDialog.kt@@ -0,0 +1,111 @@+package dev.lelonio.square.ui.library++import androidx.compose.foundation.layout.*+import androidx.compose.foundation.rememberScrollState+import androidx.compose.foundation.verticalScroll+import androidx.compose.foundation.shape.RoundedCornerShape+import androidx.compose.ui.window.Dialog+import androidx.compose.ui.window.DialogProperties+import androidx.compose.ui.platform.LocalConfiguration+import androidx.compose.ui.Alignment+import androidx.compose.material3.Icon+import dev.lelonio.square.ui.components.menuSkin+import com.adamglin.PhosphorIcons+import com.adamglin.phosphoricons.Regular+import com.adamglin.phosphoricons.regular.X+import androidx.compose.material3.MaterialTheme+import androidx.compose.material3.Text+import androidx.compose.runtime.*+import androidx.compose.ui.Modifier+import androidx.compose.ui.res.stringResource+import androidx.compose.ui.text.font.FontWeight+import androidx.compose.ui.text.style.TextOverflow+import androidx.compose.ui.unit.dp+import dev.lelonio.square.R+import dev.lelonio.square.data.ListeningEvent+import dev.lelonio.square.data.ListeningHistory+import dev.lelonio.square.ui.components.Artwork+import dev.lelonio.square.ui.glass.LiquidButton+import dev.lelonio.square.ui.glass.backdrop.Backdrop+import dev.lelonio.square.ui.theme.Ink+import dev.lelonio.square.ui.theme.InkDim+import java.time.Instant+import java.time.YearMonth+import java.time.ZoneId+import java.time.format.DateTimeFormatter+import java.util.Locale++@Composable+fun MonthlyListeningDialog(events: List<ListeningEvent>, backdrop: Backdrop, onDismiss: () -> Unit) {+ val current = YearMonth.now()+ var month by remember { mutableStateOf(current) }++ val summary = remember(events, month) { ListeningHistory.summarize(events, month) }+ val first = remember(events) {+ events.minOfOrNull { it.startedAt }?.let {+ YearMonth.from(Instant.ofEpochMilli(it).atZone(ZoneId.systemDefault()))+ } ?: current+ }+ val maxHeight = LocalConfiguration.current.screenHeightDp.dp * 0.82f+ Dialog(onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false)) {+ Column(Modifier.padding(20.dp).fillMaxWidth().heightIn(max = maxHeight)+ .menuSkin(RoundedCornerShape(28.dp)).verticalScroll(rememberScrollState()).padding(22.dp),+ verticalArrangement = Arrangement.spacedBy(18.dp)) {+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {+ Text(stringResource(R.string.recap_title), modifier = Modifier.weight(1f),+ style = MaterialTheme.typography.titleLarge, color = Ink)+ LiquidButton(onClick = onDismiss, backdrop = backdrop, flat = true,+ modifier = Modifier.size(44.dp), contentHeight = 44.dp, contentPadding = 0.dp) {+ Icon(PhosphorIcons.Regular.X, contentDescription = stringResource(R.string.close),+ tint = Ink, modifier = Modifier.size(20.dp))+ }+ }+ Text(month.format(DateTimeFormatter.ofPattern("LLLL yyyy", Locale.getDefault())),+ style = MaterialTheme.typography.titleMedium, color = InkDim)+ Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically,+ horizontalArrangement = Arrangement.spacedBy(18.dp)) {+ summary.tracks.firstOrNull()?.first?.let { track ->+ Artwork(track.artworkUrl, track.name, Modifier.size(72.dp), corner = 14.dp)+ }+ Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(4.dp)) {+ Text(stringResource(R.string.recap_plays, summary.plays),+ style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold, color = Ink)+ if (summary.minutes > 0) Text(stringResource(R.string.recap_minutes, summary.minutes),+ style = MaterialTheme.typography.bodyMedium, color = InkDim)+ }+ }+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {+ LiquidButton(onClick = { if (month > first) month = month.minusMonths(1) }, backdrop = backdrop,+ isInteractive = month > first, flat = true, contentHeight = 32.dp) {+ Text(stringResource(R.string.recap_previous), color = if (month > first) Ink else InkDim)+ }+ if (month < current) LiquidButton(onClick = { month = month.plusMonths(1) }, backdrop = backdrop,+ flat = true, contentHeight = 32.dp) {+ Text(stringResource(R.string.recap_next), color = Ink)+ }+ }+ if (summary.tracks.isNotEmpty()) {+ Text(stringResource(R.string.recap_tracks), style = MaterialTheme.typography.titleMedium, color = Ink)+ summary.tracks.take(5).forEach { (track, count) ->+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) {+ Artwork(track.artworkUrl, track.name, Modifier.size(44.dp))+ Column(Modifier.weight(1f)) {+ Text(track.name, maxLines = 1, overflow = TextOverflow.Ellipsis, color = Ink)+ Text(track.artist, maxLines = 1, overflow = TextOverflow.Ellipsis,+ style = MaterialTheme.typography.bodySmall, color = InkDim)+ }+ Text(count.toString(), color = InkDim)+ }+ }+ Text(stringResource(R.string.recap_artists), style = MaterialTheme.typography.titleMedium, color = Ink)+ summary.artists.take(5).forEach { (artist, count) ->+ Row(Modifier.fillMaxWidth()) {+ Text(artist, modifier = Modifier.weight(1f), color = Ink)+ Text(count.toString(), color = InkDim)+ }+ }+ }+ Text(stringResource(R.string.recap_partial), style = MaterialTheme.typography.bodySmall, color = InkDim)+ }+ }+}diff --git a/app/src/main/java/dev/lelonio/square/ui/player/FloatingMiniPlayer.kt b/app/src/main/java/dev/lelonio/square/ui/player/FloatingMiniPlayer.ktindex 50cc04c..2417cbd 100644--- a/app/src/main/java/dev/lelonio/square/ui/player/FloatingMiniPlayer.kt+++ b/app/src/main/java/dev/lelonio/square/ui/player/FloatingMiniPlayer.kt@@ -55,6 +55,8 @@ import androidx.compose.ui.unit.LayoutDirectionimport androidx.compose.ui.unit.dpimport androidx.compose.ui.unit.spimport com.adamglin.PhosphorIcons+import com.adamglin.phosphoricons.Regular+import com.adamglin.phosphoricons.regular.Sparkleimport com.adamglin.phosphoricons.Fillimport com.adamglin.phosphoricons.fill.Devicesimport com.adamglin.phosphoricons.fill.Pause@@ -200,6 +202,13 @@ fun FloatingMiniPlayer(Spacer(Modifier.width(androidx.compose.ui.unit.lerp(10.dp, 8.dp, fold)))Column(Modifier.weight(1f)) {+ Row(verticalAlignment = Alignment.CenterVertically) {+ if (state.smartRecommended) Icon(+ PhosphorIcons.Regular.Sparkle,+ contentDescription = null,+ tint = contentColor,+ modifier = Modifier.padding(end = 4.dp).size(14.dp),+ )Text(text = state.title,style = androidx.compose.ui.text.lerp(@@ -211,6 +220,7 @@ fun FloatingMiniPlayer(maxLines = 1,overflow = TextOverflow.Ellipsis,)+ }Row(verticalAlignment = Alignment.CenterVertically) {if (remoteLabel != null) {Icon(diff --git a/app/src/main/java/dev/lelonio/square/ui/player/PlayerPanel.kt b/app/src/main/java/dev/lelonio/square/ui/player/PlayerPanel.ktindex d978d9e..06f59cd 100644--- a/app/src/main/java/dev/lelonio/square/ui/player/PlayerPanel.kt+++ b/app/src/main/java/dev/lelonio/square/ui/player/PlayerPanel.kt@@ -62,6 +62,7 @@ import com.adamglin.phosphoricons.regular.VinylRecordimport com.adamglin.phosphoricons.fill.Infoimport com.adamglin.phosphoricons.regular.Infoimport com.adamglin.phosphoricons.regular.X+import com.adamglin.phosphoricons.regular.Sparkleimport dev.lelonio.square.ui.glass.pressable/** Which panel is open below the transport controls. */@@ -263,6 +264,7 @@ data class QueueEntry(val isCurrent: Boolean,/** Already heard: shown above the playing track, dimmed. */val played: Boolean = false,+ val recommended: Boolean = false,)@Composable@@ -332,6 +334,13 @@ internal fun QueueList(maxLines = 1,overflow = TextOverflow.Ellipsis,)+ Row(verticalAlignment = Alignment.CenterVertically) {+ if (entry.recommended) Icon(+ PhosphorIcons.Regular.Sparkle,+ contentDescription = stringResource(R.string.smart_shuffle),+ tint = GlassInkDim,+ modifier = Modifier.padding(end = 4.dp).size(12.dp),+ )Text(entry.artist,style = MaterialTheme.typography.bodySmall,@@ -339,6 +348,7 @@ internal fun QueueList(maxLines = 1,overflow = TextOverflow.Ellipsis,)+ }}// Not on the track being played: taking that one out is adiff --git a/app/src/main/java/dev/lelonio/square/ui/player/PlayerScreen.kt b/app/src/main/java/dev/lelonio/square/ui/player/PlayerScreen.ktindex 247ab2c..2ccb588 100644--- a/app/src/main/java/dev/lelonio/square/ui/player/PlayerScreen.kt+++ b/app/src/main/java/dev/lelonio/square/ui/player/PlayerScreen.kt@@ -132,6 +132,7 @@ import com.adamglin.phosphoricons.regular.Broadcastimport com.adamglin.phosphoricons.regular.YoutubeLogoimport com.adamglin.phosphoricons.regular.Repeatimport com.adamglin.phosphoricons.regular.RepeatOnce+import com.adamglin.phosphoricons.regular.Sparkleimport com.adamglin.phosphoricons.regular.Shuffleimport com.adamglin.phosphoricons.regular.TextAlignLeftimport kotlin.math.abs@@ -1926,6 +1927,15 @@ private fun TitleBlock(// track another device is playing, names a record this app has no// address for, and a title that looks like a link and does nothing// is worse than a caption.+ Row(verticalAlignment = Alignment.CenterVertically) {+ if (state.smartRecommended) {+ Icon(+ PhosphorIcons.Regular.Sparkle,+ contentDescription = stringResource(R.string.smart_shuffle),+ tint = GlassInk,+ modifier = Modifier.padding(end = 8.dp).size(20.dp),+ )+ }Text(text = title,style = MaterialTheme.typography.titleLarge,@@ -1937,6 +1947,7 @@ private fun TitleBlock(Modifier},)+ }// The rating beside the names rather than on its own line: it is// about the song, and a line of its own would read as a warning.if (state.explicit) {@@ -2056,8 +2067,9 @@ internal fun Controls() {ToggleIcon(icon = PhosphorIcons.Regular.Shuffle,- description = stringResource(R.string.shuffle_play),+ description = stringResource(if (state.smartShuffle) R.string.smart_shuffle else R.string.shuffle_play),active = state.shuffleEnabled,+ smart = state.smartShuffle,onClick = onToggleShuffle,)@@ -2244,15 +2256,24 @@ private fun ToggleIcon(icon: androidx.compose.ui.graphics.vector.ImageVector,description: String,active: Boolean,+ smart: Boolean = false,onClick: () -> Unit,) {IconButton(onClick = onClick) {+ Box(Modifier.size(if (smart) 28.dp else 22.dp)) {Icon(icon,contentDescription = description,tint = if (active) GlassInk else GlassInkDim,- modifier = Modifier.size(22.dp),+ modifier = Modifier.size(22.dp).align(Alignment.BottomStart),)+ if (smart) Icon(+ PhosphorIcons.Regular.Sparkle,+ contentDescription = null,+ tint = if (active) GlassInk else GlassInkDim,+ modifier = Modifier.size(10.dp).align(Alignment.TopEnd),+ )+ }}}diff --git a/app/src/main/java/dev/lelonio/square/ui/player/PlayerState.kt b/app/src/main/java/dev/lelonio/square/ui/player/PlayerState.ktindex 0bb0278..2e541ce 100644--- a/app/src/main/java/dev/lelonio/square/ui/player/PlayerState.kt+++ b/app/src/main/java/dev/lelonio/square/ui/player/PlayerState.kt@@ -54,6 +54,8 @@ data class PlaybackState(val hasNext: Boolean = false,val hasPrevious: Boolean = false,val shuffleEnabled: Boolean = false,+ val smartShuffle: Boolean = false,+ val smartRecommended: Boolean = false,val repeatMode: Int = Player.REPEAT_MODE_OFF,/** Tempo, 1.0 being the track as recorded. */val speed: Float = 1f,@@ -212,6 +214,8 @@ fun rememberPlaybackState(hasNext = player.hasNextMediaItem(),hasPrevious = player.hasPreviousMediaItem(),shuffleEnabled = player.shuffleModeEnabled,+ smartShuffle = player.shuffleModeEnabled && player.currentMediaItem?.mediaMetadata?.extras?.getBoolean(dev.lelonio.square.data.SmartShuffle.MODE) == true,+ smartRecommended = player.currentMediaItem?.mediaMetadata?.extras?.getBoolean(dev.lelonio.square.data.SmartShuffle.RECOMMENDED) == true,repeatMode = player.repeatMode,speed = player.playbackParameters.speed,pitch = player.playbackParameters.pitch,@@ -308,6 +312,7 @@ fun rememberQueue(player: Player?): State<List<QueueEntry>> {artist = metadata.artist?.toString().orEmpty(),isCurrent = index == current,played = index < current,+ recommended = metadata.extras?.getBoolean(dev.lelonio.square.data.SmartShuffle.RECOMMENDED) == true,)}}diff --git a/app/src/main/java/dev/lelonio/square/ui/settings/SettingsScreen.kt b/app/src/main/java/dev/lelonio/square/ui/settings/SettingsScreen.ktindex 7f8e1cd..8cb1541 100644--- a/app/src/main/java/dev/lelonio/square/ui/settings/SettingsScreen.kt+++ b/app/src/main/java/dev/lelonio/square/ui/settings/SettingsScreen.kt@@ -91,6 +91,7 @@ import androidx.compose.foundation.layout.fillMaxHeightimport com.adamglin.phosphoricons.regular.Trashimport com.adamglin.phosphoricons.regular.HandHeartimport com.adamglin.phosphoricons.regular.ChatsCircle+import com.adamglin.phosphoricons.regular.TelegramLogoimport com.adamglin.phosphoricons.regular.Bugimport dev.lelonio.square.Rimport dev.lelonio.square.data.AppLanguages@@ -751,6 +752,12 @@ fun SettingsScreen(if (shown == SettingsPage.About) item("help") {val uriHandler = LocalUriHandler.currentSection(stringResource(R.string.help_feedback)) {+ ActionRow(+ stringResource(R.string.telegram_community),+ destructive = false,+ icon = PhosphorIcons.Regular.TelegramLogo,+ ) { uriHandler.openUri(TELEGRAM_COMMUNITY_URL) }+ RowDivider()ActionRow(stringResource(R.string.help_discussions),destructive = false,@@ -1958,4 +1965,5 @@ private const val GITHUB_USER = "Lelonio"private const val GITHUB_URL = "https://github.com/Lelonio"private const val KOFI_URL = "https://ko-fi.com/lelonio"private const val DISCUSSIONS_URL = "https://github.com/Lelonio/Square/discussions"+private const val TELEGRAM_COMMUNITY_URL = "https://t.me/+SAOhZ4HTFpMwNDJk"private const val NEW_ISSUE_URL = "https://github.com/Lelonio/Square/issues/new/choose"diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xmlindex 7257c24..a836097 100644--- a/app/src/main/res/values-de/strings.xml+++ b/app/src/main/res/values-de/strings.xml@@ -505,4 +505,16 @@<string name="followed_releases_connect">Verbinde Spotify in den Einstellungen, um Veröffentlichungen deiner gefolgten Künstler zu sehen.</string><string name="new_from_followed_artists">Neues von deinen Künstlern</string><string name="connected_device_label">Verbundenes Gerät anzeigen</string>++ <string name="recap_title">Dein Musikmonat</string>+ <string name="recap_plays">%1$d Wiedergaben</string>+ <string name="recap_minutes">%1$d Minuten in Square</string>+ <string name="recap_details">Deine Favoriten ansehen</string>+ <string name="recap_hide">Details ausblenden</string>+ <string name="recap_previous">Vorheriger Monat</string>+ <string name="recap_next">Nächster Monat</string>+ <string name="recap_tracks">Meistgespielte Songs</string>+ <string name="recap_artists">Meistgehörte Künstler</string>+ <string name="recap_partial">Gespeicherte Wiedergaben und der aktuelle Spotify-Verlauf. Frühere oder nicht synchronisierte Wiedergaben können fehlen. Minuten werden nur in Square gemessen.</string>+ <string name="telegram_community">Telegram-Community</string></resources>diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xmlindex cf29d58..1a2edae 100644--- a/app/src/main/res/values-es/strings.xml+++ b/app/src/main/res/values-es/strings.xml@@ -511,4 +511,16 @@<string name="followed_releases_connect">Conecta Spotify en Ajustes para ver los lanzamientos de los artistas que sigues.</string><string name="new_from_followed_artists">Novedades de tus artistas</string><string name="connected_device_label">Mostrar dispositivo conectado</string>++ <string name="recap_title">Tu mes en música</string>+ <string name="recap_plays">%1$d reproducciones</string>+ <string name="recap_minutes">%1$d minutos en Square</string>+ <string name="recap_details">Ver tus favoritos</string>+ <string name="recap_hide">Ocultar detalles</string>+ <string name="recap_previous">Mes anterior</string>+ <string name="recap_next">Mes siguiente</string>+ <string name="recap_tracks">Canciones más escuchadas</string>+ <string name="recap_artists">Artistas más escuchados</string>+ <string name="recap_partial">Incluye las escuchas guardadas y el historial reciente de Spotify. Pueden faltar escuchas anteriores o sin sincronizar. Los minutos solo se miden en Square.</string>+ <string name="telegram_community">Comunidad de Telegram</string></resources>diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xmlindex 1a935d6..06c5582 100644--- a/app/src/main/res/values-fr/strings.xml+++ b/app/src/main/res/values-fr/strings.xml@@ -505,4 +505,16 @@<string name="followed_releases_connect">Connectez Spotify dans les paramètres pour voir les sorties des artistes suivis.</string><string name="new_from_followed_artists">Nouveautés de vos artistes</string><string name="connected_device_label">Afficher l’appareil connecté</string>++ <string name="recap_title">Ton mois en musique</string>+ <string name="recap_plays">%1$d écoutes</string>+ <string name="recap_minutes">%1$d minutes dans Square</string>+ <string name="recap_details">Voir tes favoris</string>+ <string name="recap_hide">Masquer les détails</string>+ <string name="recap_previous">Mois précédent</string>+ <string name="recap_next">Mois suivant</string>+ <string name="recap_tracks">Titres les plus écoutés</string>+ <string name="recap_artists">Artistes les plus écoutés</string>+ <string name="recap_partial">Inclut les écoutes enregistrées et le récent historique Spotify. Certaines écoutes anciennes ou non synchronisées peuvent manquer. Les minutes sont mesurées uniquement dans Square.</string>+ <string name="telegram_community">Communauté Telegram</string></resources>diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xmlindex 18310c4..e06fb14 100644--- a/app/src/main/res/values-hi/strings.xml+++ b/app/src/main/res/values-hi/strings.xml@@ -520,4 +520,16 @@<string name="followed_releases_connect">फ़ॉलो किए गए कलाकारों की रिलीज़ देखने के लिए सेटिंग में Spotify कनेक्ट करें।</string><string name="new_from_followed_artists">आपके कलाकारों की नई रिलीज़</string><string name="connected_device_label">कनेक्ट किया गया डिवाइस दिखाएँ</string>++ <string name="recap_title">संगीत के साथ आपका महीना</string>+ <string name="recap_plays">%1$d बार सुना</string>+ <string name="recap_minutes">Square में %1$d मिनट</string>+ <string name="recap_details">पसंदीदा देखें</string>+ <string name="recap_hide">विवरण छिपाएँ</string>+ <string name="recap_previous">पिछला महीना</string>+ <string name="recap_next">अगला महीना</string>+ <string name="recap_tracks">सबसे अधिक सुने गए गाने</string>+ <string name="recap_artists">सबसे अधिक सुने गए कलाकार</string>+ <string name="recap_partial">सहेजी गई सुनने की गतिविधि और Spotify का हाल का इतिहास शामिल है। पुरानी या सिंक नहीं हुई गतिविधि छूट सकती है। मिनट केवल Square में मापे जाते हैं।</string>+ <string name="telegram_community">Telegram समुदाय</string></resources>diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xmlindex 1c88a96..2b40807 100644--- a/app/src/main/res/values-it/strings.xml+++ b/app/src/main/res/values-it/strings.xml@@ -540,4 +540,18 @@<string name="followed_releases_connect">Collega Spotify nelle impostazioni per vedere le uscite degli artisti che segui.</string><string name="new_from_followed_artists">Novità dai tuoi artisti</string><string name="connected_device_label">Mostra dispositivo connesso</string>++ <string name="recap_title">Il tuo mese in musica</string>+ <string name="recap_plays">%1$d ascolti</string>+ <string name="recap_minutes">%1$d minuti in Square</string>+ <string name="recap_details">Scopri i tuoi preferiti</string>+ <string name="recap_hide">Nascondi dettagli</string>+ <string name="recap_previous">Mese precedente</string>+ <string name="recap_next">Mese successivo</string>+ <string name="recap_tracks">Brani più ascoltati</string>+ <string name="recap_artists">Artisti più ascoltati</string>+ <string name="recap_partial">Include gli ascolti salvati e la cronologia recente di Spotify. Gli ascolti precedenti o non sincronizzati potrebbero mancare. I minuti sono misurati solo in Square.</string>+ <string name="smart_shuffle">Smart Shuffle</string>+ <string name="smart_shuffle_unavailable">Smart Shuffle non è disponibile per questa playlist al momento.</string>+ <string name="telegram_community">Community Telegram</string></resources>diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xmlindex 8f37523..95f0095 100644--- a/app/src/main/res/values-pt/strings.xml+++ b/app/src/main/res/values-pt/strings.xml@@ -505,4 +505,16 @@<string name="followed_releases_connect">Liga o Spotify nas definições para veres os lançamentos dos artistas que segues.</string><string name="new_from_followed_artists">Novidades dos teus artistas</string><string name="connected_device_label">Mostrar dispositivo conectado</string>++ <string name="recap_title">Seu mês em música</string>+ <string name="recap_plays">%1$d reproduções</string>+ <string name="recap_minutes">%1$d minutos no Square</string>+ <string name="recap_details">Ver seus favoritos</string>+ <string name="recap_hide">Ocultar detalhes</string>+ <string name="recap_previous">Mês anterior</string>+ <string name="recap_next">Próximo mês</string>+ <string name="recap_tracks">Músicas mais ouvidas</string>+ <string name="recap_artists">Artistas mais ouvidos</string>+ <string name="recap_partial">Inclui as reproduções salvas e o histórico recente do Spotify. Reproduções anteriores ou não sincronizadas podem estar ausentes. Os minutos são medidos apenas no Square.</string>+ <string name="telegram_community">Comunidade do Telegram</string></resources>diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xmlindex 8995a5b..0982b2b 100644--- a/app/src/main/res/values-ru/strings.xml+++ b/app/src/main/res/values-ru/strings.xml@@ -532,4 +532,16 @@<string name="followed_releases_connect">Подключите Spotify в настройках, чтобы видеть релизы исполнителей, на которых вы подписаны.</string><string name="new_from_followed_artists">Новинки ваших исполнителей</string><string name="connected_device_label">Показывать подключённое устройство</string>++ <string name="recap_title">Ваш музыкальный месяц</string>+ <string name="recap_plays">%1$d прослушиваний</string>+ <string name="recap_minutes">%1$d минут в Square</string>+ <string name="recap_details">Посмотреть любимое</string>+ <string name="recap_hide">Скрыть подробности</string>+ <string name="recap_previous">Предыдущий месяц</string>+ <string name="recap_next">Следующий месяц</string>+ <string name="recap_tracks">Любимые песни</string>+ <string name="recap_artists">Любимые исполнители</string>+ <string name="recap_partial">Учитываются сохранённые прослушивания и недавняя история Spotify. Старые или несинхронизированные прослушивания могут отсутствовать. Минуты измеряются только в Square.</string>+ <string name="telegram_community">Сообщество Telegram</string></resources>diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xmlindex ff7399e..d61cf88 100644--- a/app/src/main/res/values-tr/strings.xml+++ b/app/src/main/res/values-tr/strings.xml@@ -518,4 +518,16 @@<string name="followed_releases_connect">Takip ettiğin sanatçıların yayınlarını görmek için Ayarlar üzerinden Spotify bağlantısı kur.</string><string name="new_from_followed_artists">Sanatçılarından yeni yayınlar</string><string name="connected_device_label">Bağlı cihazı göster</string>++ <string name="recap_title">Müzikle geçen ayın</string>+ <string name="recap_plays">%1$d dinleme</string>+ <string name="recap_minutes">Square içinde %1$d dakika</string>+ <string name="recap_details">Favorilerini gör</string>+ <string name="recap_hide">Ayrıntıları gizle</string>+ <string name="recap_previous">Önceki ay</string>+ <string name="recap_next">Sonraki ay</string>+ <string name="recap_tracks">En çok dinlenen şarkılar</string>+ <string name="recap_artists">En çok dinlenen sanatçılar</string>+ <string name="recap_partial">Kaydedilen dinlemeler ve yakın tarihli Spotify geçmişi dahildir. Eski veya eşitlenmemiş dinlemeler eksik olabilir. Dakikalar yalnızca Square içinde ölçülür.</string>+ <string name="telegram_community">Telegram topluluğu</string></resources>diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xmlindex 044102c..eb83117 100644--- a/app/src/main/res/values/strings.xml+++ b/app/src/main/res/values/strings.xml@@ -567,4 +567,18 @@<string name="followed_releases_connect">Connect Spotify in Settings to see releases from artists you follow.</string><string name="new_from_followed_artists">New from Your Artists</string><string name="connected_device_label">Show connected device</string>++ <string name="recap_title">Your month in music</string>+ <string name="recap_plays">%1$d plays</string>+ <string name="recap_minutes">%1$d minutes in Square</string>+ <string name="recap_details">See your favourites</string>+ <string name="recap_hide">Hide details</string>+ <string name="recap_previous">Previous month</string>+ <string name="recap_next">Next month</string>+ <string name="recap_tracks">Most played songs</string>+ <string name="recap_artists">Most played artists</string>+ <string name="recap_partial">Includes saved listens and recent Spotify history. Earlier or unsynced listens may be missing. Minutes are measured only in Square.</string>+ <string name="smart_shuffle">Smart Shuffle</string>+ <string name="smart_shuffle_unavailable">Smart Shuffle is not available for this playlist right now.</string>+ <string name="telegram_community">Telegram community</string></resources>diff --git a/app/src/test/java/dev/lelonio/square/data/ListeningHistoryTest.kt b/app/src/test/java/dev/lelonio/square/data/ListeningHistoryTest.ktnew file mode 100644index 0000000..b7d7d22--- /dev/null+++ b/app/src/test/java/dev/lelonio/square/data/ListeningHistoryTest.kt@@ -0,0 +1,82 @@+package dev.lelonio.square.data++import org.junit.Assert.*+import org.junit.Test+import java.time.Instant+import java.time.YearMonth+import java.time.ZoneId++class ListeningHistoryTest {+ private val song = CatalogTrack("spotify:track:a", "Song", "Artist", durationMs = 60_000)+ private val time = Instant.parse("2026-10-08T10:00:00Z").toEpochMilli()++ @Test fun importsAreIdempotentAndRepeatedSongsRemainSeparate() {+ val once = ListeningHistory.merge(emptyList(), song, time)+ val twice = ListeningHistory.merge(once, song, time)+ assertEquals(once, twice)+ assertEquals(2, ListeningHistory.merge(twice, song, time + 60_000).size)+ }+ @Test fun importedListenReconcilesWithOneLocalOccurrence() {+ val local = ListeningEvent("local:1", song, time, time + 60_000, 30_000, true)+ val matched = ListeningHistory.merge(listOf(local), song, time + 40_000)+ assertEquals(1, matched.size)+ assertEquals(30_000, matched.single().listenedMs)+ assertEquals(2, ListeningHistory.merge(matched, song, time + 50_000).size)+ }+ @Test fun pauseAndLongSamplingGapsDoNotAddTime() {+ val sampler = ListeningSampler()+ sampler.sample(song, true, time, 0)+ assertEquals(1_000, sampler.sample(song, true, time + 1_000, 1_000)!!.listenedMs)+ sampler.sample(song, false, time + 2_000, 2_000)+ sampler.sample(song, false, time + 62_000, 62_000)+ sampler.sample(song, true, time + 63_000, 63_000)+ assertEquals(2_000, sampler.sample(song, true, time + 64_000, 64_000)!!.listenedMs)+ assertEquals(4_000, sampler.sample(song, true, time + 100_000, 100_000)!!.listenedMs)+ }+ @Test fun qualifiedLocalPlaySurvivesPauseWithoutCountingTwice() {+ val sampler = ListeningSampler()+ sampler.sample(song, true, time, 0)+ var event: ListeningEvent? = null+ for (second in 1..30) event = sampler.sample(song, true, time + second * 1_000, second * 1_000L)+ assertTrue(event!!.qualified)+ val id = event!!.id+ sampler.sample(song, false, time + 31_000, 31_000)+ assertEquals(id, sampler.sample(song, true, time + 60_000, 60_000)!!.id)+ }+ @Test fun monthBoundaryUsesLocalTimeAndRemoteMinutesAreUnknown() {+ val at = Instant.parse("2026-09-30T23:30:00Z").toEpochMilli()+ val events = ListeningHistory.merge(emptyList(), song, at)+ val summary = ListeningHistory.summarize(events, YearMonth.of(2026, 10), ZoneId.of("Europe/Rome"))+ assertEquals(1, summary.plays)+ assertEquals(0, summary.minutes)+ assertEquals(0, ListeningHistory.summarize(events, YearMonth.of(2026, 9), ZoneId.of("Europe/Rome")).plays)+ }+ @Test fun openingAPausedQueueDoesNotStartAListen() {+ val sampler = ListeningSampler()+ assertNull(sampler.sample(song, false, time, 0))+ assertNull(sampler.sample(song, false, time + 60_000, 60_000))+ assertNull(sampler.sample(song, true, time + 61_000, 61_000))+ assertEquals(time + 61_000, sampler.sample(song, true, time + 62_000, 62_000)!!.startedAt)+ }+ @Test fun measuredMinutesAreSplitAtTheMonthBoundary() {+ val sampler = ListeningSampler()+ val boundary = YearMonth.of(2026, 10).atDay(1).atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli()+ sampler.sample(song, true, boundary - 500, 0)+ val event = sampler.sample(song, true, boundary + 500, 1_000)!!+ assertEquals(500L, event.measuredMonths["2026-09"])+ assertEquals(500L, event.measuredMonths["2026-10"])+ }++ @Test fun importBeforeLocalFlushIsReconciledAndOlderSnapshotsCannotRemoveMinutes() {+ val imported = ListeningHistory.merge(emptyList(), song, time)+ val local = ListeningEvent("local:1", song, time, time + 60_000, 60_000, true,+ measuredMonths = mapOf("2026-10" to 60_000))+ val recorded = ListeningHistory.record(imported, local)+ assertEquals(1, recorded.size)+ assertEquals(time, recorded.single().spotifyAt)+ assertEquals(1, ListeningHistory.summarize(recorded, YearMonth.of(2026, 10), ZoneId.of("UTC")).plays)+ assertEquals(1L, ListeningHistory.summarize(recorded, YearMonth.of(2026, 10), ZoneId.of("UTC")).minutes)+ assertEquals(recorded, ListeningHistory.record(recorded, local.copy(listenedMs = 30_000)))+ }++}diff --git a/app/src/test/java/dev/lelonio/square/data/SmartShuffleQueueTest.kt b/app/src/test/java/dev/lelonio/square/data/SmartShuffleQueueTest.ktnew file mode 100644index 0000000..8d99686--- /dev/null+++ b/app/src/test/java/dev/lelonio/square/data/SmartShuffleQueueTest.kt@@ -0,0 +1,35 @@+package dev.lelonio.square.data++import dev.lelonio.square.playback.PlayQueue+import org.junit.Assert.*+import org.junit.Test++class SmartShuffleQueueTest {+ private fun track(id: String) = PlayQueue.Track("spotify:track:$id", id, "artist", durationMs = 1000, artworkUri = null)++ @Test fun disablingRestoresOriginalOrderWithoutChangingPlayingTrack() {+ val queue = PlayQueue()+ val tracks = (0..8).map { track("$it") }+ queue.replace(tracks, 4)+ queue.setShuffled(true)+ queue.enableSmartShuffle(listOf(track("new1"), track("new2")))+ assertTrue(queue.smartShuffle)+ assertEquals(tracks[4], queue.items[queue.currentIndex])+ queue.disableSmartShuffle()+ assertEquals(tracks, queue.items)+ assertEquals(tracks[4], queue.items[queue.currentIndex])+ assertFalse(queue.smartShuffle)+ }+ @Test fun disablingKeepsPlayingRecommendationBeforeItsSuccessor() {+ val queue = PlayQueue()+ queue.replace((0..5).map { track("$it") }, 0)+ queue.setShuffled(true)+ queue.enableSmartShuffle(listOf(track("new")))+ queue.currentIndex = queue.items.indexOfFirst { it.recommended }+ val current = queue.items[queue.currentIndex]+ val successor = queue.items[queue.currentIndex + 1]+ queue.disableSmartShuffle()+ assertEquals(current, queue.items[queue.currentIndex])+ assertEquals(successor, queue.items[queue.currentIndex + 1])+ }+}diff --git a/app/src/test/java/dev/lelonio/square/data/SmartShuffleTest.kt b/app/src/test/java/dev/lelonio/square/data/SmartShuffleTest.ktnew file mode 100644index 0000000..9b2c847--- /dev/null+++ b/app/src/test/java/dev/lelonio/square/data/SmartShuffleTest.kt@@ -0,0 +1,23 @@+package dev.lelonio.square.data++import org.junit.Assert.*+import org.junit.Test++class SmartShuffleTest {+ @Test fun excludesPlaylistSongsDuplicatesAndLocalFiles() {+ assertEquals(listOf("spotify:track:new"), SmartShuffle.candidates(+ listOf("spotify:track:old", "spotify:local:file", "spotify:track:new", "spotify:track:new"),+ setOf("spotify:track:old"),+ ))+ }+ @Test fun preservesExplicitPlayNextEntries() {+ assertEquals(listOf(5), SmartShuffle.insertionPoints(listOf(false, true, true, false, false), 0, 3))+ }+ @Test fun spacesRecommendationsAmongOriginalSongs() {+ assertEquals(listOf(3, 6), SmartShuffle.insertionPoints(List(7) { false }, 0, 2))+ }+ @Test fun emptyQueueCannotEnableSmartShuffle() {+ assertTrue(SmartShuffle.insertionPoints(emptyList(), 0, 4).isEmpty())+ assertTrue(SmartShuffle.insertionPoints(listOf(false), 0, 0).isEmpty())+ }+}diff --git a/fastlane/metadata/android/en-US/changelogs/47.txt b/fastlane/metadata/android/en-US/changelogs/47.txtnew file mode 100644index 0000000..d194d95--- /dev/null+++ b/fastlane/metadata/android/en-US/changelogs/47.txt@@ -0,0 +1,5 @@+Spotify Smart Shuffle adds Spotify recommendations to your playlist, marked with sparkles in the queue and player.+Monthly listening recap in Library: play counts, favourite tracks and artists, using Square listens and available Spotify recent history.+Switch Spotify and YouTube Music from the Home header.+Source-switching splash follows the app theme.+Telegram community link in Settings > About.