From 729b9b8aeff5488b5194a112693944ecc9f2f1be Mon Sep 17 00:00:00 2001 From: Yuriy Panov Date: Fri, 23 Oct 2026 12:19:27 +0600 Subject: [PATCH] Add a phone app with Android Auto support :mobile (it.panov.musyx) is a Material 3 phone app over the shared AppState: Home, My Wave, search, collection, detail pages, Now Playing with queue and lyrics, and sign-in through Yandex's page in the browser. Its playback service is a MediaLibraryService, so Android Auto and Automotive can browse My Wave and stations, Home picks and the collection, search, and play by voice. Covers reach the car through a content provider limited to Yandex hosts. Signed out, the car shows a Sign in button, and it reloads when the session changes. The session's playlist is now the current track and PlayerCore's next 50, so a car's queue screen lists them and picking one jumps there. Co-Authored-By: Claude Opus 5.5 --- README.md | 15 +- .../java/it/panov/musyx/player/ExoEngine.kt | 11 +- .../panov/musyx/player/PlaybackController.kt | 1 + .../it/panov/musyx/player/SessionPlayer.kt | 76 +++- gradle/libs.versions.toml | 1 + mobile/build.gradle.kts | 70 +++ mobile/lint.xml | 9 + mobile/proguard-rules.pro | 1 + mobile/src/main/AndroidManifest.xml | 62 +++ .../it/panov/musyx/mobile/ArtworkProvider.kt | 63 +++ .../java/it/panov/musyx/mobile/Library.kt | 361 ++++++++++++++++ .../java/it/panov/musyx/mobile/Locales.kt | 16 + .../it/panov/musyx/mobile/MainActivity.kt | 105 +++++ .../main/java/it/panov/musyx/mobile/Musyx.kt | 63 +++ .../it/panov/musyx/mobile/PlaybackService.kt | 54 +++ .../java/it/panov/musyx/mobile/ui/Format.kt | 121 ++++++ .../java/it/panov/musyx/mobile/ui/MusyxApp.kt | 194 +++++++++ .../panov/musyx/mobile/ui/components/Media.kt | 190 ++++++++ .../musyx/mobile/ui/components/Status.kt | 41 ++ .../musyx/mobile/ui/components/Tracks.kt | 177 ++++++++ .../panov/musyx/mobile/ui/screens/Common.kt | 259 +++++++++++ .../panov/musyx/mobile/ui/screens/Detail.kt | 250 +++++++++++ .../panov/musyx/mobile/ui/screens/HomeWave.kt | 313 ++++++++++++++ .../panov/musyx/mobile/ui/screens/Library.kt | 227 ++++++++++ .../panov/musyx/mobile/ui/screens/Player.kt | 407 ++++++++++++++++++ .../panov/musyx/mobile/ui/screens/Search.kt | 234 ++++++++++ .../musyx/mobile/ui/screens/SessionScreens.kt | 205 +++++++++ .../panov/musyx/mobile/ui/screens/Settings.kt | 176 ++++++++ .../panov/musyx/mobile/ui/screens/Sheets.kt | 237 ++++++++++ .../it/panov/musyx/mobile/ui/theme/Theme.kt | 308 +++++++++++++ .../src/main/res/drawable/ic_audio_lines.xml | 44 ++ mobile/src/main/res/drawable/ic_ban.xml | 20 + mobile/src/main/res/drawable/ic_check.xml | 14 + .../src/main/res/drawable/ic_chevron_left.xml | 14 + .../main/res/drawable/ic_chevron_right.xml | 14 + mobile/src/main/res/drawable/ic_clock_3.xml | 20 + mobile/src/main/res/drawable/ic_copy.xml | 20 + mobile/src/main/res/drawable/ic_disc_3.xml | 32 ++ mobile/src/main/res/drawable/ic_ellipsis.xml | 26 ++ mobile/src/main/res/drawable/ic_globe.xml | 26 ++ .../main/res/drawable/ic_grip_vertical.xml | 44 ++ mobile/src/main/res/drawable/ic_heart.xml | 14 + .../src/main/res/drawable/ic_heart_fill.xml | 15 + mobile/src/main/res/drawable/ic_house.xml | 20 + mobile/src/main/res/drawable/ic_library.xml | 32 ++ .../src/main/res/drawable/ic_list_music.xml | 38 ++ mobile/src/main/res/drawable/ic_lock.xml | 20 + mobile/src/main/res/drawable/ic_log_out.xml | 26 ++ mobile/src/main/res/drawable/ic_mic_vocal.xml | 26 ++ mobile/src/main/res/drawable/ic_pause.xml | 20 + .../src/main/res/drawable/ic_pause_fill.xml | 22 + mobile/src/main/res/drawable/ic_pencil.xml | 20 + mobile/src/main/res/drawable/ic_play.xml | 14 + mobile/src/main/res/drawable/ic_play_fill.xml | 15 + mobile/src/main/res/drawable/ic_plus.xml | 20 + mobile/src/main/res/drawable/ic_podcast.xml | 32 ++ mobile/src/main/res/drawable/ic_repeat.xml | 32 ++ mobile/src/main/res/drawable/ic_repeat_1.xml | 38 ++ mobile/src/main/res/drawable/ic_search.xml | 20 + mobile/src/main/res/drawable/ic_settings.xml | 20 + mobile/src/main/res/drawable/ic_shuffle.xml | 38 ++ mobile/src/main/res/drawable/ic_skip_back.xml | 20 + .../src/main/res/drawable/ic_skip_forward.xml | 20 + .../res/drawable/ic_sliders_horizontal.xml | 62 +++ mobile/src/main/res/drawable/ic_trash_2.xml | 38 ++ .../src/main/res/drawable/ic_trending_up.xml | 20 + mobile/src/main/res/drawable/ic_volume_2.xml | 26 ++ mobile/src/main/res/drawable/ic_volume_x.xml | 26 ++ mobile/src/main/res/drawable/ic_x.xml | 20 + mobile/src/main/res/font/onest_medium.ttf | Bin 0 -> 90544 bytes mobile/src/main/res/font/onest_regular.ttf | Bin 0 -> 90296 bytes mobile/src/main/res/font/onest_semibold.ttf | Bin 0 -> 90568 bytes .../src/main/res/font/unbounded_semibold.ttf | Bin 0 -> 348108 bytes .../src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 6278 bytes .../src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 3405 bytes .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 9512 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 15851 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 23914 bytes .../src/main/res/values-notnight/colors.xml | 4 + mobile/src/main/res/values-ru/strings.xml | 246 +++++++++++ .../src/main/res/values-ru/strings_phone.xml | 7 + mobile/src/main/res/values/colors.xml | 5 + mobile/src/main/res/values/strings.xml | 239 ++++++++++ mobile/src/main/res/values/strings_phone.xml | 9 + mobile/src/main/res/values/themes.xml | 8 + .../src/main/res/xml/automotive_app_desc.xml | 5 + mobile/src/main/res/xml/backup_rules.xml | 9 + .../main/res/xml/data_extraction_rules.xml | 19 + settings.gradle.kts | 2 +- 89 files changed, 5773 insertions(+), 15 deletions(-) create mode 100644 mobile/build.gradle.kts create mode 100644 mobile/lint.xml create mode 100644 mobile/proguard-rules.pro create mode 100644 mobile/src/main/AndroidManifest.xml create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ArtworkProvider.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/Library.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/Locales.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/MainActivity.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/Musyx.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/PlaybackService.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/Format.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/MusyxApp.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/components/Media.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/components/Status.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/components/Tracks.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Common.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Detail.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/HomeWave.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Library.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Player.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Search.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/SessionScreens.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Settings.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Sheets.kt create mode 100644 mobile/src/main/java/it/panov/musyx/mobile/ui/theme/Theme.kt create mode 100644 mobile/src/main/res/drawable/ic_audio_lines.xml create mode 100644 mobile/src/main/res/drawable/ic_ban.xml create mode 100644 mobile/src/main/res/drawable/ic_check.xml create mode 100644 mobile/src/main/res/drawable/ic_chevron_left.xml create mode 100644 mobile/src/main/res/drawable/ic_chevron_right.xml create mode 100644 mobile/src/main/res/drawable/ic_clock_3.xml create mode 100644 mobile/src/main/res/drawable/ic_copy.xml create mode 100644 mobile/src/main/res/drawable/ic_disc_3.xml create mode 100644 mobile/src/main/res/drawable/ic_ellipsis.xml create mode 100644 mobile/src/main/res/drawable/ic_globe.xml create mode 100644 mobile/src/main/res/drawable/ic_grip_vertical.xml create mode 100644 mobile/src/main/res/drawable/ic_heart.xml create mode 100644 mobile/src/main/res/drawable/ic_heart_fill.xml create mode 100644 mobile/src/main/res/drawable/ic_house.xml create mode 100644 mobile/src/main/res/drawable/ic_library.xml create mode 100644 mobile/src/main/res/drawable/ic_list_music.xml create mode 100644 mobile/src/main/res/drawable/ic_lock.xml create mode 100644 mobile/src/main/res/drawable/ic_log_out.xml create mode 100644 mobile/src/main/res/drawable/ic_mic_vocal.xml create mode 100644 mobile/src/main/res/drawable/ic_pause.xml create mode 100644 mobile/src/main/res/drawable/ic_pause_fill.xml create mode 100644 mobile/src/main/res/drawable/ic_pencil.xml create mode 100644 mobile/src/main/res/drawable/ic_play.xml create mode 100644 mobile/src/main/res/drawable/ic_play_fill.xml create mode 100644 mobile/src/main/res/drawable/ic_plus.xml create mode 100644 mobile/src/main/res/drawable/ic_podcast.xml create mode 100644 mobile/src/main/res/drawable/ic_repeat.xml create mode 100644 mobile/src/main/res/drawable/ic_repeat_1.xml create mode 100644 mobile/src/main/res/drawable/ic_search.xml create mode 100644 mobile/src/main/res/drawable/ic_settings.xml create mode 100644 mobile/src/main/res/drawable/ic_shuffle.xml create mode 100644 mobile/src/main/res/drawable/ic_skip_back.xml create mode 100644 mobile/src/main/res/drawable/ic_skip_forward.xml create mode 100644 mobile/src/main/res/drawable/ic_sliders_horizontal.xml create mode 100644 mobile/src/main/res/drawable/ic_trash_2.xml create mode 100644 mobile/src/main/res/drawable/ic_trending_up.xml create mode 100644 mobile/src/main/res/drawable/ic_volume_2.xml create mode 100644 mobile/src/main/res/drawable/ic_volume_x.xml create mode 100644 mobile/src/main/res/drawable/ic_x.xml create mode 100644 mobile/src/main/res/font/onest_medium.ttf create mode 100644 mobile/src/main/res/font/onest_regular.ttf create mode 100644 mobile/src/main/res/font/onest_semibold.ttf create mode 100644 mobile/src/main/res/font/unbounded_semibold.ttf create mode 100644 mobile/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 mobile/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 mobile/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 mobile/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 mobile/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 mobile/src/main/res/values-notnight/colors.xml create mode 100644 mobile/src/main/res/values-ru/strings.xml create mode 100644 mobile/src/main/res/values-ru/strings_phone.xml create mode 100644 mobile/src/main/res/values/colors.xml create mode 100644 mobile/src/main/res/values/strings.xml create mode 100644 mobile/src/main/res/values/strings_phone.xml create mode 100644 mobile/src/main/res/values/themes.xml create mode 100644 mobile/src/main/res/xml/automotive_app_desc.xml create mode 100644 mobile/src/main/res/xml/backup_rules.xml create mode 100644 mobile/src/main/res/xml/data_extraction_rules.xml diff --git a/README.md b/README.md index 2f81238..6e00ef4 100644 --- a/README.md +++ b/README.md @@ -51,7 +51,12 @@ runs the JVM tests (the queue and player rules, API parsing and request signing, decryption and theme parity, mostly ported from the desktop tests), and `./gradlew lint` runs Android Lint, with a report in each module's `build/reports/lint-results-debug.html`. -To run it, start an Android TV or Google TV emulator (Device Manager in Android Studio, TV +The phone app builds with `./gradlew :mobile:assembleDebug` and installs with +`./gradlew :mobile:installDebug`. To try it in Android Auto, run the Desktop Head Unit (SDK +Manager, SDK Tools, Android Auto Desktop Head Unit) against a phone with Android Auto, with +Auto's developer settings on and "Unknown sources" allowed, since the app isn't from Play. + +To run the TV app, start an Android TV or Google TV emulator (Device Manager in Android Studio, TV category) or connect a TV with ADB debugging on, then: ```bash @@ -94,6 +99,14 @@ changing the sources: - `player/PlaybackService.kt`: the media session. - `ui/`: the shell (drawer, mini player, dialogs, toasts), `screens/` and `components/`. The theme is `ui/theme/Theme.kt`, a 1:1 port of `DESIGN.md`. +- `mobile/`: the phone app (`it.panov.musyx`), under `mobile/src/main/java/it/panov/musyx/mobile`: + - `PlaybackService.kt`: a `MediaLibraryService`, so the notification, lock screen, + Bluetooth and Android Auto all reach the player. + - `Library.kt`: the browse tree Android Auto shows (My Wave and stations, Home picks, the + collection) and its search and voice requests. + - `ArtworkProvider.kt`: serves covers to Auto as `content://` URIs, Yandex hosts only. + - `ui/`: Material 3 screens over the shared `AppState`; `res/values/strings.xml` is + copied from the TV app by name, `strings_phone.xml` has the phone's own. - `gradle/libs.versions.toml`: dependency versions. - `DESIGN.md`: design tokens (colour, type, space, components), shared with the desktop app. - `design/mockup.html`: the approved desktop mockup. diff --git a/core/src/main/java/it/panov/musyx/player/ExoEngine.kt b/core/src/main/java/it/panov/musyx/player/ExoEngine.kt index d8adb44..3179180 100644 --- a/core/src/main/java/it/panov/musyx/player/ExoEngine.kt +++ b/core/src/main/java/it/panov/musyx/player/ExoEngine.kt @@ -10,7 +10,6 @@ import android.os.Looper import androidx.media3.common.AudioAttributes import androidx.media3.common.C import androidx.media3.common.MediaItem -import androidx.media3.common.MediaMetadata import androidx.media3.common.PlaybackException import androidx.media3.common.Player import androidx.annotation.OptIn @@ -91,15 +90,7 @@ class ExoEngine(context: Context, private val token: () -> String?, private val keys.clear() val key = stream.key?.let { hexKey(it) } if (key != null) stream.urls.forEach { keys[it] = key } - val metadata = MediaMetadata.Builder() - .setTitle(track.fullTitle) - .setArtist(track.artistLine) - .setAlbumTitle(track.album?.title) - .setArtworkUri(track.coverUrl(400)?.let(Uri::parse)) - .setIsPlayable(true) - .setIsBrowsable(false) - .build() - item = MediaItem.Builder().setMediaId(track.id).setMediaMetadata(metadata) + item = MediaItem.Builder().setMediaId(track.id).setMediaMetadata(track.mediaMetadata()) start(play) } diff --git a/core/src/main/java/it/panov/musyx/player/PlaybackController.kt b/core/src/main/java/it/panov/musyx/player/PlaybackController.kt index 6c0c872..05862fe 100644 --- a/core/src/main/java/it/panov/musyx/player/PlaybackController.kt +++ b/core/src/main/java/it/panov/musyx/player/PlaybackController.kt @@ -122,6 +122,7 @@ class PlaybackController( waveStation = core.waveStation, ) positionMs = core.positionMs + sessionPlayer.queueChanged() } // ---- Engine events ---- diff --git a/core/src/main/java/it/panov/musyx/player/SessionPlayer.kt b/core/src/main/java/it/panov/musyx/player/SessionPlayer.kt index 656db23..24ba551 100644 --- a/core/src/main/java/it/panov/musyx/player/SessionPlayer.kt +++ b/core/src/main/java/it/panov/musyx/player/SessionPlayer.kt @@ -1,22 +1,49 @@ // The player that each app's media session wraps. package it.panov.musyx.player +import android.net.Uri import androidx.annotation.OptIn +import androidx.media3.common.C import androidx.media3.common.ForwardingSimpleBasePlayer +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi import com.google.common.util.concurrent.Futures import com.google.common.util.concurrent.ListenableFuture +import it.panov.musyx.api.Track + +/** Upcoming tracks shown to controllers; a long liked list would make every update heavy. */ +private const val QUEUE_SHOWN = 50 + +/** How a track describes itself to the media session, for what's playing and what's next. */ +internal fun Track.mediaMetadata(): MediaMetadata = MediaMetadata.Builder() + .setTitle(fullTitle) + .setArtist(artistLine) + .setAlbumTitle(album?.title) + .setArtworkUri(coverUrl(400)?.let(Uri::parse)) + .setIsPlayable(true) + .setIsBrowsable(false) + .build() /** * The ExoPlayer as the media session sees it. ExoPlayer only ever holds the current * track, so next and previous are added here and routed to the queue, as are play, - * pause and seeks, so PlayerCore stays the one source of truth. + * pause and seeks, so PlayerCore stays the one source of truth. The playlist controllers + * see is the current track followed by PlayerCore's upcoming ones, so a car's queue + * screen lists them and picking one jumps there. */ @OptIn(UnstableApi::class) -class SessionPlayer(player: Player, private val controller: PlaybackController) : +class SessionPlayer(private val player: Player, private val controller: PlaybackController) : ForwardingSimpleBasePlayer(player) { + /** The upcoming tracks behind the playlist last shown, and their items, so a pick finds its track. */ + private var shown: List> = emptyList() + private var shownItems: List = emptyList() + + /** PlayerCore's queue changed: controllers re-read the playlist. */ + fun queueChanged() = invalidateState() + override fun getState(): State { val state = super.getState() val commands = state.availableCommands.buildUpon() @@ -26,9 +53,40 @@ class SessionPlayer(player: Player, private val controller: PlaybackController) Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM, Player.COMMAND_SEEK_TO_PREVIOUS, Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM, + Player.COMMAND_SEEK_TO_MEDIA_ITEM, ) .build() - return state.buildUpon().setAvailableCommands(commands).build() + val builder = state.buildUpon().setAvailableCommands(commands) + val current = player.currentMediaItem + val upcoming = controller.state.upcoming.take(QUEUE_SHOWN) + if (current != null && upcoming.isNotEmpty()) { + builder.setPlaylist(listOf(nowPlaying(current)) + queued(upcoming)).setCurrentMediaItemIndex(0) + } else { + shown = emptyList() + } + return builder.build() + } + + /** The track ExoPlayer holds, as ExoPlayer describes it. */ + private fun nowPlaying(item: MediaItem): MediaItemData = MediaItemData.Builder("now:${item.mediaId}") + .setMediaItem(item) + .setTracks(player.currentTracks) + .setIsSeekable(player.isCurrentMediaItemSeekable) + .setDurationUs(player.duration.takeIf { it != C.TIME_UNSET }?.times(1000) ?: C.TIME_UNSET) + .build() + + private fun queued(upcoming: List>): List { + if (upcoming != shown) { + shown = upcoming + shownItems = upcoming.map { (pos, track) -> + val item = MediaItem.Builder().setMediaId(track.id).setMediaMetadata(track.mediaMetadata()).build() + MediaItemData.Builder("next:$pos:${track.id}") + .setMediaItem(item) + .setDurationUs(track.durationMs * 1000) + .build() + } + } + return shownItems } override fun handleSetPlayWhenReady(playWhenReady: Boolean): ListenableFuture<*> { @@ -45,10 +103,22 @@ class SessionPlayer(player: Player, private val controller: PlaybackController) /** The queue prepares tracks itself; play after a stop goes through [handleSetPlayWhenReady]. */ override fun handlePrepare(): ListenableFuture<*> = Futures.immediateVoidFuture() + /** + * Items a controller (Android Auto, say) asks to play never reach ExoPlayer: the library + * session has already started them through PlayerCore by the time they arrive here. + */ + override fun handleSetMediaItems(mediaItems: List, startIndex: Int, startPositionMs: Long): ListenableFuture<*> = + Futures.immediateVoidFuture() + + override fun handleAddMediaItems(index: Int, mediaItems: List): ListenableFuture<*> = Futures.immediateVoidFuture() + override fun handleSeek(mediaItemIndex: Int, positionMs: Long, seekCommand: Int): ListenableFuture<*> { when (seekCommand) { Player.COMMAND_SEEK_TO_NEXT, Player.COMMAND_SEEK_TO_NEXT_MEDIA_ITEM -> controller.next() Player.COMMAND_SEEK_TO_PREVIOUS, Player.COMMAND_SEEK_TO_PREVIOUS_MEDIA_ITEM -> controller.previous() + // A pick from the queue: index 0 is the current track, the rest are `shown` in order. + Player.COMMAND_SEEK_TO_MEDIA_ITEM -> shown.getOrNull(mediaItemIndex - 1)?.let { (pos, _) -> controller.jumpTo(pos) } + ?: controller.seek(positionMs.coerceAtLeast(0)) else -> controller.seek(positionMs.coerceAtLeast(0)) } return Futures.immediateVoidFuture() diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index ed68c98..d639874 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -24,6 +24,7 @@ compose-ui-graphics = { module = "androidx.compose.ui:ui-graphics" } compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" } compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" } compose-foundation = { module = "androidx.compose.foundation:foundation" } +compose-material3 = { module = "androidx.compose.material3:material3" } compose-runtime = { module = "androidx.compose.runtime:runtime" } tv-material = { module = "androidx.tv:tv-material", version.ref = "tv-material" } media3-exoplayer = { module = "androidx.media3:media3-exoplayer", version.ref = "media3" } diff --git a/mobile/build.gradle.kts b/mobile/build.gradle.kts new file mode 100644 index 0000000..8eaa9b1 --- /dev/null +++ b/mobile/build.gradle.kts @@ -0,0 +1,70 @@ +import java.util.Properties + +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.compose) +} + +android { + namespace = "it.panov.musyx.mobile" + compileSdk = 37 + + defaultConfig { + applicationId = "it.panov.musyx" + minSdk = 23 + targetSdk = 37 + versionCode = 1 + versionName = "0.1.0" + } + + // The same keystore.properties as the TV app; without one, release builds use the debug key. + val keystore = rootProject.file("keystore.properties").takeIf { it.exists() }?.let { file -> + Properties().apply { file.inputStream().use(::load) } + } + signingConfigs { + if (keystore != null) { + create("release") { + storeFile = rootProject.file(keystore.getProperty("storeFile")) + storePassword = keystore.getProperty("storePassword") + keyAlias = keystore.getProperty("keyAlias") + keyPassword = keystore.getProperty("keyPassword") + } + } + } + + buildTypes { + release { + signingConfig = signingConfigs.findByName("release") ?: signingConfigs.getByName("debug") + isMinifyEnabled = true + isShrinkResources = true + proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro") + } + } + + buildFeatures { + compose = true + buildConfig = true + } +} + +dependencies { + implementation(project(":core")) + + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.activity.compose) + implementation(libs.androidx.lifecycle.runtime.compose) + + implementation(platform(libs.compose.bom)) + implementation(libs.compose.ui) + implementation(libs.compose.ui.graphics) + implementation(libs.compose.foundation) + implementation(libs.compose.material3) + implementation(libs.compose.ui.tooling.preview) + debugImplementation(libs.compose.ui.tooling) + + implementation(libs.media3.exoplayer) + implementation(libs.media3.session) + implementation(libs.okhttp) + implementation(libs.coil.compose) + implementation(libs.coil.network.okhttp) +} diff --git a/mobile/lint.xml b/mobile/lint.xml new file mode 100644 index 0000000..ddf63d3 --- /dev/null +++ b/mobile/lint.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/mobile/proguard-rules.pro b/mobile/proguard-rules.pro new file mode 100644 index 0000000..0525298 --- /dev/null +++ b/mobile/proguard-rules.pro @@ -0,0 +1 @@ +# Project-specific R8 rules. The libraries in use ship their own consumer rules. diff --git a/mobile/src/main/AndroidManifest.xml b/mobile/src/main/AndroidManifest.xml new file mode 100644 index 0000000..04605f1 --- /dev/null +++ b/mobile/src/main/AndroidManifest.xml @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ArtworkProvider.kt b/mobile/src/main/java/it/panov/musyx/mobile/ArtworkProvider.kt new file mode 100644 index 0000000..1173d5b --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ArtworkProvider.kt @@ -0,0 +1,63 @@ +// Covers for Android Auto. Auto loads browse artwork only from content:// URIs, so each https +// cover is fetched once into the cache and served from there. +package it.panov.musyx.mobile + +import android.content.ContentProvider +import android.content.ContentValues +import android.content.Context +import android.database.Cursor +import android.net.Uri +import android.os.ParcelFileDescriptor +import okhttp3.OkHttpClient +import okhttp3.Request +import java.io.File +import java.io.FileNotFoundException +import java.security.MessageDigest + +class ArtworkProvider : ContentProvider() { + private val http by lazy { OkHttpClient() } + + override fun onCreate(): Boolean = true + + override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor { + val url = uri.lastPathSegment?.let(Uri::parse) ?: throw FileNotFoundException("$uri") + // Exported for the car, so it fetches only Yandex covers, never an arbitrary URL. + val host = url.host.orEmpty() + if (url.scheme != "https" || !(host == "yandex.net" || host.endsWith(".yandex.net"))) throw FileNotFoundException("$uri") + val file = File(requireNotNull(context).cacheDir, "artwork/${sha1(url.toString())}") + if (!file.exists()) fetch(url.toString(), file) + return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY) + } + + /** Downloads to a temporary file first, so a broken download never passes for a cover. */ + private fun fetch(url: String, file: File) { + file.parentFile?.mkdirs() + val part = File(file.path + ".part") + try { + http.newCall(Request.Builder().url(url).build()).execute().use { response -> + if (!response.isSuccessful) throw FileNotFoundException("$url: http ${response.code}") + part.outputStream().use { response.body.byteStream().copyTo(it) } + } + if (!part.renameTo(file)) throw FileNotFoundException(url) + } catch (e: java.io.IOException) { + part.delete() + throw FileNotFoundException("$url: $e") + } + } + + override fun getType(uri: Uri): String = "image/jpeg" + + override fun query(uri: Uri, projection: Array?, selection: String?, selectionArgs: Array?, sortOrder: String?): Cursor? = null + override fun insert(uri: Uri, values: ContentValues?): Uri? = null + override fun delete(uri: Uri, selection: String?, selectionArgs: Array?): Int = 0 + override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array?): Int = 0 + + companion object { + /** The content URI the car loads `url` from. */ + fun uri(context: Context, url: String): Uri = + Uri.Builder().scheme("content").authority("${context.packageName}.artwork").appendPath(url).build() + + private fun sha1(s: String): String = + MessageDigest.getInstance("SHA-1").digest(s.toByteArray()).joinToString("") { "%02x".format(it) } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/Library.kt b/mobile/src/main/java/it/panov/musyx/mobile/Library.kt new file mode 100644 index 0000000..f8d62fc --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/Library.kt @@ -0,0 +1,361 @@ +// The media library Android Auto browses: My Wave and stations, picks from Home, and the +// collection. Playing an item starts it through PlayerCore, like a tap in the app would. +package it.panov.musyx.mobile + +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.net.Uri +import android.os.Bundle +import android.util.Log +import androidx.annotation.OptIn +import androidx.compose.runtime.snapshotFlow +import androidx.compose.runtime.snapshots.Snapshot +import androidx.media3.common.C +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata +import androidx.media3.common.util.UnstableApi +import androidx.media3.session.LibraryResult +import androidx.media3.session.MediaConstants +import androidx.media3.session.MediaLibraryService.LibraryParams +import androidx.media3.session.MediaLibraryService.MediaLibrarySession +import androidx.media3.session.MediaSession +import androidx.media3.session.MediaSession.MediaItemsWithStartPosition +import androidx.media3.session.SessionError +import com.google.common.collect.ImmutableList +import com.google.common.util.concurrent.Futures +import com.google.common.util.concurrent.ListenableFuture +import com.google.common.util.concurrent.SettableFuture +import it.panov.musyx.api.AlbumSummary +import it.panov.musyx.api.MY_WAVE +import it.panov.musyx.api.PlaylistId +import it.panov.musyx.api.PlaylistSummary +import it.panov.musyx.api.SearchKind +import it.panov.musyx.api.Station +import it.panov.musyx.api.Track +import it.panov.musyx.api.YmClient +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Liked +import it.panov.musyx.state.Session +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.drop +import kotlinx.coroutines.launch +import kotlinx.coroutines.withTimeoutOrNull + +/** Covers in the car: big enough for the grid, small enough to load quickly. */ +private const val ART_SIZE = 300 +/** Recently played tracks listed in the car. */ +private const val RECENT_SHOWN = 30 +/** How long to wait for the stored sign-in when Auto connects before the app has run. */ +private const val RESTORE_MS = 20_000L + +// Media ids. Folders are plain names or `kind:id`; a playable track is `t||`, +// so playing it can queue the rest of its folder. +private const val ROOT = "root" +private const val WAVE = "wave" +private const val HOME = "home" +private const val COLLECTION = "collection" +private const val LIKED = "liked" +private const val RECENT = "recent" +private const val CHART = "chart" +private const val PLAYLISTS = "playlists" +private const val ALBUMS = "albums" +private const val STATION = "station|" +private const val TRACK = "t|" +private const val SEARCH = "search:" + +@OptIn(UnstableApi::class) +class Library(private val context: Context, private val state: AppState, private val scope: CoroutineScope) : + MediaLibrarySession.Callback { + + /** Track lists by folder, as last shown, so playing a row queues what was on screen. */ + private val shown = HashMap>() + /** Search results by query, between onSearch and onGetSearchResult. */ + private val searches = HashMap>() + + /** + * Has the car reload whenever someone signs in or out, so it never keeps showing "Sign in" + * (or someone else's music). Returns what stops watching. + */ + fun watchSession(session: MediaLibrarySession): () -> Unit { + // snapshotFlow hears about changes through Compose's apply notifications, which only the + // app's UI sends; with just the car connected, nothing would. Send them here as well. + var queued = false + val writes = Snapshot.registerGlobalWriteObserver { + if (!queued) { + queued = true + scope.launch(Dispatchers.Main) { + queued = false + Snapshot.sendApplyNotifications() + } + } + } + val job = scope.launch { + snapshotFlow { state.session is Session.SignedIn } + .distinctUntilChanged() + .drop(1) + .collect { + shown.clear() + searches.clear() + session.notifyChildrenChanged(ROOT, Int.MAX_VALUE, null) + } + } + return { + job.cancel() + writes.dispose() + } + } + + override fun onGetLibraryRoot( + session: MediaLibrarySession, + browser: MediaSession.ControllerInfo, + params: LibraryParams?, + ): ListenableFuture> { + // Folders of albums and playlists show as grids, tracks as lists. + val extras = Bundle().apply { + putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_GRID_ITEM) + putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + } + val root = folder(ROOT, context.getString(R.string.app_name)) + return Futures.immediateFuture(LibraryResult.ofItem(root, LibraryParams.Builder().setExtras(extras).build())) + } + + override fun onGetChildren( + session: MediaLibrarySession, + browser: MediaSession.ControllerInfo, + parentId: String, + page: Int, + pageSize: Int, + params: LibraryParams?, + ): ListenableFuture>> = future { + val client = client() ?: return@future signedOut() + val items = children(client, parentId) ?: return@future LibraryResult.ofError(SessionError.ERROR_BAD_VALUE) + LibraryResult.ofItemList(items.page(page, pageSize), params) + } + + override fun onGetItem( + session: MediaLibrarySession, + browser: MediaSession.ControllerInfo, + mediaId: String, + ): ListenableFuture> { + val item = if (mediaId == ROOT) folder(ROOT, context.getString(R.string.app_name)) else null + return Futures.immediateFuture(item?.let { LibraryResult.ofItem(it, null) } ?: LibraryResult.ofError(SessionError.ERROR_BAD_VALUE)) + } + + override fun onSearch( + session: MediaLibrarySession, + browser: MediaSession.ControllerInfo, + query: String, + params: LibraryParams?, + ): ListenableFuture> = future { + val client = client() ?: return@future signedOut() + val tracks = client.search(query, SearchKind.Tracks, 0).tracks + val folder = SEARCH + query + shown[folder] = tracks + searches[query] = tracks.mapIndexed { i, t -> track(folder, i, t) } + session.notifySearchResultChanged(browser, query, tracks.size, params) + LibraryResult.ofVoid() + } + + override fun onGetSearchResult( + session: MediaLibrarySession, + browser: MediaSession.ControllerInfo, + query: String, + page: Int, + pageSize: Int, + params: LibraryParams?, + ): ListenableFuture>> = + Futures.immediateFuture(LibraryResult.ofItemList(searches[query].orEmpty().page(page, pageSize), params)) + + /** + * Plays what the car picked: a station, a track with the rest of its folder, or, for a + * spoken request, the best tracks for it (My Wave when nothing was named). + */ + override fun onSetMediaItems( + mediaSession: MediaSession, + controller: MediaSession.ControllerInfo, + mediaItems: List, + startIndex: Int, + startPositionMs: Long, + ): ListenableFuture = future { + val item = mediaItems.getOrNull(startIndex.coerceAtLeast(0)) ?: mediaItems.first() + val id = item.mediaId + val query = item.requestMetadata.searchQuery + when { + id.startsWith(STATION) -> state.playWave(id.removePrefix(STATION)) + id.startsWith(TRACK) -> { + val (folder, index) = id.removePrefix(TRACK).let { it.substringBeforeLast('|') to it.substringAfterLast('|').toIntOrNull() } + val tracks = shown[folder] ?: client()?.let { tracks(it, folder) } + if (tracks != null && index != null && index in tracks.indices) state.playTracks(tracks, index) + } + id.isEmpty() -> playFromSearch(state, query) + } + MediaItemsWithStartPosition(mediaItems, startIndex, C.TIME_UNSET) + } + + // ---- The tree ---- + + private suspend fun children(client: YmClient, parent: String): List? = when (parent) { + ROOT -> listOf( + folder(WAVE, context.getString(R.string.nav_wave), browsable = MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM), + folder(HOME, context.getString(R.string.nav_home)), + folder(COLLECTION, context.getString(R.string.nav_collection), browsable = MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM), + ) + WAVE -> { + val stations = runCatching { client.stations() }.getOrDefault(emptyList()).filter { it.id != MY_WAVE } + listOf(station(MY_WAVE, context.getString(R.string.nav_wave), null)) + stations.map(::station) + } + HOME -> { + val home = client.home() + listOf( + folder(RECENT, context.getString(R.string.section_recent)), + folder(CHART, context.getString(R.string.section_chart)), + ) + home.personal.map { playlist(it.playlist) } + } + COLLECTION -> listOf( + folder(LIKED, context.getString(R.string.tab_liked_tracks)), + folder(PLAYLISTS, context.getString(R.string.tab_playlists)), + folder(ALBUMS, context.getString(R.string.tab_albums)), + ) + PLAYLISTS -> client.libraryPlaylists().let { it.own + it.liked }.map(::playlist) + ALBUMS -> client.likedAlbums().filter { !it.isPodcast }.map(::album) + else -> tracks(client, parent)?.let { tracks -> + shown[parent] = tracks + tracks.mapIndexed { i, t -> track(parent, i, t) } + } + } + + /** The tracks of a track folder; null for anything else. */ + private suspend fun tracks(client: YmClient, folder: String): List? = when { + folder == LIKED -> (state.liked as? Liked.Loaded)?.tracks ?: client.likedTracks() + folder == RECENT -> client.recentlyPlayed(RECENT_SHOWN) + folder == CHART -> client.chart().map { it.track } + folder.startsWith("album:") -> folder.removePrefix("album:").toLongOrNull()?.let { client.album(it).tracks } + folder.startsWith("playlist:") -> folder.removePrefix("playlist:").split(':').mapNotNull { it.toLongOrNull() } + .takeIf { it.size == 2 } + ?.let { (owner, kind) -> client.playlist(PlaylistId(owner, kind)).tracks } + folder.startsWith(SEARCH) -> client.search(folder.removePrefix(SEARCH), SearchKind.Tracks, 0).tracks + else -> null + } + + private fun folder(id: String, title: String, art: String? = null, subtitle: String? = null, browsable: Int? = null): MediaItem { + val extras = browsable?.let { Bundle().apply { putInt(MediaConstants.EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, it) } } + return MediaItem.Builder() + .setMediaId(id) + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(title) + .setSubtitle(subtitle) + .setArtworkUri(artwork(art)) + .setIsBrowsable(true) + .setIsPlayable(false) + .setMediaType(MediaMetadata.MEDIA_TYPE_FOLDER_MIXED) + .setExtras(extras) + .build(), + ) + .build() + } + + private fun playlist(p: PlaylistSummary) = + folder("playlist:${p.id.owner}:${p.id.kind}", p.title, p.coverUrl(ART_SIZE), p.ownerName.takeIf { it.isNotEmpty() }, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + + private fun album(a: AlbumSummary) = + folder("album:${a.id}", a.fullTitle, a.coverUrl(ART_SIZE), a.artistLine, MediaConstants.EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM) + + private fun station(s: Station) = station(s.id, s.name, s.iconUrl(ART_SIZE)) + + private fun station(id: String, name: String, art: String?) = MediaItem.Builder() + .setMediaId(STATION + id) + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(name) + .setArtworkUri(artwork(art)) + .setIsBrowsable(false) + .setIsPlayable(true) + .setMediaType(MediaMetadata.MEDIA_TYPE_RADIO_STATION) + .build(), + ) + .build() + + private fun track(folder: String, index: Int, t: Track) = MediaItem.Builder() + .setMediaId("$TRACK$folder|$index") + .setMediaMetadata( + MediaMetadata.Builder() + .setTitle(t.fullTitle) + .setArtist(t.artistLine) + .setAlbumTitle(t.album?.title) + .setArtworkUri(artwork(t.coverUrl(ART_SIZE))) + .setDurationMs(t.durationMs) + .setIsBrowsable(false) + .setIsPlayable(t.available) + .setMediaType(MediaMetadata.MEDIA_TYPE_MUSIC) + .build(), + ) + .build() + + private fun artwork(url: String?): Uri? = url?.let { ArtworkProvider.uri(context, it) } + + // ---- Plumbing ---- + + private suspend fun client(): YmClient? = awaitClient(state) + + /** Signed out: the car shows why, with a button that opens the app's sign-in. */ + private fun signedOut(): LibraryResult { + val open = PendingIntent.getActivity( + context, + 0, + Intent(context, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK), + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, + ) + val extras = Bundle().apply { + putString(MediaConstants.EXTRAS_KEY_ERROR_RESOLUTION_ACTION_LABEL_COMPAT, context.getString(R.string.action_sign_in)) + putParcelable(MediaConstants.EXTRAS_KEY_ERROR_RESOLUTION_ACTION_INTENT_COMPAT, open) + } + val error = SessionError(SessionError.ERROR_SESSION_AUTHENTICATION_EXPIRED, context.getString(R.string.auto_sign_in), extras) + return LibraryResult.ofError(error) + } + + /** Runs `block` on the app's main-thread scope; a failure fails the future, which the car shows as an error. */ + private fun future(block: suspend () -> T): ListenableFuture { + val result = SettableFuture.create() + scope.launch { + try { + result.set(block()) + } catch (e: CancellationException) { + result.cancel(false) + throw e + } catch (e: Throwable) { + Log.w(TAG, "library: $e") + result.setException(e) + } + } + return result + } + + private fun List.page(page: Int, size: Int): List = + if (size <= 0 || size == Int.MAX_VALUE) this else drop(page * size).take(size) + + private companion object { + const val TAG = "Musyx" + } +} + +/** The signed-in client, once the stored sign-in has been checked; null when signed out. */ +internal suspend fun awaitClient(state: AppState): YmClient? { + // Polled: without the app's UI running, nothing delivers Compose state changes to observers. + withTimeoutOrNull(RESTORE_MS) { + while (state.session is Session.Restoring || state.session is Session.Connecting) delay(100) + } + return state.client +} + +/** A spoken request ("play … on Musyx"): the best tracks for `query`, or My Wave when nothing was named. */ +internal suspend fun playFromSearch(state: AppState, query: String?) { + if (query.isNullOrBlank()) return state.playWave(MY_WAVE) + val tracks = awaitClient(state)?.search(query, SearchKind.Tracks, 0)?.tracks.orEmpty() + if (tracks.isNotEmpty()) state.playTracks(tracks, 0) +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/Locales.kt b/mobile/src/main/java/it/panov/musyx/mobile/Locales.kt new file mode 100644 index 0000000..72bab21 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/Locales.kt @@ -0,0 +1,16 @@ +package it.panov.musyx.mobile + +import android.content.Context +import android.content.res.Configuration +import it.panov.musyx.data.SettingsStore +import java.util.Locale + +/** This context in the interface language the settings pick; as it is when they follow the system. */ +fun Context.inAppLanguage(): Context { + val tag = SettingsStore(this).language().tag ?: return this + val config = Configuration(resources.configuration) + val locale = Locale.forLanguageTag(tag) + Locale.setDefault(locale) + config.setLocale(locale) + return createConfigurationContext(config) +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/MainActivity.kt b/mobile/src/main/java/it/panov/musyx/mobile/MainActivity.kt new file mode 100644 index 0000000..45efe85 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/MainActivity.kt @@ -0,0 +1,105 @@ +package it.panov.musyx.mobile + +import android.Manifest +import android.app.SearchManager +import android.content.ComponentName +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.os.Build +import android.os.Bundle +import android.provider.MediaStore +import androidx.activity.ComponentActivity +import androidx.activity.SystemBarStyle +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.snapshotFlow +import androidx.compose.ui.graphics.toArgb +import androidx.core.content.ContextCompat +import androidx.media3.session.MediaController +import androidx.media3.session.SessionToken +import com.google.common.util.concurrent.ListenableFuture +import it.panov.musyx.data.Appearance +import it.panov.musyx.mobile.ui.MusyxApp +import it.panov.musyx.mobile.ui.theme.DarkColors +import it.panov.musyx.mobile.ui.theme.LightColors +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.theme.isMusyxDark +import it.panov.musyx.state.Session +import kotlinx.coroutines.flow.drop +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.launch + +class MainActivity : ComponentActivity() { + /** Binds the playback service so it can go foreground when playback starts. */ + private var controller: ListenableFuture? = null + + private val askNotifications = registerForActivityResult(ActivityResultContracts.RequestPermission()) {} + + /** The interface language follows the setting, not only the system. */ + override fun attachBaseContext(newBase: Context) = super.attachBaseContext(newBase.inAppLanguage()) + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + val state = Musyx.graph(this).state + state.start() + if (savedInstanceState == null) handleVoiceSearch(intent) + setContent { + val dark = when (state.settings.appearance) { + Appearance.System -> isMusyxDark() + Appearance.Light -> false + Appearance.Dark -> true + } + LaunchedEffect(dark) { + val bg = (if (dark) DarkColors else LightColors).bg.toArgb() + val bars = if (dark) SystemBarStyle.dark(bg) else SystemBarStyle.light(bg, bg) + enableEdgeToEdge(statusBarStyle = bars, navigationBarStyle = bars) + } + // A new interface language means new resources: rebuild the activity in it. + LaunchedEffect(Unit) { + snapshotFlow { state.settings.language }.drop(1).collect { recreate() } + } + // The playback notification needs permission from Android 13; ask once signed in. + LaunchedEffect(Unit) { + snapshotFlow { state.session }.first { it is Session.SignedIn } + askForNotifications() + } + MusyxTheme(dark = dark, typeScale = state.settings.fontSize.scale) { + MusyxApp(state, onExit = { moveTaskToBack(true) }) + } + } + } + + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + handleVoiceSearch(intent) + } + + /** A spoken "play … on Musyx": the activity is only the way in, the search runs in the app. */ + private fun handleVoiceSearch(intent: Intent?) { + if (intent?.action != MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH) return + val app = Musyx.graph(this) + val query = intent.getStringExtra(SearchManager.QUERY) + app.scope.launch { runCatching { playFromSearch(app.state, query) } } + } + + private fun askForNotifications() { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return + if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED) return + askNotifications.launch(Manifest.permission.POST_NOTIFICATIONS) + } + + override fun onStart() { + super.onStart() + val token = SessionToken(this, ComponentName(this, PlaybackService::class.java)) + controller = MediaController.Builder(this, token).buildAsync() + } + + override fun onStop() { + controller?.let { MediaController.releaseFuture(it) } + controller = null + super.onStop() + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/Musyx.kt b/mobile/src/main/java/it/panov/musyx/mobile/Musyx.kt new file mode 100644 index 0000000..3d818d5 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/Musyx.kt @@ -0,0 +1,63 @@ +// The application: one AppState for the activity, the playback service and Android Auto to share. +package it.panov.musyx.mobile + +import android.app.Application +import android.content.Context +import android.content.res.Resources +import androidx.core.os.ConfigurationCompat +import coil3.ImageLoader +import coil3.PlatformContext +import coil3.SingletonImageLoader +import coil3.disk.DiskCache +import coil3.disk.directory +import coil3.memory.MemoryCache +import coil3.network.okhttp.OkHttpNetworkFetcherFactory +import coil3.request.crossfade +import it.panov.musyx.api.Lrclib +import it.panov.musyx.data.CredentialStore +import it.panov.musyx.data.SettingsStore +import it.panov.musyx.state.AppState +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.withContext + +class Musyx : Application(), SingletonImageLoader.Factory { + /** Lives as long as the process; everything in it runs on the main thread. */ + val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) + + override fun onCreate() { + super.onCreate() + Lrclib.agent = "Musyx/${BuildConfig.VERSION_NAME} (https://git.panov.it/panov/musyz-mobile)" + } + + val state: AppState by lazy { + AppState( + context = this, + scope = scope, + credentialStore = CredentialStore(this), + settingsStore = SettingsStore(this), + systemLanguage = { ConfigurationCompat.getLocales(Resources.getSystem().configuration)[0]?.language.orEmpty() }, + clearCovers = { + withContext(Dispatchers.IO) { SingletonImageLoader.get(this@Musyx).diskCache?.clear() } + }, + ) + } + + /** Covers: kept in memory and on disk so rows of cards open instantly the second time. */ + override fun newImageLoader(context: PlatformContext): ImageLoader = ImageLoader.Builder(context) + .components { add(OkHttpNetworkFetcherFactory()) } + .memoryCache { MemoryCache.Builder().maxSizePercent(context, 0.2).build() } + .diskCache { + DiskCache.Builder().directory(cacheDir.resolve("covers")).maxSizeBytes(COVER_CACHE_BYTES).build() + } + .crossfade(true) + .build() + + companion object { + private const val COVER_CACHE_BYTES = 200L * 1024 * 1024 + + /** The app state, from any context of this app. */ + fun graph(context: Context): Musyx = context.applicationContext as Musyx + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/PlaybackService.kt b/mobile/src/main/java/it/panov/musyx/mobile/PlaybackService.kt new file mode 100644 index 0000000..f697db5 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/PlaybackService.kt @@ -0,0 +1,54 @@ +// Background audio and everything outside the app that controls it: the notification, the +// lock screen, Bluetooth buttons, and Android Auto, which also browses the library here. +package it.panov.musyx.mobile + +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import androidx.annotation.OptIn +import androidx.media3.common.util.UnstableApi +import androidx.media3.session.MediaLibraryService +import androidx.media3.session.MediaSession + +@OptIn(UnstableApi::class) +class PlaybackService : MediaLibraryService() { + private var session: MediaLibrarySession? = null + private var stopWatching: (() -> Unit)? = null + + /** Folder names in Android Auto follow the app's language setting. */ + override fun attachBaseContext(newBase: Context) = super.attachBaseContext(newBase.inAppLanguage()) + + override fun onCreate() { + super.onCreate() + val app = Musyx.graph(this) + val open = PendingIntent.getActivity( + this, + 0, + Intent(this, MainActivity::class.java).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, + ) + // Android Auto may start the service with no activity: restore the sign-in for it. + app.state.start() + val library = Library(this, app.state, app.scope) + session = MediaLibrarySession.Builder(this, app.state.playback.sessionPlayer, library) + .setSessionActivity(open) + .build() + .also { stopWatching = library.watchSession(it) } + } + + override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession? = session + + override fun onTaskRemoved(rootIntent: Intent?) { + val player = session?.player + if (player == null || !player.playWhenReady || player.mediaItemCount == 0) stopSelf() + } + + override fun onDestroy() { + stopWatching?.invoke() + stopWatching = null + // The player belongs to the app and outlives the service. + session?.release() + session = null + super.onDestroy() + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/Format.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/Format.kt new file mode 100644 index 0000000..4f8705f --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/Format.kt @@ -0,0 +1,121 @@ +// Words and numbers as the interface shows them, in the interface language. +package it.panov.musyx.mobile.ui + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.ReadOnlyComposable +import androidx.compose.ui.platform.LocalResources +import androidx.compose.ui.res.pluralStringResource +import androidx.compose.ui.res.stringResource +import it.panov.musyx.mobile.R +import it.panov.musyx.api.AlbumKind +import it.panov.musyx.api.AlbumSummary +import it.panov.musyx.api.Clip +import it.panov.musyx.api.PlaylistSummary +import it.panov.musyx.api.Track +import it.panov.musyx.state.UiText + +@Composable +fun text(ui: UiText): String { + val res = LocalResources.current + fun resolve(t: UiText): String = when (t) { + is UiText.Raw -> t.text + is UiText.Res -> res.getString(t.id, *t.args.map { if (it is UiText) resolve(it) else it }.toTypedArray()) + is UiText.Plural -> res.getQuantityString(t.id, t.count, *t.args.map { if (it is UiText) resolve(it) else it }.toTypedArray()) + } + return resolve(ui) +} + +@Composable +@ReadOnlyComposable +fun Track.artistsOrUnknown(): String = artistLine ?: if (spoken) "" else stringResource(R.string.unknown_artist) + +@Composable +@ReadOnlyComposable +fun Clip.artistsOrUnknown(): String = artistLine ?: stringResource(R.string.unknown_artist) + +@Composable +@ReadOnlyComposable +fun kindLabel(kind: AlbumKind): String = stringResource( + when (kind) { + AlbumKind.Album -> R.string.kind_album + AlbumKind.Single -> R.string.kind_single + AlbumKind.Compilation -> R.string.kind_compilation + AlbumKind.Podcast -> R.string.kind_podcast + AlbumKind.Audiobook -> R.string.kind_audiobook + }, +) + +/** "Кино · 1988", the line under a card. Podcasts often list no artist: "Podcast · 2022". */ +@Composable +@ReadOnlyComposable +fun AlbumSummary.subtitle(): String { + val who = artistLine ?: kindLabel(kind) + return if (year != null) "$who · $year" else who +} + +@Composable +@ReadOnlyComposable +fun PlaylistSummary.subtitle(): String { + val count = tracksWord(trackCount) + return if (ownerName.isEmpty()) count else "$ownerName · $count" +} + +/** "1 track", "12 tracks". */ +@Composable +@ReadOnlyComposable +fun tracksWord(n: Int): String = pluralStringResource(R.plurals.tracks, n, n) + +/** "47 min" or "1 h 12 min". */ +@Composable +@ReadOnlyComposable +fun durationWords(ms: Long): String { + val mins = (ms / 60_000).toInt() + return if (mins >= 60) stringResource(R.string.duration_h_min, mins / 60, mins % 60) + else stringResource(R.string.duration_min, mins) +} + +/** `m:ss`, or `h:mm:ss` for podcast-length items. */ +fun clock(ms: Long): String { + val s = (ms.coerceAtLeast(0) / 1000) + val (h, m, sec) = Triple(s / 3600, (s / 60) % 60, s % 60) + return if (h > 0) "%d:%02d:%02d".format(h, m, sec) else "%d:%02d".format(m, sec) +} + +/** "4.1M", "830K", "912"; in Russian "4,1 млн", "830 тыс.", "912". */ +fun compact(n: Long, russian: Boolean): String { + val (value, en, ru) = when { + n >= 1_000_000 -> Triple("%.1f".format(java.util.Locale.US, n / 1e6), "M", " млн") + n >= 10_000 -> Triple((n / 1000).toString(), "K", " тыс.") + n >= 1_000 -> Triple("%.1f".format(java.util.Locale.US, n / 1e3), "K", " тыс.") + else -> return n.toString() + } + val v = value.removeSuffix(".0") + return if (russian) v.replace('.', ',') + ru else v + en +} + +@Composable +@ReadOnlyComposable +fun isRussian(): Boolean = stringResource(R.string.lang_code) == "ru" + +/** A compact count and its noun: "4.1M listeners a month", "3 лайка". */ +@Composable +@ReadOnlyComposable +fun counted(n: Long, plural: Int): String { + // An abbreviated number ("4,1 млн") reads as many. + val form = if (n >= 1_000) 5 else n.toInt().coerceAtLeast(0) + return pluralStringResource(plural, form, compact(n, isRussian())) +} + +/** `2027-01-05T00:00:00+03:00` → `5 January 2027` (`5 января 2027`). */ +@Composable +@ReadOnlyComposable +fun humanDate(iso: String): String? { + if (iso.length < 10) return null + val parts = iso.substring(0, 10).split('-') + if (parts.size != 3) return null + val year = parts[0].toIntOrNull() ?: return null + val month = parts[1].toIntOrNull()?.takeIf { it in 1..12 } ?: return null + val day = parts[2].toIntOrNull() ?: return null + val months = LocalResources.current.getStringArray(R.array.months_genitive) + return "$day ${months[month - 1]} $year" +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/MusyxApp.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/MusyxApp.kt new file mode 100644 index 0000000..d239235 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/MusyxApp.kt @@ -0,0 +1,194 @@ +// The app's frame: the full-screen sign-in states, and once signed in the top bar, the routed +// page, the mini player, the navigation bar, sheets and toasts. +package it.panov.musyx.mobile.ui + +import androidx.activity.compose.BackHandler +import androidx.annotation.DrawableRes +import androidx.annotation.StringRes +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.slideInVertically +import androidx.compose.animation.slideOutVertically +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.foundation.layout.systemBarsPadding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.material3.IconButton +import androidx.compose.material3.NavigationBar +import androidx.compose.material3.NavigationBarItem +import androidx.compose.material3.NavigationBarItemDefaults +import androidx.compose.material3.Scaffold +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.saveable.rememberSaveableStateHolder +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.screens.AlbumScreen +import it.panov.musyx.mobile.ui.screens.ArtistScreen +import it.panov.musyx.mobile.ui.screens.ChartScreen +import it.panov.musyx.mobile.ui.screens.CollectionScreen +import it.panov.musyx.mobile.ui.screens.GenreScreen +import it.panov.musyx.mobile.ui.screens.HoldingScreen +import it.panov.musyx.mobile.ui.screens.HomeScreen +import it.panov.musyx.mobile.ui.screens.MiniPlayer +import it.panov.musyx.mobile.ui.screens.NowPlayingScreen +import it.panov.musyx.mobile.ui.screens.PlaylistScreen +import it.panov.musyx.mobile.ui.screens.PodcastsScreen +import it.panov.musyx.mobile.ui.screens.SearchScreen +import it.panov.musyx.mobile.ui.screens.SettingsScreen +import it.panov.musyx.mobile.ui.screens.SheetHost +import it.panov.musyx.mobile.ui.screens.SignInScreen +import it.panov.musyx.mobile.ui.screens.ToastHost +import it.panov.musyx.mobile.ui.screens.UnreachableScreen +import it.panov.musyx.mobile.ui.screens.WaveScreen +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Route +import it.panov.musyx.state.Session + +private const val WORDMARK = "musyx" + +@Composable +fun MusyxApp(state: AppState, onExit: () -> Unit) { + Box(Modifier.fillMaxSize().background(MusyxTheme.colors.bg)) { + when (val s = state.session) { + Session.Restoring -> HoldingScreen(stringResource(R.string.session_checking)) + is Session.Connecting -> HoldingScreen(stringResource(R.string.session_signing_in)) + Session.Unreachable -> UnreachableScreen(state) + is Session.SignedOut -> SignInScreen(s.signIn) + is Session.SignedIn -> Shell(state, onExit) + } + if (state.session !is Session.SignedIn) ToastHost(state, Modifier.systemBarsPadding()) + } +} + +/** A navigation bar destination. */ +private class NavItem(val route: Route, @param:StringRes val label: Int, @param:DrawableRes val icon: Int) + +private val NAV = listOf( + NavItem(Route.Home, R.string.nav_home, R.drawable.ic_house), + NavItem(Route.Wave, R.string.nav_wave, R.drawable.ic_audio_lines), + NavItem(Route.Search, R.string.nav_search, R.drawable.ic_search), + NavItem(Route.Collection, R.string.nav_collection, R.drawable.ic_library), + NavItem(Route.Podcasts, R.string.nav_podcasts, R.drawable.ic_podcast), +) + +@Composable +private fun Shell(state: AppState, onExit: () -> Unit) { + val route = state.nav.current + val pages = rememberSaveableStateHolder() + BackHandler { if (!state.back()) onExit() } + + Scaffold( + containerColor = MusyxTheme.colors.bg, + topBar = { TopBar(state, route) }, + bottomBar = { + Column { + if (state.playback.state.hasTrack) MiniPlayer(state) + NavBar(state.nav.section, state::navigate) + } + }, + ) { padding -> + Box(Modifier.fillMaxSize().padding(padding)) { + pages.SaveableStateProvider(route.toString()) { Page(state, route) } + ToastHost(state) + } + } + // Now Playing slides up over everything, bars included. + AnimatedVisibility( + route == Route.NowPlaying, + enter = slideInVertically { it }, + exit = slideOutVertically { it }, + ) { + Box(Modifier.fillMaxSize().background(MusyxTheme.colors.bg).systemBarsPadding()) { + NowPlayingScreen(state, onClose = { state.back() }) + ToastHost(state) + } + } + SheetHost(state) +} + +@Composable +private fun Page(state: AppState, route: Route) { + when (route) { + Route.Home -> HomeScreen(state) + Route.Wave -> WaveScreen(state) + Route.Search -> SearchScreen(state) + Route.Collection -> CollectionScreen(state) + Route.Podcasts -> PodcastsScreen(state) + Route.Settings -> SettingsScreen(state) + // Drawn over the shell; the page underneath stays the one Now Playing was opened from. + Route.NowPlaying -> {} + Route.Chart -> ChartScreen(state) + is Route.Genre -> GenreScreen(state, route.index) + is Route.Album -> AlbumScreen(state, route) + is Route.Artist -> ArtistScreen(state, route) + is Route.Playlist -> PlaylistScreen(state, route) + } +} + +/** Back on pages under a section, the wordmark on the sections themselves; Settings on the right. */ +@Composable +private fun TopBar(state: AppState, route: Route) { + Row( + Modifier.fillMaxWidth().statusBarsPadding().height(56.dp).padding(horizontal = 4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + if (route in Route.SECTIONS || !state.nav.canGoBack) { + Wordmark(Modifier.padding(start = MusyxTheme.space.gutter - 4.dp)) + } else { + IconButton(onClick = { state.back() }) { MusyxIcon(R.drawable.ic_chevron_left) } + } + Spacer(Modifier.weight(1f)) + if (route != Route.Settings) { + IconButton(onClick = { state.navigate(Route.Settings) }) { MusyxIcon(R.drawable.ic_settings, tint = MusyxTheme.colors.muted) } + } + } +} + +@Composable +private fun NavBar(current: Route, onNavigate: (Route) -> Unit) { + val c = MusyxTheme.colors + NavigationBar(containerColor = c.panel) { + NAV.forEach { item -> + val selected = item.route == current + NavigationBarItem( + selected = selected, + onClick = { onNavigate(item.route) }, + icon = { MusyxIcon(item.icon, tint = if (selected) c.accentInk else c.muted) }, + label = { Text(stringResource(item.label), maxLines = 1) }, + colors = NavigationBarItemDefaults.colors( + indicatorColor = c.accent, + selectedTextColor = c.fg, + unselectedTextColor = c.muted, + ), + ) + } + } +} + +/** `musyx` and the amber dot. */ +@Composable +fun Wordmark(modifier: Modifier = Modifier) { + val c = MusyxTheme.colors + val scale = MusyxTheme.type.scale + Row(modifier) { + Text(WORDMARK, style = MusyxTheme.type.wordmark, color = c.fg, modifier = Modifier.alignByBaseline()) + Spacer(Modifier.width((3 * scale).dp)) + // The dot sits on the baseline, as in the desktop sidebar. + Box(Modifier.alignBy { it.measuredHeight }.size((7 * scale).dp).background(c.accent, CircleShape)) + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Media.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Media.kt new file mode 100644 index 0000000..aa05fb9 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Media.kt @@ -0,0 +1,190 @@ +// Covers, cards, shelves of cards and grids. +package it.panov.musyx.mobile.ui.components + +import androidx.annotation.DrawableRes +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.background +import androidx.compose.foundation.combinedClickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.aspectRatio +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyRow +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Icon +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Shape +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import coil3.compose.AsyncImage +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.theme.CoverPlaceholder +import it.panov.musyx.mobile.ui.theme.DarkColors +import it.panov.musyx.mobile.ui.theme.MusyxTheme + +/** Cover sizes asked of the image server. */ +const val COVER_SMALL = 100 +const val COVER_LARGE = 400 + +/** Cards in a shelf; grids work out their own width. */ +val CardWidth = 144.dp + +/** A Lucide icon from `res/drawable`, tinted. */ +@Composable +fun MusyxIcon(@DrawableRes icon: Int, modifier: Modifier = Modifier, tint: Color = MusyxTheme.colors.fg, size: Dp = 22.dp) { + Icon(painterResource(icon), contentDescription = null, tint = tint, modifier = modifier.size(size)) +} + +/** A cover image, with the two-hue placeholder while it loads or when there's none. */ +@Composable +fun Cover(url: String?, hues: Pair, modifier: Modifier = Modifier, shape: Shape = RoundedCornerShape(MusyxTheme.radius.smallCover)) { + Box(modifier.clip(shape)) { + CoverPlaceholder(hues, Modifier.fillMaxSize()) + if (url != null) { + AsyncImage(model = url, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxSize()) + } + } +} + +@Composable +fun Thumb(url: String?, hues: Pair, size: Dp, round: Boolean = false) { + Cover(url, hues, Modifier.size(size), if (round) CircleShape else RoundedCornerShape(MusyxTheme.radius.smallCover)) +} + +/** What a card shows. */ +class CardData( + val key: Any, + val title: String, + val subtitle: String, + val cover: String?, + val hues: Pair, + val round: Boolean = false, + val liked: Boolean? = null, + /** A short label on the cover's corner, such as a chart position. */ + val badge: String? = null, + /** What's playing comes from this card: an equaliser on its cover. */ + val playing: Boolean = false, + val onClick: () -> Unit, + val onLongClick: (() -> Unit)? = null, +) + +@OptIn(ExperimentalFoundationApi::class) +@Composable +fun MediaCard(card: CardData, modifier: Modifier = Modifier) { + val c = MusyxTheme.colors + val shape = if (card.round) CircleShape else RoundedCornerShape(MusyxTheme.radius.cover) + Column( + modifier + .clip(RoundedCornerShape(MusyxTheme.radius.cover)) + .combinedClickable(onClick = card.onClick, onLongClick = card.onLongClick), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Box(Modifier.fillMaxWidth().aspectRatio(1f)) { + Cover(card.cover, card.hues, Modifier.fillMaxSize(), shape) + card.badge?.let { badge -> + Text( + badge, + style = MusyxTheme.type.section, + color = Color.White, + modifier = Modifier + .align(Alignment.BottomStart) + .padding(8.dp) + .background(Color.Black.copy(alpha = 0.55f), RoundedCornerShape(MusyxTheme.radius.control)) + .padding(horizontal = 8.dp, vertical = 2.dp), + ) + } + if (card.playing) PlayingBadge(Modifier.align(Alignment.TopStart).padding(8.dp)) + if (card.liked == true) { + MusyxIcon(R.drawable.ic_heart_fill, Modifier.align(Alignment.TopEnd).padding(8.dp), tint = c.like, size = 18.dp) + } + } + Column { + Text(card.title, style = MusyxTheme.type.bodyMedium, color = c.fg, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text(card.subtitle, style = MusyxTheme.type.meta, color = c.muted, maxLines = 1, overflow = TextOverflow.Ellipsis) + } + } +} + +/** The equaliser on a cover whose music is playing: amber on a dark disc, legible on any art. */ +@Composable +fun PlayingBadge(modifier: Modifier = Modifier) { + Box(modifier.size(32.dp).background(Color.Black.copy(alpha = 0.6f), CircleShape), contentAlignment = Alignment.Center) { + MusyxIcon(R.drawable.ic_audio_lines, tint = DarkColors.accent, size = 18.dp) + } +} + +/** A link at the end of a shelf's heading, such as "Show all 100". */ +class ShelfMore(val label: String, val onClick: () -> Unit) + +/** A heading over a row of cards that scrolls sideways. */ +@Composable +fun CardShelf(title: String?, cards: List, modifier: Modifier = Modifier, more: ShelfMore? = null) { + val space = MusyxTheme.space + Column(modifier, verticalArrangement = Arrangement.spacedBy(space.s)) { + if (title != null || more != null) { + Row(Modifier.fillMaxWidth().padding(start = space.gutter, end = space.xs), verticalAlignment = Alignment.CenterVertically) { + Box(Modifier.weight(1f)) { if (title != null) SectionTitle(title) } + if (more != null) TextButton(onClick = more.onClick) { Text(more.label, style = MusyxTheme.type.meta) } + } + } + LazyRow( + horizontalArrangement = Arrangement.spacedBy(space.m), + contentPadding = PaddingValues(horizontal = space.gutter), + ) { + items(cards, key = { it.key }) { MediaCard(it, Modifier.width(CardWidth)) } + } + } +} + +/** Cards wrapped into as many columns as fit, as one item of a page. */ +@Composable +fun CardGrid(cards: List, modifier: Modifier = Modifier) { + val space = MusyxTheme.space + BoxWithConstraints(modifier.fillMaxWidth().padding(horizontal = space.gutter)) { + val columns = ((maxWidth + space.m) / (CardWidth + space.m)).toInt().coerceAtLeast(2) + Column(verticalArrangement = Arrangement.spacedBy(space.l)) { + cards.chunked(columns).forEach { row -> + Row(horizontalArrangement = Arrangement.spacedBy(space.m)) { + row.forEach { MediaCard(it, Modifier.weight(1f)) } + repeat(columns - row.size) { Spacer(Modifier.weight(1f)) } + } + } + } + } +} + +@Composable +fun SectionTitle(text: String, modifier: Modifier = Modifier) { + Text(text, style = MusyxTheme.type.section, color = MusyxTheme.colors.fg, modifier = modifier) +} + +/** A page's own title, at the top of its column. */ +@Composable +fun ScreenTitle(text: String) { + Text( + text, + style = MusyxTheme.type.displayS, + color = MusyxTheme.colors.fg, + modifier = Modifier.padding(horizontal = MusyxTheme.space.gutter, vertical = MusyxTheme.space.s), + ) +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Status.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Status.kt new file mode 100644 index 0000000..667a52b --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Status.kt @@ -0,0 +1,41 @@ +// Loading text, failures with a retry button, empty states. +package it.panov.musyx.mobile.ui.components + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.Button +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import it.panov.musyx.api.YmError +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.theme.MusyxTheme + +/** Muted running text inside the page margin. */ +@Composable +fun Note(text: String, modifier: Modifier = Modifier) { + Text( + text, + style = MusyxTheme.type.body, + color = MusyxTheme.colors.muted, + modifier = modifier.padding(horizontal = MusyxTheme.space.gutter, vertical = MusyxTheme.space.s), + ) +} + +/** A failure with a retry button. `what` is the object of "Couldn't load …", such as "your albums". */ +@Composable +fun Failure(error: YmError, what: String, onRetry: () -> Unit) { + Column( + Modifier.padding(horizontal = MusyxTheme.space.gutter, vertical = MusyxTheme.space.s), + verticalArrangement = Arrangement.spacedBy(MusyxTheme.space.m), + ) { + Text( + if (error is YmError.Network) stringResource(R.string.load_failed_network, what) else stringResource(R.string.load_failed, what), + style = MusyxTheme.type.body, + color = MusyxTheme.colors.muted, + ) + Button(onClick = onRetry) { Text(stringResource(R.string.action_try_again)) } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Tracks.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Tracks.kt new file mode 100644 index 0000000..5ac92d2 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/components/Tracks.kt @@ -0,0 +1,177 @@ +// Track rows and the play bar above lists. A tap plays the list from the row; a long press or +// the "more" button opens the track's menu. +package it.panov.musyx.mobile.ui.components + +import androidx.compose.foundation.ExperimentalFoundationApi +import androidx.compose.foundation.combinedClickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.material3.Button +import androidx.compose.material3.IconButton +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import it.panov.musyx.api.PlaylistId +import it.panov.musyx.api.Track +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.artistsOrUnknown +import it.panov.musyx.mobile.ui.clock +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.theme.tabular +import it.panov.musyx.state.AppState +import it.panov.musyx.state.PlaylistSlot +import it.panov.musyx.state.Sheet + +/** Which parts a row shows: album pages drop the cover; artist pages show the album, not the artist. */ +data class Columns(val cover: Boolean = true, val artist: Boolean = true) { + companion object { + val FULL = Columns() + val ALBUM_PAGE = Columns(cover = false) + val ARTIST_PAGE = Columns(artist = false) + } +} + +/** + * The rows of a track list, as items of the page's lazy column. `shifts` adds chart + * movement; `playlist` adds edit actions to the menu, at `positions` on the server. + */ +fun LazyListScope.trackItems( + state: AppState, + tracks: List, + columns: Columns = Columns.FULL, + shifts: List? = null, + playlist: PlaylistId? = null, + positions: List? = null, + keyPrefix: String = "t", + /** Off in Liked tracks, where every heart would be full; unliking is in the menu. */ + hearts: Boolean = true, +) { + itemsIndexed(tracks, key = { i, t -> "$keyPrefix:$i:${t.id}" }) { i, track -> + TrackRow( + index = i, + track = track, + playing = state.playback.state.track?.id == track.id, + liked = state.liked.contains(track.id), + columns = columns, + shift = shifts?.getOrNull(i), + onPlay = { state.playTracks(tracks, i) }, + onLike = if (hearts) ({ state.likeTrack(track, !state.liked.contains(track.id)) }) else null, + onMore = { + val at = positions ?: tracks.indices.toList() + state.openSheet(Sheet.TrackMenu(track, playlist?.let { PlaylistSlot(it, at[i], at.getOrNull(i - 1), at.getOrNull(i + 1)) })) + }, + ) + } +} + +@OptIn(ExperimentalFoundationApi::class) +@Composable +fun TrackRow( + index: Int, + track: Track, + playing: Boolean, + liked: Boolean, + columns: Columns, + shift: Int?, + onPlay: () -> Unit, + /** Null hides the heart. */ + onLike: (() -> Unit)?, + onMore: () -> Unit, +) { + val c = MusyxTheme.colors + val titleColor = when { + !track.available -> c.muted + playing -> c.accent + else -> c.fg + } + Row( + Modifier + .fillMaxWidth() + .combinedClickable(onClick = { if (track.available) onPlay() }, onLongClick = onMore) + .padding(start = MusyxTheme.space.gutter, end = 4.dp, top = 6.dp, bottom = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + if (columns.cover) { + Box(contentAlignment = Alignment.Center) { + Thumb(track.coverUrl(COVER_SMALL), track.hues, 48.dp) + if (playing) PlayingBadge() + } + } else { + Box(Modifier.width(28.dp), contentAlignment = Alignment.Center) { + if (playing) MusyxIcon(R.drawable.ic_audio_lines, tint = c.accent, size = 18.dp) + else Text("${index + 1}", style = MusyxTheme.type.meta.tabular(), color = c.muted) + } + } + if (shift != null) ShiftMarker(shift) + Column(Modifier.weight(1f)) { + Text(track.fullTitle, style = MusyxTheme.type.bodyMedium, color = titleColor, maxLines = 1, overflow = TextOverflow.Ellipsis) + val subtitle = listOfNotNull( + (if (columns.artist) track.artistsOrUnknown() else track.album?.title).takeIf { !it.isNullOrEmpty() }, + clock(track.durationMs), + ).joinToString(" · ") + Text(subtitle, style = MusyxTheme.type.meta, color = c.muted, maxLines = 1, overflow = TextOverflow.Ellipsis) + } + if (onLike != null) { + IconButton(onClick = onLike) { + MusyxIcon(if (liked) R.drawable.ic_heart_fill else R.drawable.ic_heart, tint = if (liked) c.like else c.muted, size = 20.dp) + } + } + IconButton(onClick = onMore) { MusyxIcon(R.drawable.ic_ellipsis, tint = c.muted, size = 20.dp) } + } +} + +/** The arrow beside a chart position. */ +@Composable +fun ShiftMarker(shift: Int) { + val c = MusyxTheme.colors + val (glyph, colour) = when { + shift > 0 -> "▲" to c.ok + shift < 0 -> "▼" to c.like + else -> "–" to c.muted + } + Text(glyph, style = MusyxTheme.type.small, color = colour, modifier = Modifier.width(14.dp), textAlign = TextAlign.Center) +} + +/** Play and Shuffle, then any page actions (the heart), then a summary. */ +@Composable +fun PlayBar(state: AppState, tracks: List, summary: String = "", actions: @Composable () -> Unit = {}) { + val space = MusyxTheme.space + Column(Modifier.fillMaxWidth().padding(horizontal = space.gutter), verticalArrangement = Arrangement.spacedBy(space.s)) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(space.s)) { + Button(onClick = { state.playTracks(tracks, 0) }, enabled = tracks.isNotEmpty()) { + MusyxIcon(R.drawable.ic_play_fill, tint = MusyxTheme.colors.accentInk, size = 18.dp) + Text(stringResource(R.string.action_play), modifier = Modifier.padding(start = 8.dp)) + } + OutlinedButton(onClick = { state.playTracks(tracks, 0, shuffle = true) }, enabled = tracks.isNotEmpty()) { + MusyxIcon(R.drawable.ic_shuffle, size = 18.dp) + Text(stringResource(R.string.action_shuffle), modifier = Modifier.padding(start = 8.dp)) + } + actions() + } + if (summary.isNotEmpty()) Text(summary, style = MusyxTheme.type.meta, color = MusyxTheme.colors.muted) + } +} + +/** A round heart that adds or removes something from the collection. */ +@Composable +fun LikeButton(liked: Boolean, onClick: () -> Unit) { + val c = MusyxTheme.colors + IconButton(onClick = onClick, modifier = Modifier.size(44.dp)) { + MusyxIcon(if (liked) R.drawable.ic_heart_fill else R.drawable.ic_heart, tint = if (liked) c.like else c.fg) + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Common.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Common.kt new file mode 100644 index 0000000..2ee795b --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Common.kt @@ -0,0 +1,259 @@ +// Pieces several screens share: the page column, card builders, genre tiles, loading states. +package it.panov.musyx.mobile.ui.screens + +import android.content.ActivityNotFoundException +import android.content.Context +import android.content.Intent +import androidx.annotation.StringRes +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxWithConstraints +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.lazy.LazyRow +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import androidx.core.net.toUri +import it.panov.musyx.api.AlbumSummary +import it.panov.musyx.api.ArtistSummary +import it.panov.musyx.api.Clip +import it.panov.musyx.api.Genre +import it.panov.musyx.api.PlaylistSummary +import it.panov.musyx.api.Track +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.artistsOrUnknown +import it.panov.musyx.mobile.ui.clock +import it.panov.musyx.mobile.ui.components.COVER_LARGE +import it.panov.musyx.mobile.ui.components.CardData +import it.panov.musyx.mobile.ui.components.CardShelf +import it.panov.musyx.mobile.ui.components.CardWidth +import it.panov.musyx.mobile.ui.components.Failure +import it.panov.musyx.mobile.ui.components.Note +import it.panov.musyx.mobile.ui.components.SectionTitle +import it.panov.musyx.mobile.ui.components.ShelfMore +import it.panov.musyx.mobile.ui.subtitle +import it.panov.musyx.mobile.ui.theme.DarkColors +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.theme.mix +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Loadable +import it.panov.musyx.state.Route +import it.panov.musyx.state.Sheet +import it.panov.musyx.state.UiText + +/** A scrolling page: sections stacked with a small gap, room at the bottom for the mini player. */ +@Composable +fun PageColumn(content: LazyListScope.() -> Unit) { + val space = MusyxTheme.space + LazyColumn( + state = rememberLazyListState(), + modifier = Modifier.fillMaxSize(), + contentPadding = PaddingValues(top = space.s, bottom = space.section), + verticalArrangement = Arrangement.spacedBy(space.s), + content = content, + ) +} + +/** Space between two sections of a page. */ +fun LazyListScope.gap(key: Any) { + item(key = key) { Spacer(Modifier.height(MusyxTheme.space.section - MusyxTheme.space.s * 2)) } +} + +/** An album, podcast or book. `heart` is off where every card is liked anyway. */ +@Composable +fun albumCard(state: AppState, a: AlbumSummary, heart: Boolean = true) = CardData( + key = "al${a.id}", + title = a.fullTitle, + subtitle = a.subtitle(), + cover = a.coverUrl(COVER_LARGE), + hues = a.hues, + liked = heart && a.id in state.likes.albums, + playing = state.playback.state.track?.album?.id == a.id, + onClick = { state.navigate(Route.Album(a.id)) }, +) + +@Composable +fun artistCard(state: AppState, a: ArtistSummary) = CardData( + key = "ar${a.id}", + title = a.name, + subtitle = a.genres.firstOrNull() ?: stringResource(R.string.kind_artist), + cover = a.coverUrl(COVER_LARGE), + hues = a.hues, + round = true, + onClick = { state.navigate(Route.Artist(a.id)) }, +) + +@Composable +fun playlistCard(state: AppState, p: PlaylistSummary, subtitle: String? = null) = CardData( + key = "pl${p.id.key}", + title = p.title, + subtitle = subtitle ?: p.subtitle(), + cover = p.coverUrl(COVER_LARGE), + hues = p.hues, + onClick = { state.navigate(Route.Playlist(p.id)) }, +) + +/** A track as a card: a tap plays `tracks` from it, a long press opens its menu. */ +@Composable +fun trackCard(state: AppState, tracks: List, index: Int, badge: String? = null): CardData { + val track = tracks[index] + return CardData( + key = "tr$index:${track.id}", + title = track.fullTitle, + subtitle = track.artistsOrUnknown(), + cover = track.coverUrl(COVER_LARGE), + hues = track.hues, + liked = state.liked.contains(track.id), + badge = badge, + playing = state.playback.state.track?.id == track.id, + onClick = { if (track.available) state.playTracks(tracks, index) }, + onLongClick = { state.openSheet(Sheet.TrackMenu(track)) }, + ) +} + +/** A music video. It opens in the browser or the Yandex Music app; a long press likes or unlikes it. */ +@Composable +fun clipCard(state: AppState, clip: Clip): CardData { + val context = LocalContext.current + val liked = clip.id in state.likes.clips + return CardData( + key = "cl${clip.id}", + title = clip.title, + subtitle = "${clip.artistsOrUnknown()} · ${clock(clip.durationSec * 1000)}", + cover = clip.coverUrl(COVER_LARGE), + hues = clip.hues, + liked = liked, + onClick = { openClip(context, state, clip) }, + onLongClick = { state.likeClip(clip, !liked) }, + ) +} + +private fun openClip(context: Context, state: AppState, clip: Clip) { + try { + context.startActivity(Intent(Intent.ACTION_VIEW, clip.url.toUri()).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) + } catch (_: ActivityNotFoundException) { + state.toast(UiText.Res(R.string.toast_no_browser)) + } +} + +/** A loading note, a retry on failure, or `loaded` with the value. */ +fun LazyListScope.loadable( + key: String, + value: Loadable, + loading: @Composable () -> String, + what: @Composable () -> String, + retry: () -> Unit, + loaded: LazyListScope.(T) -> Unit, +) { + when (value) { + is Loadable.Loaded -> loaded(value.value) + is Loadable.Failed -> item(key = "$key-failed") { Failure(value.error, what(), retry) } + else -> item(key = "$key-loading") { Note(loading()) } + } +} + +/** A shelf of cards as one item of a page. */ +fun LazyListScope.shelf( + key: String, + @StringRes title: Int?, + cards: @Composable () -> List, + more: (@Composable () -> ShelfMore)? = null, +) { + item(key = key) { + val list = cards() + if (list.isNotEmpty()) CardShelf(title?.let { stringResource(it) }, list, more = more?.invoke()) + } +} + +/** The top-level genres: a row on Home, or a grid on Search before anything is typed. */ +fun LazyListScope.genreShelf(state: AppState, grid: Boolean = false) { + if (!grid) { + item(key = "genres-title") { SectionTitle(stringResource(R.string.section_genres), Modifier.padding(horizontal = MusyxTheme.space.gutter)) } + } + loadable( + "genres", + state.genres, + loading = { stringResource(R.string.loading_genres) }, + what = { stringResource(R.string.what_genres) }, + retry = state::loadGenres, + ) { list -> + val top = list.withIndex().filter { (_, g) -> list.none { p -> p.subGenres.any { it.id == g.id } } } + item(key = "genres-row") { + if (grid) { + GenreGrid(top.map { (index, genre) -> genre to { state.navigate(Route.Genre(index)) } }) + } else { + LazyRow( + horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.m), + contentPadding = PaddingValues(horizontal = MusyxTheme.space.gutter), + ) { + items(top, key = { it.value.id }) { (index, genre) -> + GenreTile(genre, { state.navigate(Route.Genre(index)) }, Modifier.width(CardWidth)) + } + } + } + } + } +} + +@Composable +fun GenreTile(genre: Genre, onClick: () -> Unit, modifier: Modifier = Modifier) { + // Genres without a colour get the dark raised tone, so the white title reads in either theme. + val tint = genre.color?.let(::parseHex) ?: DarkColors.raised + val shape = RoundedCornerShape(MusyxTheme.radius.cover) + Box( + modifier + .height(72.dp) + .clip(shape) + .background(Brush.linearGradient(listOf(tint, mix(tint, Color.Black, 0.45f)))) + .clickable(onClick = onClick) + .padding(horizontal = 14.dp), + contentAlignment = Alignment.CenterStart, + ) { + Text(genre.title, style = MusyxTheme.type.bodyMedium, color = Color.White, maxLines = 2) + } +} + +@Composable +private fun GenreGrid(genres: List Unit>>) { + val space = MusyxTheme.space + BoxWithConstraints(Modifier.fillMaxWidth().padding(horizontal = space.gutter)) { + val columns = ((maxWidth + space.m) / (CardWidth + space.m)).toInt().coerceAtLeast(2) + Column(verticalArrangement = Arrangement.spacedBy(space.m)) { + genres.chunked(columns).forEach { row -> + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(space.m)) { + row.forEach { (genre, open) -> GenreTile(genre, open, Modifier.weight(1f)) } + repeat(columns - row.size) { Spacer(Modifier.weight(1f)) } + } + } + } + } +} + +/** `#rrggbb` → colour. */ +fun parseHex(s: String): Color? { + val h = s.removePrefix("#").takeIf { s.startsWith('#') && it.length == 6 } ?: return null + val n = h.toLongOrNull(16) ?: return null + return Color(0xFF000000 or n) +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Detail.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Detail.kt new file mode 100644 index 0000000..606e59f --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Detail.kt @@ -0,0 +1,250 @@ +// Album, artist and playlist pages: a cover header, then tracks and shelves. +package it.panov.musyx.mobile.ui.screens + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.IconButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import it.panov.musyx.api.AlbumPage +import it.panov.musyx.api.ArtistPage +import it.panov.musyx.api.PlaylistPage +import it.panov.musyx.api.PlaylistSummary +import it.panov.musyx.api.YmError +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.components.COVER_LARGE +import it.panov.musyx.mobile.ui.components.Columns +import it.panov.musyx.mobile.ui.components.Cover +import it.panov.musyx.mobile.ui.components.Failure +import it.panov.musyx.mobile.ui.components.LikeButton +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Note +import it.panov.musyx.mobile.ui.components.PlayBar +import it.panov.musyx.mobile.ui.components.SectionTitle +import it.panov.musyx.mobile.ui.components.trackItems +import it.panov.musyx.mobile.ui.counted +import it.panov.musyx.mobile.ui.durationWords +import it.panov.musyx.mobile.ui.kindLabel +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.tracksWord +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Loadable +import it.panov.musyx.state.Page +import it.panov.musyx.state.Route +import it.panov.musyx.state.Sheet + +/** How a page talks about what it's loading. */ +private class What(val loading: Int, val gone: Int, val retry: Int) + +/** The shared frame: loading, gone, failure, or the page. */ +@Composable +private fun DetailPage(state: AppState, route: Route, what: What, content: LazyListScope.(Page) -> Unit) { + PageColumn { + when (val page = state.pages[route] ?: Loadable.Loading) { + is Loadable.Loaded -> content(page.value) + is Loadable.Failed -> item(key = "failed") { + if (page.error is YmError.NotFound) Note(stringResource(what.gone)) + else Failure(page.error, stringResource(what.retry)) { state.retryPage(route) } + } + else -> item(key = "loading") { Note(stringResource(what.loading)) } + } + } +} + +/** The cover centred over kind, title, byline and meta, then any actions. */ +@Composable +private fun Head( + cover: String?, + hues: Pair, + round: Boolean, + kind: String, + title: String, + by: String?, + meta: String, + onBy: (() -> Unit)? = null, + actions: (@Composable () -> Unit)? = null, +) { + val c = MusyxTheme.colors + Column( + Modifier.fillMaxWidth().padding(horizontal = MusyxTheme.space.gutter), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Cover(cover, hues, Modifier.size(220.dp).padding(bottom = 8.dp), if (round) CircleShape else RoundedCornerShape(MusyxTheme.radius.cover)) + Text(kind, style = MusyxTheme.type.meta, color = c.muted, maxLines = 1) + Text(title, style = MusyxTheme.type.displayL, color = c.fg, maxLines = 3, overflow = TextOverflow.Ellipsis, textAlign = TextAlign.Center) + if (by != null) { + if (onBy != null) TextButton(onClick = onBy) { Text(by, style = MusyxTheme.type.bodyMedium, maxLines = 1) } + else Text(by, style = MusyxTheme.type.bodyMedium, color = c.fg, maxLines = 1) + } + if (meta.isNotEmpty()) Text(meta, style = MusyxTheme.type.meta, color = c.muted, maxLines = 2, textAlign = TextAlign.Center) + if (actions != null) Row(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s), verticalAlignment = Alignment.CenterVertically) { actions() } + } +} + +@Composable +fun AlbumScreen(state: AppState, route: Route.Album) { + DetailPage(state, route, What(R.string.loading_album, R.string.gone_album, R.string.what_album)) { page -> + albumPage(state, (page as Page.OfAlbum).info) + } +} + +private fun LazyListScope.albumPage(state: AppState, info: AlbumPage) { + val a = info.album + item(key = "head") { + val kind = kindLabel(a.kind).let { if (a.year != null) "$it · ${a.year}" else it } + val length = "${tracksWord(info.tracks.size)} · ${durationWords(info.tracks.sumOf { it.durationMs })}" + val artist = a.artists.firstOrNull { it.id != null } + Head( + a.coverUrl(COVER_LARGE), a.hues, false, kind, a.fullTitle, a.artistLine, + listOfNotNull(length, info.label).joinToString(" · "), + onBy = artist?.let { { state.navigate(Route.Artist(it.id!!)) } }, + ) + } + item(key = "play") { + val liked = a.id in state.likes.albums + PlayBar(state, info.tracks) { LikeButton(liked) { state.likeAlbum(a.id, !liked) } } + } + trackItems(state, info.tracks, Columns.ALBUM_PAGE, keyPrefix = "album") +} + +@Composable +fun ArtistScreen(state: AppState, route: Route.Artist) { + DetailPage(state, route, What(R.string.loading_artist, R.string.gone_artist, R.string.what_artist)) { page -> + artistPage(state, (page as Page.OfArtist).info) + } +} + +private fun LazyListScope.artistPage(state: AppState, info: ArtistPage) { + val a = info.artist + item(key = "head") { + val kind = if (a.genres.isEmpty()) stringResource(R.string.kind_artist) + else stringResource(R.string.kind_artist_genres, a.genres.joinToString(", ")) + val meta = info.monthlyListeners?.let { counted(it, R.plurals.listeners_a_month) } + ?: a.likes?.let { counted(it, R.plurals.likes) } + ?: "" + val liked = a.id in state.likes.artists + Head( + a.coverUrl(COVER_LARGE), a.hues, true, kind, a.name, null, meta, + actions = if (info.popular.isEmpty()) ({ LikeButton(liked) { state.likeArtist(a.id, !liked) } }) else null, + ) + } + if (info.popular.isNotEmpty()) { + gap("popular-gap") + item(key = "popular-title") { SectionTitle(stringResource(R.string.section_popular), Modifier.padding(horizontal = MusyxTheme.space.gutter)) } + item(key = "play") { + val liked = a.id in state.likes.artists + PlayBar(state, info.popular) { LikeButton(liked) { state.likeArtist(a.id, !liked) } } + } + trackItems(state, info.popular, Columns.ARTIST_PAGE, keyPrefix = "popular") + } + if (info.albums.isNotEmpty()) { + gap("albums-gap") + shelf("albums", R.string.tab_albums, { info.albums.map { albumCard(state, it) } }) + } + if (info.alsoAlbums.isNotEmpty()) { + gap("also-gap") + shelf("also", R.string.section_appears_on, { info.alsoAlbums.map { albumCard(state, it) } }) + } + if (info.clips.isNotEmpty()) { + gap("clips-gap") + shelf("clips", R.string.tab_clips, { info.clips.map { clipCard(state, it) } }) + } + if (info.similar.isNotEmpty()) { + gap("similar-gap") + shelf("similar", R.string.section_similar_artists, { info.similar.map { artistCard(state, it) } }) + } +} + +@Composable +fun PlaylistScreen(state: AppState, route: Route.Playlist) { + DetailPage(state, route, What(R.string.loading_playlist, R.string.gone_playlist, R.string.what_playlist)) { page -> + playlistPage(state, (page as Page.OfPlaylist).info) + } +} + +private fun LazyListScope.playlistPage(state: AppState, info: PlaylistPage) { + val p = info.playlist + val own = p.id.owner == state.account?.uid + item(key = "head") { + val kind = stringResource(R.string.kind_playlist_by, stringResource(if (p.public) R.string.visibility_public else R.string.visibility_private)) + val meta = "${tracksWord(info.tracks.size)} · ${durationWords(info.tracks.sumOf { it.durationMs })}" + val likeHere = !own && info.tracks.isEmpty() + Head( + p.coverUrl(COVER_LARGE), p.hues, false, kind, p.title, p.ownerName.takeIf { it.isNotEmpty() }, meta, + actions = if (likeHere) ({ val liked = p.id in state.likes.playlists; LikeButton(liked) { state.likePlaylist(p.id, !liked) } }) else null, + ) + } + info.description?.let { d -> + item(key = "description") { + Text( + d, + style = MusyxTheme.type.meta, + color = MusyxTheme.colors.muted, + maxLines = 4, + overflow = TextOverflow.Ellipsis, + modifier = Modifier.padding(horizontal = MusyxTheme.space.gutter), + ) + } + } + if (info.tracks.isEmpty()) { + if (own) item(key = "own-actions") { Row(Modifier.padding(horizontal = MusyxTheme.space.gutter)) { OwnPlaylistMenu(state, p) } } + item(key = "empty") { Note(stringResource(R.string.playlist_empty)) } + return + } + item(key = "play") { + PlayBar(state, info.tracks) { + if (own) { + OwnPlaylistMenu(state, p) + } else { + val liked = p.id in state.likes.playlists + LikeButton(liked) { state.likePlaylist(p.id, !liked) } + } + } + } + trackItems(state, info.tracks, playlist = if (own) p.id else null, positions = info.positions, keyPrefix = "pl") +} + +/** Rename, visibility and delete for your own playlist, behind a "more" button. */ +@Composable +private fun OwnPlaylistMenu(state: AppState, p: PlaylistSummary) { + var open by remember { mutableStateOf(false) } + IconButton(onClick = { open = true }) { MusyxIcon(R.drawable.ic_ellipsis) } + DropdownMenu(expanded = open, onDismissRequest = { open = false }) { + DropdownMenuItem( + text = { Text(stringResource(R.string.action_rename)) }, + leadingIcon = { MusyxIcon(R.drawable.ic_pencil, size = 18.dp) }, + onClick = { open = false; state.openSheet(Sheet.Rename(p.id, p.title)) }, + ) + DropdownMenuItem( + text = { Text(stringResource(if (p.public) R.string.action_make_private else R.string.action_make_public)) }, + leadingIcon = { MusyxIcon(if (p.public) R.drawable.ic_lock else R.drawable.ic_globe, size = 18.dp) }, + onClick = { open = false; state.setPlaylistPublic(p.id, !p.public) }, + ) + DropdownMenuItem( + text = { Text(stringResource(R.string.action_delete), color = MusyxTheme.colors.like) }, + leadingIcon = { MusyxIcon(R.drawable.ic_trash_2, tint = MusyxTheme.colors.like, size = 18.dp) }, + onClick = { open = false; state.openSheet(Sheet.ConfirmDelete(p.id, p.title)) }, + ) + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/HomeWave.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/HomeWave.kt new file mode 100644 index 0000000..98f9848 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/HomeWave.kt @@ -0,0 +1,313 @@ +// Home and My Wave: the animated hero, the picks, station settings and other stations. +package it.panov.musyx.mobile.ui.screens + +import androidx.compose.animation.core.LinearEasing +import androidx.compose.animation.core.RepeatMode +import androidx.compose.animation.core.animateFloat +import androidx.compose.animation.core.infiniteRepeatable +import androidx.compose.animation.core.rememberInfiniteTransition +import androidx.compose.animation.core.tween +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyRow +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.Button +import androidx.compose.material3.FilterChip +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import coil3.compose.AsyncImage +import it.panov.musyx.api.Character +import it.panov.musyx.api.Language +import it.panov.musyx.api.MY_WAVE +import it.panov.musyx.api.Mood +import it.panov.musyx.api.Station +import it.panov.musyx.api.WaveSettings +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.components.CardWidth +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Note +import it.panov.musyx.mobile.ui.components.PlayingBadge +import it.panov.musyx.mobile.ui.components.SectionTitle +import it.panov.musyx.mobile.ui.components.ShelfMore +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.theme.mix +import it.panov.musyx.player.Status +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Route +import kotlin.math.PI +import kotlin.math.ceil +import kotlin.math.sin + +/** Chart positions shown on Home before "Show all". */ +private const val HOME_CHART = 12 +/** Cards per Home shelf. */ +private const val HOME_CARDS = 12 + +@Composable +fun HomeScreen(state: AppState) { + PageColumn { + item(key = "hero") { WaveHero(state, big = false) } + + // Only worth a section when it has something; a failure stays in the log. + state.recent.get()?.takeIf { it.isNotEmpty() }?.let { recent -> + gap("recent-gap") + shelf("recent", R.string.section_recent, { recent.indices.map { trackCard(state, recent, it) } }) + } + + gap("home-gap") + loadable( + "home", + state.home, + loading = { stringResource(R.string.loading_home) }, + what = { stringResource(R.string.what_home) }, + retry = state::loadHome, + ) { home -> + if (home.personal.isNotEmpty()) { + shelf("personal", R.string.section_made_for_you, { + home.personal.map { p -> playlistCard(state, p.playlist, subtitle = p.description) } + }) + } + if (home.chart.isNotEmpty()) { + gap("chart-gap") + val top = home.chart.take(HOME_CHART).map { it.track } + shelf( + "chart", + R.string.section_chart, + { top.indices.map { trackCard(state, top, it, badge = "${it + 1}") } }, + more = { ShelfMore(stringResource(R.string.action_show_all_n, home.chart.size)) { state.navigate(Route.Chart) } }, + ) + } + if (home.newReleases.isNotEmpty()) { + gap("releases-gap") + shelf("releases", R.string.section_new_releases, { home.newReleases.take(HOME_CARDS).map { albumCard(state, it) } }) + } + if (home.newPlaylists.isNotEmpty()) { + gap("playlists-gap") + shelf("new-playlists", R.string.section_new_playlists, { home.newPlaylists.take(HOME_CARDS).map { playlistCard(state, it) } }) + } + } + gap("genres-gap") + genreShelf(state) + } +} + +/** The My Wave hero, on Home (`big = false`) and the My Wave screen. */ +@Composable +fun WaveHero(state: AppState, big: Boolean) { + val c = MusyxTheme.colors + val space = MusyxTheme.space + val status = state.playback.state.takeIf { it.waveStation == MY_WAVE }?.status + val playing = status == Status.Playing + val settings = state.waveShown + + // Why My Wave stopped, when it did, so a failed start isn't silent here. + val notice = state.playback.state.takeIf { it.waveStation == MY_WAVE && status != Status.Playing }?.notice + val blurb = if (notice != null) { + noticeText(notice) + } else if (settings != null && !settings.isDefault) { + stringResource( + R.string.wave_tuned, + stringResource(moodLabel(settings.mood)).lowercase(), + stringResource(characterLabel(settings.character)).lowercase(), + stringResource(languageLabel(settings.language)).lowercase(), + ) + } else { + stringResource(R.string.wave_blurb) + } + val (label, icon, action) = when (status) { + Status.Playing, Status.Loading -> Triple(R.string.action_pause, R.drawable.ic_pause_fill) { state.playback.toggle() } + null -> Triple(R.string.wave_play, R.drawable.ic_play_fill) { state.playWave(MY_WAVE) } + else -> Triple(R.string.action_resume, R.drawable.ic_play_fill) { state.playback.toggle() } + } + val shape = RoundedCornerShape(MusyxTheme.radius.hero) + Box( + Modifier + .padding(horizontal = space.gutter) + .fillMaxWidth() + .height(if (big) 220.dp else 180.dp) + .clip(shape) + .background(Brush.horizontalGradient(listOf(c.panel, mix(c.panel, c.accent, 0.10f)))), + ) { + WaveArt(playing, Modifier.fillMaxSize()) + Column( + Modifier.align(Alignment.BottomStart).fillMaxWidth().padding(20.dp), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + Text(stringResource(R.string.nav_wave), style = if (big) MusyxTheme.type.displayL else MusyxTheme.type.displayM, color = c.fg) + Text(blurb, style = MusyxTheme.type.meta, color = c.muted, maxLines = 2, overflow = TextOverflow.Ellipsis) + Button(onClick = action, modifier = Modifier.padding(top = 6.dp)) { + MusyxIcon(icon, tint = c.accentInk, size = 18.dp) + Text(stringResource(label), modifier = Modifier.padding(start = 8.dp)) + } + } + } +} + +/** Lines drifting across the hero. They move only while My Wave plays. */ +@Composable +private fun WaveArt(playing: Boolean, modifier: Modifier) { + val accent = MusyxTheme.colors.accent + val transition = rememberInfiniteTransition(label = "wave") + val drift by transition.animateFloat( + initialValue = 0f, + targetValue = (2 * PI * 20).toFloat(), + animationSpec = infiniteRepeatable(tween(durationMillis = 120_000, easing = LinearEasing), RepeatMode.Restart), + label = "phase", + ) + val phase = if (playing) drift else 0f + val energy = if (playing) 1f else 0.45f + Canvas(modifier) { + val (w, h) = size.width to size.height + val lines = 14 + for (k in 0 until lines) { + val kf = k.toFloat() + val base = h * (0.18f + kf * 0.024f) + val amp = h * (0.05f + kf * 0.006f) * energy + val freq = 1.6f + kf * 0.09f + val ph = phase * (0.35f + kf * 0.02f) + kf * 0.5f + val path = Path() + val steps = ceil(w / 8f).toInt() + for (i in 0..steps) { + val x = i * 8f + val u = x / w + val y = base + sin(u * PI.toFloat() * freq + ph) * amp + sin(u * PI.toFloat() * 4.2f - ph * 0.7f) * amp * 0.35f + if (i == 0) path.moveTo(x, y) else path.lineTo(x, y) + } + val alpha = 0.08f + (kf / lines) * 0.55f + drawPath(path, accent.copy(alpha = alpha), style = Stroke(width = 1.5f + kf * 0.12f)) + } + } +} + +fun moodLabel(m: Mood) = when (m) { + Mood.Any -> R.string.wave_any + Mood.Energetic -> R.string.mood_energetic + Mood.Cheerful -> R.string.mood_cheerful + Mood.Calm -> R.string.mood_calm + Mood.Sad -> R.string.mood_sad +} + +fun characterLabel(ch: Character) = when (ch) { + Character.Default -> R.string.wave_any + Character.Favourite -> R.string.character_favourite + Character.Unfamiliar -> R.string.character_unfamiliar + Character.Popular -> R.string.character_popular +} + +fun languageLabel(l: Language) = when (l) { + Language.Any -> R.string.wave_any + Language.Russian -> R.string.language_russian + Language.Foreign -> R.string.language_foreign +} + +@Composable +fun WaveScreen(state: AppState) { + val space = MusyxTheme.space + PageColumn { + item(key = "hero") { WaveHero(state, big = true) } + gap("settings-gap") + val shown = state.waveShown + val saving = state.waveSaving != null + if (shown != null) { + item(key = "mood") { + SettingRow(stringResource(R.string.wave_mood), Mood.entries.map { m -> + Triple(stringResource(moodLabel(m)), m == shown.mood, shown.copy(mood = m)) + }, saving, state::setWaveSettings) + } + item(key = "character") { + SettingRow(stringResource(R.string.wave_character), Character.entries.map { ch -> + Triple(stringResource(characterLabel(ch)), ch == shown.character, shown.copy(character = ch)) + }, saving, state::setWaveSettings) + } + item(key = "language") { + SettingRow(stringResource(R.string.wave_language), Language.entries.map { l -> + Triple(stringResource(languageLabel(l)), l == shown.language, shown.copy(language = l)) + }, saving, state::setWaveSettings) + } + } else { + loadable( + "wave-settings", + state.waveSettings, + loading = { stringResource(R.string.loading_wave_settings) }, + what = { stringResource(R.string.what_wave_settings) }, + retry = state::loadWave, + ) {} + } + gap("stations-gap") + item(key = "stations-title") { SectionTitle(stringResource(R.string.section_stations), Modifier.padding(horizontal = space.gutter)) } + loadable( + "stations", + state.stations, + loading = { stringResource(R.string.loading_stations) }, + what = { stringResource(R.string.what_stations) }, + retry = state::loadWave, + ) { list -> + val others = list.filter { it.id != MY_WAVE } + if (others.isEmpty()) { + item(key = "no-stations") { Note(stringResource(R.string.stations_none)) } + } else { + item(key = "stations-row") { + LazyRow(horizontalArrangement = Arrangement.spacedBy(space.m), contentPadding = PaddingValues(horizontal = space.gutter)) { + items(others, key = { it.id }) { s -> + StationTile(s, playing = state.playback.state.waveStation == s.id) { state.playWave(s.id) } + } + } + } + } + } + } +} + +@OptIn(ExperimentalLayoutApi::class) +@Composable +private fun SettingRow(title: String, options: List>, saving: Boolean, pick: (WaveSettings) -> Unit) { + val space = MusyxTheme.space + Column(Modifier.padding(horizontal = space.gutter, vertical = space.xs), verticalArrangement = Arrangement.spacedBy(space.xs)) { + Text(title, style = MusyxTheme.type.bodyMedium, color = MusyxTheme.colors.muted) + FlowRow(horizontalArrangement = Arrangement.spacedBy(space.s)) { + options.forEach { (label, on, next) -> + FilterChip(selected = on, onClick = { if (!on && !saving) pick(next) }, label = { Text(label) }) + } + } + } +} + +@Composable +private fun StationTile(station: Station, playing: Boolean, onClick: () -> Unit) { + val c = MusyxTheme.colors + val tint = station.color?.let(::parseHex) ?: c.raised + val shape = RoundedCornerShape(MusyxTheme.radius.cover) + Column(Modifier.width(CardWidth).clickable(onClick = onClick), verticalArrangement = Arrangement.spacedBy(6.dp)) { + Box(Modifier.size(CardWidth).clip(shape).background(tint), contentAlignment = Alignment.Center) { + val icon = station.iconUrl(200) + if (icon != null) AsyncImage(model = icon, contentDescription = null, modifier = Modifier.size(80.dp)) + if (playing) PlayingBadge(Modifier.align(Alignment.TopStart).padding(8.dp)) + } + Row { Text(station.name, style = MusyxTheme.type.bodyMedium, color = c.fg, maxLines = 1, overflow = TextOverflow.Ellipsis) } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Library.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Library.kt new file mode 100644 index 0000000..9f91c32 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Library.kt @@ -0,0 +1,227 @@ +// Collection, the chart, genres and podcasts. +package it.panov.musyx.mobile.ui.screens + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.material3.AssistChip +import androidx.compose.material3.Button +import androidx.compose.material3.PrimaryScrollableTabRow +import androidx.compose.material3.Tab +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.components.CardGrid +import it.panov.musyx.mobile.ui.components.Failure +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Note +import it.panov.musyx.mobile.ui.components.PlayBar +import it.panov.musyx.mobile.ui.components.ScreenTitle +import it.panov.musyx.mobile.ui.components.trackItems +import it.panov.musyx.mobile.ui.durationWords +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.tracksWord +import it.panov.musyx.state.AppState +import it.panov.musyx.state.CollectionTab +import it.panov.musyx.state.Liked +import it.panov.musyx.state.Loadable +import it.panov.musyx.state.Route +import it.panov.musyx.state.Sheet + +private fun tabLabel(tab: CollectionTab) = when (tab) { + CollectionTab.Tracks -> R.string.tab_liked_tracks + CollectionTab.Albums -> R.string.tab_albums + CollectionTab.Artists -> R.string.tab_artists + CollectionTab.Playlists -> R.string.tab_playlists + CollectionTab.Clips -> R.string.tab_clips +} + +@Composable +fun CollectionScreen(state: AppState) { + PageColumn { + item(key = "title") { ScreenTitle(stringResource(R.string.nav_collection)) } + item(key = "tabs") { + val tabs = CollectionTab.entries + PrimaryScrollableTabRow(selectedTabIndex = tabs.indexOf(state.collectionTab), edgePadding = MusyxTheme.space.gutter) { + tabs.forEach { tab -> + val count = when (tab) { + CollectionTab.Tracks -> state.liked.tracks()?.size + CollectionTab.Albums -> state.albums.get()?.size + CollectionTab.Artists -> state.artists.get()?.size + CollectionTab.Playlists -> state.playlists.get()?.let { it.own.size + it.liked.size } + CollectionTab.Clips -> state.clips.get()?.size + } + val label = stringResource(tabLabel(tab)) + Tab( + selected = tab == state.collectionTab, + onClick = { state.selectTab(tab) }, + text = { Text(if (count != null) "$label $count" else label, maxLines = 1) }, + ) + } + } + } + when (state.collectionTab) { + CollectionTab.Tracks -> when (val liked = state.liked) { + Liked.NotLoaded, Liked.Loading -> item(key = "loading") { Note(stringResource(R.string.loading_liked)) } + is Liked.Failed -> item(key = "failed") { Failure(liked.error, stringResource(R.string.what_liked), state::loadLiked) } + is Liked.Loaded -> if (liked.tracks.isEmpty()) { + item(key = "empty") { Note(stringResource(R.string.empty_liked)) } + } else { + item(key = "play") { + PlayBar(state, liked.tracks, summary = "${tracksWord(liked.tracks.size)} · ${durationWords(liked.tracks.sumOf { it.durationMs })}") + } + trackItems(state, liked.tracks, keyPrefix = "liked", hearts = false) + } + } + CollectionTab.Albums -> loadable( + "albums", state.albums, + loading = { stringResource(R.string.loading_what, stringResource(R.string.what_albums)) }, + what = { stringResource(R.string.what_albums) }, + retry = { state.forceLoadTab(CollectionTab.Albums) }, + ) { albums -> + item(key = "grid") { + if (albums.isEmpty()) Note(stringResource(R.string.empty_albums)) + else CardGrid(albums.map { albumCard(state, it, heart = false) }) + } + } + CollectionTab.Artists -> loadable( + "artists", state.artists, + loading = { stringResource(R.string.loading_what, stringResource(R.string.what_artists)) }, + what = { stringResource(R.string.what_artists) }, + retry = { state.forceLoadTab(CollectionTab.Artists) }, + ) { artists -> + item(key = "grid") { + if (artists.isEmpty()) Note(stringResource(R.string.empty_artists)) + else CardGrid(artists.map { artistCard(state, it) }) + } + } + CollectionTab.Playlists -> loadable( + "playlists", state.playlists, + loading = { stringResource(R.string.loading_what, stringResource(R.string.what_playlists)) }, + what = { stringResource(R.string.what_playlists) }, + retry = { state.forceLoadTab(CollectionTab.Playlists) }, + ) { p -> + item(key = "new") { + Box(Modifier.padding(horizontal = MusyxTheme.space.gutter)) { + AssistChip( + onClick = { state.openSheet(Sheet.NewPlaylist(null)) }, + label = { Text(stringResource(R.string.action_new_playlist)) }, + leadingIcon = { MusyxIcon(R.drawable.ic_plus, size = 18.dp) }, + ) + } + } + if (p.own.isEmpty() && p.liked.isEmpty()) { + item(key = "empty") { Note(stringResource(R.string.empty_playlists)) } + } + if (p.own.isNotEmpty()) shelf("own", R.string.section_your_playlists, { p.own.map { playlistCard(state, it) } }) + if (p.liked.isNotEmpty()) { + gap("liked-gap") + shelf("liked", R.string.section_liked_playlists, { p.liked.map { playlistCard(state, it) } }) + } + } + CollectionTab.Clips -> loadable( + "clips", state.clips, + loading = { stringResource(R.string.loading_what, stringResource(R.string.what_clips)) }, + what = { stringResource(R.string.what_clips) }, + retry = { state.forceLoadTab(CollectionTab.Clips) }, + ) { clips -> + item(key = "grid") { + if (clips.isEmpty()) Note(stringResource(R.string.empty_clips)) + else CardGrid(clips.map { clipCard(state, it) }) + } + } + } + } +} + +@Composable +fun ChartScreen(state: AppState) { + PageColumn { + item(key = "title") { ScreenTitle(stringResource(R.string.section_chart)) } + loadable( + "chart", state.home, + loading = { stringResource(R.string.loading_chart) }, + what = { stringResource(R.string.what_chart) }, + retry = state::loadHome, + ) { home -> + if (home.chart.isEmpty()) { + item(key = "empty") { Note(stringResource(R.string.chart_empty)) } + return@loadable + } + val tracks = home.chart.map { it.track } + item(key = "play") { PlayBar(state, tracks, summary = stringResource(R.string.chart_blurb)) } + trackItems(state, tracks, shifts = home.chart.map { it.shift }, keyPrefix = "chart") + } + } +} + +@OptIn(ExperimentalLayoutApi::class) +@Composable +fun GenreScreen(state: AppState, index: Int) { + val space = MusyxTheme.space + val genres = state.genres.get().orEmpty() + val genre = genres.getOrNull(index) + PageColumn { + if (genre == null) { + // The list itself may still be on its way (after a language switch). + item(key = "gone") { Note(stringResource(if (state.genres.get() == null) R.string.loading_genres else R.string.genre_gone)) } + return@PageColumn + } + item(key = "title") { ScreenTitle(genre.title) } + item(key = "radio") { + Row(Modifier.fillMaxWidth().padding(horizontal = space.gutter), verticalAlignment = Alignment.CenterVertically) { + Button(onClick = { state.playWave("genre:${genre.id}") }) { + MusyxIcon(R.drawable.ic_audio_lines, tint = MusyxTheme.colors.accentInk, size = 18.dp) + Text(stringResource(R.string.action_play_radio), modifier = Modifier.padding(start = 8.dp)) + } + } + } + val subs = genre.subGenres.mapNotNull { s -> genres.indexOfFirst { it.id == s.id }.takeIf { it >= 0 }?.let { it to s } } + if (subs.isNotEmpty()) { + item(key = "subs") { + FlowRow(Modifier.padding(horizontal = space.gutter), horizontalArrangement = Arrangement.spacedBy(space.s)) { + subs.forEach { (i, s) -> AssistChip(onClick = { state.navigate(Route.Genre(i)) }, label = { Text(s.title) }) } + } + } + } + gap("playlists-gap") + val playlists = state.genrePlaylists[index] ?: Loadable.Loading + loadable( + "playlists", playlists, + loading = { stringResource(R.string.loading_playlists) }, + what = { stringResource(R.string.what_the_playlists) }, + retry = { state.loadGenre(index, force = true) }, + ) { list -> + if (list.isEmpty()) item(key = "empty") { Note(stringResource(R.string.genre_empty)) } + else item(key = "grid") { CardGrid(list.map { playlistCard(state, it) }) } + } + } +} + +@Composable +fun PodcastsScreen(state: AppState) { + PageColumn { + item(key = "title") { ScreenTitle(stringResource(R.string.podcasts_title)) } + val mine = state.albums.get()?.filter { it.isPodcast }.orEmpty() + if (mine.isNotEmpty()) { + shelf("yours", R.string.section_yours, { mine.map { albumCard(state, it, heart = false) } }) + gap("featured-gap") + } + loadable( + "featured", state.podcasts, + loading = { stringResource(R.string.loading_podcasts) }, + what = { stringResource(R.string.what_podcasts) }, + retry = state::loadPodcasts, + ) { list -> + item(key = "featured-grid") { CardGrid(list.map { albumCard(state, it) }) } + } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Player.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Player.kt new file mode 100644 index 0000000..9399232 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Player.kt @@ -0,0 +1,407 @@ +// Now Playing: the cover over a blurred copy of itself, what's playing, the seek bar and the +// transport. The queue and the lyrics take the cover's place on request. Also the mini player +// that sits above the navigation bar on every other screen. +package it.panov.musyx.mobile.ui.screens + +import android.os.Build +import androidx.activity.compose.BackHandler +import androidx.annotation.DrawableRes +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.aspectRatio +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.itemsIndexed +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.FilledIconButton +import androidx.compose.material3.IconButton +import androidx.compose.material3.IconButtonDefaults +import androidx.compose.material3.Slider +import androidx.compose.material3.SliderDefaults +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.blur +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.layout.ContentScale +import androidx.compose.ui.res.pluralStringResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import coil3.compose.AsyncImage +import it.panov.musyx.api.LyricsSource +import it.panov.musyx.api.Lyrics +import it.panov.musyx.api.Track +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.artistsOrUnknown +import it.panov.musyx.mobile.ui.clock +import it.panov.musyx.mobile.ui.components.COVER_LARGE +import it.panov.musyx.mobile.ui.components.COVER_SMALL +import it.panov.musyx.mobile.ui.components.Cover +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Thumb +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.mobile.ui.theme.tabular +import it.panov.musyx.player.Notice +import it.panov.musyx.player.PlaybackState +import it.panov.musyx.player.Repeat +import it.panov.musyx.player.Status +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Loadable +import it.panov.musyx.state.Route +import it.panov.musyx.state.Sheet + +/** Upcoming items listed at once; a long liked list would otherwise build thousands of rows. */ +private const val QUEUE_SHOWN = 100 + +@Composable +internal fun noticeText(notice: Notice): String = when (notice) { + Notice.StationDry -> stringResource(R.string.notice_station_dry) + Notice.TooManyFailures -> stringResource(R.string.notice_too_many) + is Notice.Skipped -> stringResource(R.string.notice_skipped, notice.title) +} + +private enum class Panel { Queue, Lyrics } + +@Composable +fun NowPlayingScreen(state: AppState, onClose: () -> Unit) { + val p = state.playback.state + val c = MusyxTheme.colors + val space = MusyxTheme.space + val track = p.track + var panel by rememberSaveable { mutableStateOf(null) } + BackHandler(enabled = panel != null) { panel = null } + + Box(Modifier.fillMaxSize().background(c.bg)) { + track?.let { Backdrop(it) } + Column(Modifier.fillMaxSize().padding(horizontal = space.gutter)) { + Row(Modifier.fillMaxWidth().padding(vertical = space.xs), verticalAlignment = Alignment.CenterVertically) { + IconButton(onClick = onClose) { MusyxIcon(R.drawable.ic_chevron_left) } + Spacer(Modifier.weight(1f)) + PanelToggle(R.drawable.ic_list_music, panel == Panel.Queue) { panel = if (panel == Panel.Queue) null else Panel.Queue } + PanelToggle(R.drawable.ic_mic_vocal, panel == Panel.Lyrics) { panel = if (panel == Panel.Lyrics) null else Panel.Lyrics } + } + if (track == null) { + Column(Modifier.weight(1f).padding(top = space.section), verticalArrangement = Arrangement.spacedBy(space.m)) { + Text(stringResource(R.string.nothing_playing), style = MusyxTheme.type.displayS, color = c.fg) + Text(p.notice?.let { noticeText(it) } ?: stringResource(R.string.pick_a_track), style = MusyxTheme.type.body, color = c.muted) + } + return@Column + } + Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { + when (panel) { + null -> Cover( + track.coverUrl(COVER_LARGE), + track.hues, + Modifier + .widthIn(max = 420.dp) + .fillMaxWidth() + .aspectRatio(1f) + .shadow(24.dp, RoundedCornerShape(MusyxTheme.radius.cover), clip = false), + RoundedCornerShape(MusyxTheme.radius.cover), + ) + Panel.Queue -> QueueList(state, p) + Panel.Lyrics -> LyricsPanel(state, track) + } + } + TrackInfo(state, p, track) + SeekBar(state, p) + Transport(state, p) + Spacer(Modifier.height(space.l)) + } + } +} + +/** The cover again, blurred across the whole screen and washed with the background. */ +@Composable +private fun Backdrop(track: Track) { + val c = MusyxTheme.colors + // Blur needs Android 12; before it the cover would show sharp, so it's washed out further. + val blurs = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S + AsyncImage( + model = track.coverUrl(COVER_LARGE), + contentDescription = null, + contentScale = ContentScale.Crop, + modifier = Modifier.fillMaxSize().then(if (blurs) Modifier.blur(80.dp) else Modifier), + ) + Box( + Modifier.fillMaxSize().background( + Brush.verticalGradient( + 0f to c.bg.copy(alpha = if (blurs) 0.55f else 0.9f), + 1f to c.bg.copy(alpha = if (blurs) 0.92f else 0.96f), + ), + ), + ) +} + +@Composable +private fun PanelToggle(@DrawableRes icon: Int, on: Boolean, onClick: () -> Unit) { + val c = MusyxTheme.colors + IconButton( + onClick = onClick, + colors = IconButtonDefaults.iconButtonColors(containerColor = if (on) c.raised else androidx.compose.ui.graphics.Color.Transparent), + ) { MusyxIcon(icon, tint = if (on) c.accent else c.fg) } +} + +/** Quality, title, artist and album, the notice when there is one, and the heart and menu. */ +@Composable +private fun TrackInfo(state: AppState, p: PlaybackState, track: Track) { + val c = MusyxTheme.colors + val liked = state.liked.contains(track.id) + Row(Modifier.fillMaxWidth().padding(top = MusyxTheme.space.l), verticalAlignment = Alignment.CenterVertically) { + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(4.dp)) { + p.stream?.let { s -> + Text( + if (s.preview) stringResource(R.string.badge_preview) else s.label, + style = MusyxTheme.type.small, + color = if (s.lossless) c.accent else c.muted, + modifier = Modifier + .border(1.dp, if (s.lossless) c.accent else c.line, RoundedCornerShape(4.dp)) + .padding(horizontal = 6.dp, vertical = 1.dp), + ) + } + Text(track.fullTitle, style = MusyxTheme.type.displayS, color = c.fg, maxLines = 2, overflow = TextOverflow.Ellipsis) + val artist = track.artists.firstOrNull { it.id != null } + Text( + track.artistsOrUnknown(), + style = MusyxTheme.type.body, + color = c.muted, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + modifier = if (artist != null) Modifier.clickable { state.navigate(Route.Artist(artist.id!!)) } else Modifier, + ) + val notice = p.notice + if (notice != null && (p.status == Status.Loading || p.status == Status.Paused)) { + Text(noticeText(notice), style = MusyxTheme.type.meta, color = c.like, maxLines = 2) + } + } + IconButton(onClick = { state.likeTrack(track, !liked) }) { + MusyxIcon(if (liked) R.drawable.ic_heart_fill else R.drawable.ic_heart, tint = if (liked) c.like else c.fg) + } + IconButton(onClick = { state.openSheet(Sheet.TrackMenu(track)) }) { MusyxIcon(R.drawable.ic_ellipsis) } + } +} + +/** Position and length around a slider; the track seeks when the thumb is let go. */ +@Composable +private fun SeekBar(state: AppState, p: PlaybackState) { + val c = MusyxTheme.colors + var dragging by remember { mutableStateOf(null) } + val position = state.playback.positionMs.coerceAtMost(p.durationMs) + val fraction = dragging ?: if (p.durationMs > 0) position.toFloat() / p.durationMs else 0f + Column(Modifier.fillMaxWidth().padding(top = MusyxTheme.space.s)) { + Slider( + value = fraction.coerceIn(0f, 1f), + onValueChange = { dragging = it }, + onValueChangeFinished = { + dragging?.let { state.playback.seek((it * p.durationMs).toLong()) } + dragging = null + }, + enabled = p.durationMs > 0, + colors = SliderDefaults.colors(thumbColor = c.accent, activeTrackColor = c.accent, inactiveTrackColor = c.fg.copy(alpha = 0.18f)), + ) + Row(Modifier.fillMaxWidth()) { + val shown = dragging?.let { (it * p.durationMs).toLong() } ?: position + Text(clock(shown), style = MusyxTheme.type.small.tabular(), color = c.muted) + Spacer(Modifier.weight(1f)) + Text(clock(p.durationMs), style = MusyxTheme.type.small.tabular(), color = c.muted) + } + } +} + +@Composable +private fun Transport(state: AppState, p: PlaybackState) { + val c = MusyxTheme.colors + val playback = state.playback + val playing = p.status == Status.Playing || p.status == Status.Loading + Row( + Modifier.fillMaxWidth().padding(top = MusyxTheme.space.s), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceEvenly, + ) { + // A station decides its own order. + Toggle(R.drawable.ic_shuffle, on = p.shuffle, onClick = playback::toggleShuffle, enabled = p.waveStation == null) + IconButton(onClick = playback::previous, modifier = Modifier.size(56.dp)) { MusyxIcon(R.drawable.ic_skip_back, size = 28.dp) } + FilledIconButton( + onClick = playback::toggle, + modifier = Modifier.size(72.dp), + colors = IconButtonDefaults.filledIconButtonColors(containerColor = c.accent, contentColor = c.accentInk), + ) { + MusyxIcon(if (playing) R.drawable.ic_pause_fill else R.drawable.ic_play_fill, tint = c.accentInk, size = 32.dp) + } + IconButton(onClick = playback::next, modifier = Modifier.size(56.dp)) { MusyxIcon(R.drawable.ic_skip_forward, size = 28.dp) } + Toggle(if (p.repeat == Repeat.One) R.drawable.ic_repeat_1 else R.drawable.ic_repeat, on = p.repeat != Repeat.Off, onClick = playback::cycleRepeat) + } +} + +/** Shuffle and repeat: amber with a dot under it when on, faded only when it can't be used. */ +@Composable +private fun Toggle(@DrawableRes icon: Int, on: Boolean, onClick: () -> Unit, enabled: Boolean = true) { + val c = MusyxTheme.colors + Box(contentAlignment = Alignment.BottomCenter) { + IconButton(onClick = onClick, enabled = enabled) { + MusyxIcon(icon, tint = if (!enabled) c.muted.copy(alpha = 0.5f) else if (on) c.accent else c.fg) + } + if (on && enabled) Box(Modifier.padding(bottom = 2.dp).size(4.dp).background(c.accent, CircleShape)) + } +} + +@Composable +private fun QueueList(state: AppState, p: PlaybackState) { + val track = p.track ?: return + LazyColumn(Modifier.fillMaxSize(), contentPadding = PaddingValues(vertical = 8.dp)) { + item(key = "now") { Heading(stringResource(R.string.queue_now)) } + item(key = "current") { QueueItem(track, now = true, onClick = null) } + item(key = "next-heading") { + val n = p.upcoming.size + Heading(if (n == 0) stringResource(R.string.queue_nothing_after) else stringResource(R.string.queue_next_up, n)) + } + itemsIndexed(p.upcoming.take(QUEUE_SHOWN), key = { _, (pos, t) -> "$pos:${t.id}" }) { _, (pos, t) -> + QueueItem(t, now = false, onClick = { state.playback.jumpTo(pos) }) + } + if (p.upcoming.size > QUEUE_SHOWN) { + item(key = "more") { Heading(pluralStringResource(R.plurals.queue_and_more, p.upcoming.size - QUEUE_SHOWN, p.upcoming.size - QUEUE_SHOWN)) } + } + } +} + +@Composable +private fun Heading(text: String) { + Text(text, style = MusyxTheme.type.small, color = MusyxTheme.colors.muted, modifier = Modifier.padding(top = 12.dp, bottom = 6.dp)) +} + +@Composable +private fun QueueItem(track: Track, now: Boolean, onClick: (() -> Unit)?) { + val c = MusyxTheme.colors + Row( + Modifier + .fillMaxWidth() + .then(if (onClick != null) Modifier.clickable(onClick = onClick) else Modifier) + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + Thumb(track.coverUrl(COVER_SMALL), track.hues, 40.dp) + Column(Modifier.weight(1f)) { + Text(track.fullTitle, style = MusyxTheme.type.bodyMedium, color = if (now) c.accent else c.fg, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text(track.artistsOrUnknown(), style = MusyxTheme.type.meta, color = c.muted, maxLines = 1, overflow = TextOverflow.Ellipsis) + } + Text(clock(track.durationMs), style = MusyxTheme.type.small.tabular(), color = c.muted) + } +} + +@Composable +private fun LyricsPanel(state: AppState, track: Track) { + val c = MusyxTheme.colors + LaunchedEffect(track.id) { state.wantLyrics(track) } + when (val l = state.lyrics[track.id] ?: Loadable.Loading) { + is Loadable.Loaded -> l.value?.let { LyricsList(state, it) } ?: PanelNote(stringResource(R.string.lyrics_none)) + is Loadable.Failed -> Column(verticalArrangement = Arrangement.spacedBy(12.dp), horizontalAlignment = Alignment.CenterHorizontally) { + Text(stringResource(R.string.lyrics_failed), style = MusyxTheme.type.meta, color = c.muted) + TextButton(onClick = { state.retryLyrics(track) }) { Text(stringResource(R.string.action_try_again)) } + } + else -> PanelNote(stringResource(R.string.lyrics_loading)) + } +} + +@Composable +private fun PanelNote(text: String) { + Text(text, style = MusyxTheme.type.body, color = MusyxTheme.colors.muted) +} + +/** Synced lyrics follow the song and seek on a tap; plain lyrics just scroll. */ +@Composable +private fun LyricsList(state: AppState, lyrics: Lyrics) { + val c = MusyxTheme.colors + val current = lyrics.current(state.playback.positionMs) + val list = rememberLazyListState() + LaunchedEffect(current) { if (current != null) list.animateScrollToItem((current - 2).coerceAtLeast(0)) } + LazyColumn(Modifier.fillMaxSize(), state = list, contentPadding = PaddingValues(vertical = 8.dp)) { + itemsIndexed(lyrics.lines) { i, line -> + val (color, style) = when { + current == i -> c.fg to MusyxTheme.type.section + current != null && i < current -> c.muted.copy(alpha = 0.6f) to MusyxTheme.type.body + lyrics.synced -> c.muted to MusyxTheme.type.body + else -> c.fg to MusyxTheme.type.body + } + val at = line.atMs + Text( + line.text.ifEmpty { "♪" }, + style = style, + color = color, + modifier = Modifier + .fillMaxWidth() + .then(if (at != null) Modifier.clickable { state.playback.seek(at) } else Modifier) + .padding(vertical = 6.dp), + ) + } + if (lyrics.writers.isNotEmpty()) { + item(key = "writers") { + Text(stringResource(R.string.lyrics_writers, lyrics.writers.joinToString(", ")), style = MusyxTheme.type.small, color = c.muted, modifier = Modifier.padding(top = 12.dp)) + } + } + if (lyrics.source == LyricsSource.Lrclib) { + item(key = "source") { + Text(stringResource(R.string.lyrics_source_lrclib), style = MusyxTheme.type.small, color = c.muted, modifier = Modifier.padding(top = 8.dp)) + } + } + } +} + +/** The bar above the navigation: what's playing, play/pause and next. A tap opens Now Playing. */ +@Composable +fun MiniPlayer(state: AppState) { + val p = state.playback.state + val track = p.track ?: return + val c = MusyxTheme.colors + val playing = p.status == Status.Playing || p.status == Status.Loading + val fraction = if (p.durationMs > 0) state.playback.positionMs.toFloat() / p.durationMs else 0f + Column(Modifier.fillMaxWidth().background(c.panel).clickable { state.navigate(Route.NowPlaying) }) { + Box(Modifier.fillMaxWidth().height(2.dp).background(c.raised)) { + Box(Modifier.fillMaxWidth(fraction.coerceIn(0f, 1f)).height(2.dp).background(c.accent)) + } + Row( + Modifier.padding(start = MusyxTheme.space.gutter, end = 4.dp, top = 6.dp, bottom = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + Thumb(track.coverUrl(COVER_SMALL), track.hues, 40.dp) + Column(Modifier.weight(1f)) { + Text(track.fullTitle, style = MusyxTheme.type.bodyMedium, color = c.fg, maxLines = 1, overflow = TextOverflow.Ellipsis) + val notice = p.notice?.takeIf { p.status == Status.Loading || p.status == Status.Paused } + Text( + notice?.let { noticeText(it) } ?: track.artistsOrUnknown(), + style = MusyxTheme.type.meta, + color = if (notice != null) c.like else c.muted, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + IconButton(onClick = state.playback::toggle) { MusyxIcon(if (playing) R.drawable.ic_pause_fill else R.drawable.ic_play_fill) } + IconButton(onClick = state.playback::next) { MusyxIcon(R.drawable.ic_skip_forward) } + } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Search.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Search.kt new file mode 100644 index 0000000..b2af786 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Search.kt @@ -0,0 +1,234 @@ +// Search: a field, suggestions while typing, results by kind, more on request. With no query +// it shows genres to browse. +package it.panov.musyx.mobile.ui.screens + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.KeyboardActions +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.material3.IconButton +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.PrimaryScrollableTabRow +import androidx.compose.material3.Tab +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalFocusManager +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import it.panov.musyx.api.BestMatch +import it.panov.musyx.api.SearchKind +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.artistsOrUnknown +import it.panov.musyx.mobile.ui.compact +import it.panov.musyx.mobile.ui.components.COVER_LARGE +import it.panov.musyx.mobile.ui.components.CardGrid +import it.panov.musyx.mobile.ui.components.Cover +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Note +import it.panov.musyx.mobile.ui.components.PlayBar +import it.panov.musyx.mobile.ui.components.ScreenTitle +import it.panov.musyx.mobile.ui.components.SectionTitle +import it.panov.musyx.mobile.ui.components.trackItems +import it.panov.musyx.mobile.ui.isRussian +import it.panov.musyx.mobile.ui.kindLabel +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.state.ALL_TAB_TRACKS +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Route + +fun searchKindLabel(kind: SearchKind) = when (kind) { + SearchKind.All -> R.string.search_all + SearchKind.Tracks -> R.string.search_tracks + SearchKind.Albums -> R.string.search_albums + SearchKind.Artists -> R.string.search_artists + SearchKind.Playlists -> R.string.search_playlists + SearchKind.Podcasts -> R.string.search_podcasts +} + +@Composable +fun SearchScreen(state: AppState) { + val search = state.search + val space = MusyxTheme.space + val focus = LocalFocusManager.current + PageColumn { + item(key = "field") { + OutlinedTextField( + value = search.text, + onValueChange = search::change, + placeholder = { Text(stringResource(R.string.search_placeholder)) }, + leadingIcon = { MusyxIcon(R.drawable.ic_search, tint = MusyxTheme.colors.muted) }, + trailingIcon = if (search.text.isNotEmpty()) ({ + IconButton(onClick = search::clear) { MusyxIcon(R.drawable.ic_x, tint = MusyxTheme.colors.muted) } + }) else null, + singleLine = true, + shape = RoundedCornerShape(MusyxTheme.radius.pill), + keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search), + keyboardActions = KeyboardActions(onSearch = { + focus.clearFocus() + search.submit() + }), + modifier = Modifier.fillMaxWidth().padding(horizontal = space.gutter), + ) + } + items(search.suggestions, key = { "s$it" }) { s -> + Row( + Modifier + .fillMaxWidth() + .clickable { + focus.clearFocus() + search.pick(s) + } + .padding(horizontal = space.gutter + 4.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + MusyxIcon(R.drawable.ic_search, tint = MusyxTheme.colors.muted, size = 18.dp) + Text(s, style = MusyxTheme.type.body, color = MusyxTheme.colors.fg) + } + } + if (search.query.isEmpty()) { + item(key = "browse") { ScreenTitle(stringResource(R.string.search_browse)) } + genreShelf(state, grid = true) + return@PageColumn + } + search.results.get()?.data?.corrected?.let { corrected -> + item(key = "corrected") { Note(stringResource(R.string.search_corrected, corrected)) } + } + item(key = "tabs") { + val russian = isRussian() + val kinds = SearchKind.entries + PrimaryScrollableTabRow(selectedTabIndex = kinds.indexOf(search.kind), edgePadding = space.gutter) { + kinds.forEach { kind -> + val total = search.results.get()?.data?.totals?.get(kind)?.takeIf { it > 0 } + val label = stringResource(searchKindLabel(kind)) + Tab( + selected = kind == search.kind, + onClick = { search.tab(kind) }, + text = { Text(if (total != null) "$label ${compact(total.toLong(), russian)}" else label, maxLines = 1) }, + ) + } + } + } + loadable( + "results", + search.results, + loading = { stringResource(R.string.searching) }, + what = { stringResource(R.string.what_results) }, + retry = search::retry, + ) { r -> + val d = r.data + if (d.isEmpty) { + item(key = "empty") { Note(stringResource(R.string.search_nothing, search.query)) } + return@loadable + } + when (search.kind) { + SearchKind.All -> { + d.best?.let { best -> item(key = "best") { BestCard(state, best) } } + if (d.tracks.isNotEmpty()) { + item(key = "tracks-title") { SectionTitle(stringResource(R.string.search_tracks), Modifier.padding(horizontal = space.gutter, vertical = space.xs)) } + trackItems(state, d.tracks.take(ALL_TAB_TRACKS), keyPrefix = "top") + item(key = "tracks-all") { + TextButton(onClick = { search.tab(SearchKind.Tracks) }, modifier = Modifier.padding(horizontal = space.s)) { + Text(stringResource(R.string.search_show_all_tracks)) + } + } + } + if (d.artists.isNotEmpty()) { + gap("artists-gap") + shelf("artists", R.string.search_artists, { d.artists.map { artistCard(state, it) } }) + } + if (d.albums.isNotEmpty()) { + gap("albums-gap") + shelf("albums", R.string.search_albums, { d.albums.map { albumCard(state, it) } }) + } + if (d.playlists.isNotEmpty()) { + gap("playlists-gap") + shelf("playlists", R.string.search_playlists, { d.playlists.map { playlistCard(state, it) } }) + } + if (d.podcasts.isNotEmpty()) { + gap("podcasts-gap") + shelf("podcasts", R.string.search_podcasts, { d.podcasts.map { albumCard(state, it) } }) + } + } + SearchKind.Tracks -> { + item(key = "play") { PlayBar(state, d.tracks) } + trackItems(state, d.tracks, keyPrefix = "all") + } + SearchKind.Albums -> item(key = "grid") { CardGrid(d.albums.map { albumCard(state, it) }) } + SearchKind.Artists -> item(key = "grid") { CardGrid(d.artists.map { artistCard(state, it) }) } + SearchKind.Playlists -> item(key = "grid") { CardGrid(d.playlists.map { playlistCard(state, it) }) } + SearchKind.Podcasts -> item(key = "grid") { CardGrid(d.podcasts.map { albumCard(state, it) }) } + } + if (search.hasMore(r)) { + item(key = "more") { + Box(Modifier.padding(horizontal = space.gutter, vertical = space.l)) { + OutlinedButton(onClick = search::more, enabled = !r.loadingMore) { + Text(stringResource(if (r.loadingMore) R.string.loading else R.string.action_show_more)) + } + } + } + } + } + } +} + +/** The top result as a wide card: cover, name, kind, and the action it implies. */ +@Composable +private fun BestCard(state: AppState, best: BestMatch) { + val c = MusyxTheme.colors + data class Shown(val cover: String?, val hues: Pair, val round: Boolean, val title: String, val kind: String, val go: () -> Unit) + val shown = when (best) { + is BestMatch.OfArtist -> Shown(best.artist.coverUrl(COVER_LARGE), best.artist.hues, true, best.artist.name, stringResource(R.string.kind_artist)) { + state.navigate(Route.Artist(best.artist.id)) + } + is BestMatch.OfAlbum -> Shown( + best.album.coverUrl(COVER_LARGE), best.album.hues, false, best.album.fullTitle, + listOfNotNull(kindLabel(best.album.kind), best.album.artistLine).joinToString(" · "), + ) { state.navigate(Route.Album(best.album.id)) } + is BestMatch.OfPlaylist -> Shown( + best.playlist.coverUrl(COVER_LARGE), best.playlist.hues, false, best.playlist.title, + stringResource(R.string.kind_playlist_by, best.playlist.ownerName), + ) { state.navigate(Route.Playlist(best.playlist.id)) } + is BestMatch.OfTrack -> Shown( + best.track.coverUrl(COVER_LARGE), best.track.hues, false, best.track.fullTitle, + stringResource(R.string.kind_track_by, best.track.artistsOrUnknown()), + ) { state.playTracks(listOf(best.track), 0) } + } + val shape = RoundedCornerShape(MusyxTheme.radius.card) + Row( + Modifier + .padding(horizontal = MusyxTheme.space.gutter) + .fillMaxWidth() + .clip(shape) + .background(c.panel) + .clickable(onClick = shown.go) + .padding(14.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(14.dp), + ) { + Cover(shown.cover, shown.hues, Modifier.size(80.dp), if (shown.round) CircleShape else RoundedCornerShape(MusyxTheme.radius.cover)) + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { + Text(stringResource(R.string.search_top_result), style = MusyxTheme.type.small, color = c.muted) + Text(shown.title, style = MusyxTheme.type.section, color = c.fg, maxLines = 2, overflow = TextOverflow.Ellipsis) + Text(shown.kind, style = MusyxTheme.type.meta, color = c.muted, maxLines = 1, overflow = TextOverflow.Ellipsis) + } + MusyxIcon(if (best is BestMatch.OfTrack) R.drawable.ic_play_fill else R.drawable.ic_chevron_right, tint = c.accent) + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/SessionScreens.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/SessionScreens.kt new file mode 100644 index 0000000..5d45a87 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/SessionScreens.kt @@ -0,0 +1,205 @@ +// The full-screen states outside a session: checking, unreachable, and sign-in. On the phone +// the device code is confirmed in the browser right here, so there's no QR to scan. +package it.panov.musyx.mobile.ui.screens + +import android.content.ActivityNotFoundException +import android.content.ClipData +import android.content.Intent +import android.os.SystemClock +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.systemBarsPadding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.KeyboardActions +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Button +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.produceState +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.ClipEntry +import androidx.compose.ui.platform.LocalClipboard +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.input.ImeAction +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.text.input.PasswordVisualTransformation +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.em +import androidx.core.net.toUri +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.Wordmark +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.text +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.state.AppState +import it.panov.musyx.state.SignInState +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +/** Shown while the stored session is checked or a new one connects. */ +@Composable +fun HoldingScreen(label: String) { + Column(Modifier.fillMaxSize(), verticalArrangement = Arrangement.Center, horizontalAlignment = Alignment.CenterHorizontally) { + Wordmark() + Spacer(Modifier.height(MusyxTheme.space.l)) + Text(label, style = MusyxTheme.type.body, color = MusyxTheme.colors.muted) + } +} + +/** Stored credentials exist but Yandex can't be reached. */ +@Composable +fun UnreachableScreen(state: AppState) { + Column( + Modifier.fillMaxSize().padding(horizontal = MusyxTheme.space.gutter * 2), + verticalArrangement = Arrangement.spacedBy(MusyxTheme.space.l, Alignment.CenterVertically), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Wordmark() + Text(stringResource(R.string.unreachable_title), style = MusyxTheme.type.displayS, color = MusyxTheme.colors.fg, textAlign = TextAlign.Center) + Text(stringResource(R.string.unreachable_body), style = MusyxTheme.type.body, color = MusyxTheme.colors.muted, textAlign = TextAlign.Center) + Row(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.m)) { + Button(onClick = state::restore) { Text(stringResource(R.string.action_try_again)) } + OutlinedButton(onClick = state::signOut) { Text(stringResource(R.string.action_sign_out)) } + } + } +} + +@Composable +fun SignInScreen(signIn: SignInState) { + val c = MusyxTheme.colors + val space = MusyxTheme.space + Column( + Modifier + .fillMaxSize() + .systemBarsPadding() + .imePadding() + .verticalScroll(rememberScrollState()) + .padding(horizontal = space.gutter + 8.dp, vertical = space.section), + verticalArrangement = Arrangement.spacedBy(space.l), + ) { + Wordmark() + Spacer(Modifier.height(space.s)) + Text(stringResource(R.string.signin_title), style = MusyxTheme.type.displayM, color = c.fg) + Text(stringResource(R.string.signin_blurb), style = MusyxTheme.type.body, color = c.muted) + when (val stage = signIn.stage) { + SignInState.Stage.Idle -> Button(onClick = signIn::getCode, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.signin_get_code)) + } + SignInState.Stage.Requesting -> Button(onClick = {}, enabled = false, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.signin_getting_code)) + } + is SignInState.Stage.Waiting -> CodeCard(signIn, stage) + } + signIn.error?.let { Text(text(it), style = MusyxTheme.type.meta, color = c.like) } + if (signIn.stage !is SignInState.Stage.Waiting) TokenFallback(signIn) + Text(stringResource(R.string.signin_footer), style = MusyxTheme.type.small, color = c.muted) + } +} + +/** The code, a button that opens Yandex's page for it, and the time left. */ +@Composable +private fun CodeCard(signIn: SignInState, stage: SignInState.Stage.Waiting) { + val c = MusyxTheme.colors + val context = LocalContext.current + val clipboard = LocalClipboard.current + val scope = rememberCoroutineScope() + val code = stage.code + val remaining by produceState(stage.deadline - SystemClock.elapsedRealtime(), stage) { + while (true) { + value = (stage.deadline - SystemClock.elapsedRealtime()).coerceAtLeast(0) + delay(1_000) + } + } + val shape = RoundedCornerShape(MusyxTheme.radius.card) + Column( + Modifier.fillMaxWidth().background(c.panel, shape).border(1.dp, c.line, shape).padding(20.dp), + verticalArrangement = Arrangement.spacedBy(MusyxTheme.space.m), + ) { + Text(stringResource(R.string.signin_step_code), style = MusyxTheme.type.bodyMedium, color = c.fg) + Row(verticalAlignment = Alignment.CenterVertically) { + // Shown exactly as it must be typed: a space or capital here ends up on Yandex's page. + Text( + code.userCode, + style = MusyxTheme.type.displayS.copy(letterSpacing = 0.12.em), + color = c.fg, + maxLines = 1, + modifier = Modifier.weight(1f), + ) + TextButton(onClick = { scope.launch { clipboard.setClipEntry(ClipEntry(ClipData.newPlainText("code", code.userCode))) } }) { + MusyxIcon(R.drawable.ic_copy, size = 18.dp) + Text(stringResource(R.string.action_copy), modifier = Modifier.padding(start = 6.dp)) + } + } + Button( + onClick = { + // The code goes to the clipboard on the way, ready to paste on Yandex's page. + scope.launch { clipboard.setClipEntry(ClipEntry(ClipData.newPlainText("code", code.userCode))) } + try { + context.startActivity(Intent(Intent.ACTION_VIEW, code.verificationUrl.toUri())) + } catch (_: ActivityNotFoundException) { + } + }, + modifier = Modifier.fillMaxWidth(), + ) { Text(stringResource(R.string.signin_open_page)) } + Text(stringResource(R.string.signin_phone_hint), style = MusyxTheme.type.small, color = c.muted) + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + Box(Modifier.size(8.dp).background(c.accent, CircleShape)) + val secs = remaining / 1000 + Text( + stringResource(R.string.signin_waiting, "%d:%02d".format(secs / 60, secs % 60)), + style = MusyxTheme.type.meta, + color = c.muted, + modifier = Modifier.weight(1f), + ) + TextButton(onClick = signIn::cancel) { Text(stringResource(R.string.action_cancel)) } + } + } +} + +/** Sign-in with a token someone already has. */ +@Composable +private fun TokenFallback(signIn: SignInState) { + Column(verticalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + TextButton(onClick = signIn::toggleToken) { + Text(stringResource(if (signIn.tokenOpen) R.string.signin_token_hide else R.string.signin_token_show), color = MusyxTheme.colors.muted) + } + if (signIn.tokenOpen) { + OutlinedTextField( + value = signIn.token, + onValueChange = { signIn.token = it }, + placeholder = { Text(stringResource(R.string.signin_token_placeholder)) }, + singleLine = true, + visualTransformation = PasswordVisualTransformation(), + keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password, imeAction = ImeAction.Done), + keyboardActions = KeyboardActions(onDone = { signIn.useToken() }), + modifier = Modifier.fillMaxWidth(), + ) + Button(onClick = signIn::useToken, enabled = signIn.token.isNotBlank(), modifier = Modifier.width(160.dp)) { + Text(stringResource(R.string.action_sign_in)) + } + } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Settings.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Settings.kt new file mode 100644 index 0000000..abe8299 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Settings.kt @@ -0,0 +1,176 @@ +// Settings: account, streaming quality, appearance, font size, language, storage. +package it.panov.musyx.mobile.ui.screens + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.CircleShape +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.FilterChip +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import it.panov.musyx.data.Appearance +import it.panov.musyx.data.FontSize +import it.panov.musyx.data.Locale +import it.panov.musyx.data.Quality +import it.panov.musyx.mobile.BuildConfig +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.ScreenTitle +import it.panov.musyx.mobile.ui.humanDate +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.state.AppState +import it.panov.musyx.state.qualityLabel + +private fun qualityDetail(q: Quality) = when (q) { + Quality.Lossless -> R.string.quality_lossless_detail + Quality.Best -> R.string.quality_best_detail + Quality.Balanced -> R.string.quality_balanced_detail + Quality.DataSaver -> R.string.quality_data_saver_detail +} + +private fun appearanceLabel(a: Appearance) = when (a) { + Appearance.System -> R.string.match_system + Appearance.Light -> R.string.appearance_light + Appearance.Dark -> R.string.appearance_dark +} + +private fun fontSizeLabel(f: FontSize) = when (f) { + FontSize.Small -> R.string.font_size_small + FontSize.Medium -> R.string.font_size_medium + FontSize.Large -> R.string.font_size_large +} + +@OptIn(ExperimentalLayoutApi::class) +@Composable +fun SettingsScreen(state: AppState) { + val settings = state.settings + PageColumn { + item(key = "title") { ScreenTitle(stringResource(R.string.nav_settings)) } + item(key = "account") { AccountCard(state) } + item(key = "quality") { + Section(stringResource(R.string.settings_quality)) { + FlowRow(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + Quality.entries.forEach { q -> + FilterChip(selected = q == settings.quality, onClick = { if (q != settings.quality) state.setQuality(q) }, label = { Text(stringResource(qualityLabel(q))) }) + } + } + Text(stringResource(qualityDetail(settings.quality)), style = MusyxTheme.type.meta, color = MusyxTheme.colors.muted) + } + } + item(key = "appearance") { + Section(stringResource(R.string.settings_appearance)) { + FlowRow(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + Appearance.entries.forEach { a -> + FilterChip(selected = a == settings.appearance, onClick = { state.setAppearance(a) }, label = { Text(stringResource(appearanceLabel(a))) }) + } + } + } + } + item(key = "font-size") { + Section(stringResource(R.string.settings_font_size)) { + FlowRow(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + FontSize.entries.forEach { f -> + FilterChip(selected = f == settings.fontSize, onClick = { state.setFontSize(f) }, label = { Text(stringResource(fontSizeLabel(f))) }) + } + } + } + } + item(key = "language") { + Section(stringResource(R.string.settings_language)) { + FlowRow(horizontalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + Locale.entries.forEach { l -> + // Language names stay in their own language so they can be found in either. + val label = when (l) { + Locale.System -> stringResource(R.string.match_system) + Locale.English -> "English" + Locale.Russian -> "Русский" + } + FilterChip(selected = l == settings.language, onClick = { if (l != settings.language) state.setLanguage(l) }, label = { Text(label) }) + } + } + } + } + item(key = "storage") { + Section(stringResource(R.string.settings_storage)) { + Text(stringResource(R.string.settings_storage_detail), style = MusyxTheme.type.meta, color = MusyxTheme.colors.muted) + OutlinedButton(onClick = state::clearCoverCache) { + MusyxIcon(R.drawable.ic_trash_2, size = 18.dp) + Text(stringResource(R.string.action_clear_covers), modifier = Modifier.padding(start = 8.dp)) + } + } + } + item(key = "version") { + Text( + stringResource(R.string.settings_version, BuildConfig.VERSION_NAME), + style = MusyxTheme.type.small, + color = MusyxTheme.colors.muted, + modifier = Modifier.padding(horizontal = MusyxTheme.space.gutter, vertical = MusyxTheme.space.l), + ) + } + } +} + +@Composable +private fun Section(title: String, content: @Composable () -> Unit) { + val space = MusyxTheme.space + Column( + Modifier + .padding(horizontal = space.gutter, vertical = space.xs) + .fillMaxWidth() + .background(MusyxTheme.colors.panel, RoundedCornerShape(MusyxTheme.radius.card)) + .padding(18.dp), + verticalArrangement = Arrangement.spacedBy(space.m), + ) { + Text(title, style = MusyxTheme.type.section, color = MusyxTheme.colors.fg) + content() + } +} + +@Composable +private fun AccountCard(state: AppState) { + val me = state.account ?: return + val c = MusyxTheme.colors + val space = MusyxTheme.space + val end = me.subscriptionEnd?.let { humanDate(it) } + val plan = when { + me.hasPlus && end != null -> stringResource(R.string.plus_until, end) + me.hasPlus -> stringResource(R.string.plus) + else -> stringResource(R.string.plus_none) + } + Column( + Modifier + .padding(horizontal = space.gutter, vertical = space.xs) + .fillMaxWidth() + .background(c.panel, RoundedCornerShape(MusyxTheme.radius.card)) + .padding(18.dp), + verticalArrangement = Arrangement.spacedBy(space.m), + ) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp)) { + Box(Modifier.size(52.dp).background(c.accent, CircleShape), contentAlignment = Alignment.Center) { + Text(me.initial, style = MusyxTheme.type.section, color = c.accentInk) + } + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(2.dp)) { + Text(me.name, style = MusyxTheme.type.section, color = c.fg) + Text(me.login, style = MusyxTheme.type.meta, color = c.muted) + } + } + Text(plan, style = MusyxTheme.type.meta, color = if (me.hasPlus) c.ok else c.muted) + OutlinedButton(onClick = state::signOut) { + MusyxIcon(R.drawable.ic_log_out, size = 18.dp) + Text(stringResource(R.string.action_sign_out), modifier = Modifier.padding(start = 8.dp)) + } + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Sheets.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Sheets.kt new file mode 100644 index 0000000..8a0f6e4 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/screens/Sheets.kt @@ -0,0 +1,237 @@ +// The track menu as a bottom sheet, the playlist dialogs, and the toast that floats above the +// bottom of the screen after an action. +package it.panov.musyx.mobile.ui.screens + +import androidx.annotation.DrawableRes +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.LazyListScope +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import it.panov.musyx.mobile.R +import it.panov.musyx.mobile.ui.artistsOrUnknown +import it.panov.musyx.mobile.ui.components.COVER_SMALL +import it.panov.musyx.mobile.ui.components.MusyxIcon +import it.panov.musyx.mobile.ui.components.Thumb +import it.panov.musyx.mobile.ui.text +import it.panov.musyx.mobile.ui.theme.MusyxTheme +import it.panov.musyx.state.AppState +import it.panov.musyx.state.Route +import it.panov.musyx.state.Sheet +import kotlinx.coroutines.delay + +/** How long a status message stays up. */ +private const val TOAST_MS = 4_000L + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun SheetHost(state: AppState) { + when (val sheet = state.sheet ?: return) { + is Sheet.TrackMenu -> ModalBottomSheet(onDismissRequest = state::closeSheet, containerColor = MusyxTheme.colors.panel) { + if (sheet.choosing) ChoosePlaylist(state, sheet) else TrackMenu(state, sheet) + } + is Sheet.NewPlaylist -> NameDialog( + title = stringResource(R.string.sheet_new_playlist), + initial = "", + hint = stringResource(if (sheet.add != null) R.string.sheet_new_hint_track else R.string.sheet_new_hint), + confirm = stringResource(R.string.action_create), + onCancel = state::closeSheet, + ) { state.createPlaylist(it, sheet.add) } + is Sheet.Rename -> NameDialog( + title = stringResource(R.string.sheet_rename_playlist), + initial = sheet.name, + hint = null, + confirm = stringResource(R.string.action_rename), + onCancel = state::closeSheet, + ) { state.renamePlaylist(sheet.id, it) } + is Sheet.ConfirmDelete -> AlertDialog( + onDismissRequest = state::closeSheet, + title = { Text(stringResource(R.string.sheet_delete_title, sheet.title)) }, + text = { Text(stringResource(R.string.sheet_delete_body)) }, + confirmButton = { + TextButton(onClick = { state.deletePlaylist(sheet.id) }) { Text(stringResource(R.string.action_delete), color = MusyxTheme.colors.like) } + }, + dismissButton = { TextButton(onClick = state::closeSheet) { Text(stringResource(R.string.action_cancel)) } }, + containerColor = MusyxTheme.colors.panel, + ) + } +} + +/** The sheet's head: the track's cover, title and artist. */ +@Composable +private fun Head(title: String, subtitle: String?, cover: (@Composable () -> Unit)? = null) { + Row( + Modifier.fillMaxWidth().padding(horizontal = MusyxTheme.space.gutter, vertical = MusyxTheme.space.s), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + cover?.invoke() + Column(Modifier.weight(1f)) { + Text(title, style = MusyxTheme.type.section, color = MusyxTheme.colors.fg, maxLines = 2, overflow = TextOverflow.Ellipsis) + if (subtitle != null) Text(subtitle, style = MusyxTheme.type.meta, color = MusyxTheme.colors.muted, maxLines = 1) + } + } +} + +@Composable +private fun Actions(content: LazyListScope.() -> Unit) { + LazyColumn(contentPadding = PaddingValues(bottom = MusyxTheme.space.l), content = content) +} + +@Composable +private fun Item(@DrawableRes icon: Int, label: String, onClick: () -> Unit) { + Row( + Modifier.fillMaxWidth().clickable(onClick = onClick).padding(horizontal = MusyxTheme.space.gutter + 4.dp, vertical = 14.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(16.dp), + ) { + MusyxIcon(icon, tint = MusyxTheme.colors.muted, size = 20.dp) + Text(label, style = MusyxTheme.type.bodyMedium, color = MusyxTheme.colors.fg, maxLines = 1, overflow = TextOverflow.Ellipsis) + } +} + +@Composable +private fun TrackMenu(state: AppState, sheet: Sheet.TrackMenu) { + val track = sheet.track + val playing = state.playback.state.track?.id == track.id + val liked = state.liked.contains(track.id) + val disliked = track.id in state.likes.dislikedTracks + // Where the menu was opened: no "go to" for the page already showing. + val here = state.nav.current + Head(track.fullTitle, track.artistsOrUnknown().ifEmpty { null }) { Thumb(track.coverUrl(COVER_SMALL), track.hues, 48.dp) } + HorizontalDivider(color = MusyxTheme.colors.line) + Actions { + item { + if (playing) Item(R.drawable.ic_skip_forward, stringResource(R.string.menu_next_track), state::skipFromMenu) + else Item(R.drawable.ic_skip_forward, stringResource(R.string.menu_play_next)) { state.playNext(track) } + } + item { Item(R.drawable.ic_list_music, stringResource(R.string.menu_add_to_queue)) { state.addToQueue(track) } } + item { + Item(if (liked) R.drawable.ic_heart_fill else R.drawable.ic_heart, stringResource(if (liked) R.string.menu_unlike else R.string.menu_like)) { + state.closeSheet() + state.likeTrack(track, !liked) + } + } + item { Item(R.drawable.ic_plus, stringResource(R.string.menu_add_to_playlist)) { state.openSheet(sheet.copy(choosing = true)) } } + // Similar tracks and recommendations are about music; an episode or a chapter has neither. + if (!track.spoken) { + item { Item(R.drawable.ic_audio_lines, stringResource(R.string.menu_play_similar)) { state.playSimilar(track) } } + } + track.album?.takeIf { here != Route.Album(it.id) }?.let { album -> + item { Item(R.drawable.ic_disc_3, stringResource(R.string.menu_go_to_album)) { state.navigate(Route.Album(album.id)) } } + } + track.artists.filter { a -> a.id?.let { here != Route.Artist(it) } == true }.take(3).forEach { artist -> + item { Item(R.drawable.ic_mic_vocal, stringResource(R.string.menu_go_to_artist_named, artist.name)) { state.navigate(Route.Artist(artist.id!!)) } } + } + if (!track.spoken) { + item { + Item(R.drawable.ic_ban, stringResource(if (disliked) R.string.menu_undislike else R.string.menu_dislike)) { + state.dislikeTrack(track, !disliked) + } + } + } + sheet.playlist?.let { slot -> + item { HorizontalDivider(Modifier.padding(vertical = 6.dp), color = MusyxTheme.colors.line) } + slot.up?.let { up -> + item { Item(R.drawable.ic_chevron_left, stringResource(R.string.menu_move_up)) { state.movePlaylistTrack(slot.id, track, slot.index, up) } } + } + // Delete-then-insert: the row below shifts up one, so inserting at its old index lands after it. + slot.down?.let { down -> + item { Item(R.drawable.ic_chevron_right, stringResource(R.string.menu_move_down)) { state.movePlaylistTrack(slot.id, track, slot.index, down) } } + } + item { Item(R.drawable.ic_trash_2, stringResource(R.string.menu_remove_from_playlist)) { state.removeFromPlaylist(slot.id, slot.index) } } + } + } +} + +@Composable +private fun ChoosePlaylist(state: AppState, sheet: Sheet.TrackMenu) { + val own = state.playlists.get()?.own.orEmpty() + Head(stringResource(R.string.sheet_add_to_playlist), sheet.track.fullTitle) + HorizontalDivider(color = MusyxTheme.colors.line) + Actions { + item { Item(R.drawable.ic_plus, stringResource(R.string.menu_new_playlist)) { state.openSheet(Sheet.NewPlaylist(sheet.track)) } } + own.forEach { p -> + item(key = p.id.key) { Item(R.drawable.ic_list_music, p.title) { state.addToPlaylist(p.id, sheet.track) } } + } + } +} + +@Composable +private fun NameDialog(title: String, initial: String, hint: String?, confirm: String, onCancel: () -> Unit, onConfirm: (String) -> Unit) { + var name by remember { mutableStateOf(initial) } + val focus = remember { FocusRequester() } + LaunchedEffect(Unit) { + delay(50) + runCatching { focus.requestFocus() } + } + AlertDialog( + onDismissRequest = onCancel, + title = { Text(title) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(MusyxTheme.space.s)) { + OutlinedTextField( + value = name, + onValueChange = { name = it }, + placeholder = { Text(stringResource(R.string.sheet_playlist_name)) }, + singleLine = true, + modifier = Modifier.fillMaxWidth().focusRequester(focus), + ) + if (hint != null) Text(hint, style = MusyxTheme.type.meta, color = MusyxTheme.colors.muted) + } + }, + confirmButton = { TextButton(onClick = { onConfirm(name) }, enabled = name.isNotBlank()) { Text(confirm) } }, + dismissButton = { TextButton(onClick = onCancel) { Text(stringResource(R.string.action_cancel)) } }, + containerColor = MusyxTheme.colors.panel, + ) +} + +/** The status line that floats above the bottom of the screen after an action. */ +@Composable +fun ToastHost(state: AppState, modifier: Modifier = Modifier) { + val toast = state.toast ?: return + LaunchedEffect(toast.serial) { + delay(TOAST_MS) + state.dismissToast(toast.serial) + } + val c = MusyxTheme.colors + Box(modifier.fillMaxSize().padding(16.dp), contentAlignment = Alignment.BottomCenter) { + Text( + text(toast.text), + style = MusyxTheme.type.bodyMedium, + color = c.bg, + modifier = Modifier + .background(c.fg, RoundedCornerShape(MusyxTheme.radius.pill)) + .clickable { state.dismissToast(toast.serial) } + .padding(horizontal = 20.dp, vertical = 10.dp), + ) + } +} diff --git a/mobile/src/main/java/it/panov/musyx/mobile/ui/theme/Theme.kt b/mobile/src/main/java/it/panov/musyx/mobile/ui/theme/Theme.kt new file mode 100644 index 0000000..3b78072 --- /dev/null +++ b/mobile/src/main/java/it/panov/musyx/mobile/ui/theme/Theme.kt @@ -0,0 +1,308 @@ +// Design tokens and the Compose theme for the phone. The colours and type roles are DESIGN.md's, +// as in the TV app's Theme.kt and the desktop's theme.rs; change them together. +package it.panov.musyx.mobile.ui.theme + +import android.content.res.Configuration +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.ColorScheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Shapes +import androidx.compose.material3.Typography +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.Immutable +import androidx.compose.runtime.ReadOnlyComposable +import androidx.compose.runtime.remember +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalConfiguration +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.Font +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.em +import androidx.compose.ui.unit.sp +import it.panov.musyx.mobile.R +import kotlin.math.abs + +// ---- Colour ---- + +@Immutable +data class MusyxColors( + val bg: Color, + val panel: Color, + val raised: Color, + val line: Color, + val fg: Color, + val muted: Color, + val accent: Color, + val accentInk: Color, + val like: Color, + val ok: Color, + val isDark: Boolean, +) + +val DarkColors = MusyxColors( + bg = Color(0xFF1C1A22), + panel = Color(0xFF23202B), + raised = Color(0xFF2D2937), + line = Color(0xFF3A3546), + fg = Color(0xFFEEEAF3), + muted = Color(0xFFA39CB0), + accent = Color(0xFFF0B23E), + accentInk = Color(0xFF2A1D04), + like = Color(0xFFF27286), + ok = Color(0xFF7FCB9B), + isDark = true, +) + +/** Porcelain: cool greys, near-black ink and a petrol accent. */ +val LightColors = MusyxColors( + bg = Color(0xFFF1F2F5), + panel = Color(0xFFFFFFFF), + raised = Color(0xFFE5E7EC), + line = Color(0xFFD5D8DF), + fg = Color(0xFF1B1C22), + muted = Color(0xFF5C606C), + accent = Color(0xFF1F5F7A), + accentInk = Color(0xFFF2F8FA), + like = Color(0xFFB5304B), + ok = Color(0xFF24704A), + isDark = false, +) + +/** Dark-first: light only when the system explicitly asks for it. Matches `values-notnight`. */ +@Composable +@ReadOnlyComposable +fun isMusyxDark(): Boolean = + LocalConfiguration.current.uiMode and Configuration.UI_MODE_NIGHT_MASK != Configuration.UI_MODE_NIGHT_NO + +private fun MusyxColors.toColorScheme(): ColorScheme = + (if (isDark) darkColorScheme() else lightColorScheme()).copy( + primary = accent, + onPrimary = accentInk, + primaryContainer = raised, + onPrimaryContainer = fg, + secondary = muted, + onSecondary = bg, + secondaryContainer = raised, + onSecondaryContainer = fg, + tertiary = ok, + onTertiary = bg, + background = bg, + onBackground = fg, + surface = bg, + onSurface = fg, + surfaceVariant = raised, + onSurfaceVariant = muted, + surfaceTint = Color.Transparent, + surfaceContainerLowest = bg, + surfaceContainerLow = panel, + surfaceContainer = panel, + surfaceContainerHigh = panel, + surfaceContainerHighest = raised, + inverseSurface = fg, + inverseOnSurface = bg, + error = like, + onError = accentInk, + outline = line, + outlineVariant = line, + ) + +// ---- Type ---- + +val Onest = FontFamily( + Font(R.font.onest_regular, FontWeight.Normal), + Font(R.font.onest_medium, FontWeight.Medium), + Font(R.font.onest_semibold, FontWeight.SemiBold), +) + +val Unbounded = FontFamily(Font(R.font.unbounded_semibold, FontWeight.SemiBold)) + +/** The type roles of DESIGN.md. Desktop sizes read about right on a phone at the medium font size. */ +@Immutable +data class MusyxType( + val displayXl: TextStyle, + val displayL: TextStyle, + val displayM: TextStyle, + val displayS: TextStyle, + val wordmark: TextStyle, + val section: TextStyle, + val body: TextStyle, + val bodyMedium: TextStyle, + val meta: TextStyle, + val small: TextStyle, + val scale: Float, +) + +private fun display(scale: Float, size: Float, lineHeight: Float, tracking: Float) = TextStyle( + fontFamily = Unbounded, + fontWeight = FontWeight.SemiBold, + fontSize = (size * scale).sp, + lineHeight = lineHeight.em, + letterSpacing = tracking.em, +) + +private fun onest(scale: Float, size: Float, weight: FontWeight = FontWeight.Normal) = TextStyle( + fontFamily = Onest, + fontWeight = weight, + fontSize = (size * scale).sp, + lineHeight = 1.45.em, +) + +/** Display sizes are trimmed for the phone's width; text sizes are the desktop's. */ +fun musyxType(scale: Float) = MusyxType( + displayXl = display(scale, 34f, 1.05f, -0.02f), + displayL = display(scale, 26f, 1.1f, -0.02f), + displayM = display(scale, 24f, 1.08f, -0.02f), + displayS = display(scale, 22f, 1.15f, -0.015f), + wordmark = display(scale, 20f, 1f, -0.01f), + section = onest(scale, 18f, FontWeight.SemiBold).copy(lineHeight = 1.2.em, letterSpacing = (-0.005).em), + body = onest(scale, 15f), + bodyMedium = onest(scale, 15f, FontWeight.Medium), + meta = onest(scale, 13f), + small = onest(scale, 12f), + scale = scale, +) + +fun TextStyle.tabular(): TextStyle = copy(fontFeatureSettings = "tnum") + +private fun MusyxType.toTypography() = Typography( + displayLarge = displayXl, + displayMedium = displayL, + displaySmall = displayM, + headlineLarge = displayS, + headlineMedium = wordmark, + headlineSmall = section, + titleLarge = section, + titleMedium = bodyMedium, + titleSmall = bodyMedium, + bodyLarge = body, + bodyMedium = body, + bodySmall = meta, + labelLarge = bodyMedium, + labelMedium = meta, + labelSmall = small, +) + +// ---- Space and shape ---- + +@Immutable +data class MusyxSpacing( + val xxs: Dp = 2.dp, + val xs: Dp = 4.dp, + val s: Dp = 8.dp, + val m: Dp = 12.dp, + val l: Dp = 18.dp, + val xl: Dp = 22.dp, + /** Left and right page margin. */ + val gutter: Dp = 16.dp, + /** Gap between sections. */ + val section: Dp = 28.dp, +) + +@Immutable +data class MusyxRadius( + val cover: Dp = 10.dp, + val control: Dp = 8.dp, + val smallCover: Dp = 6.dp, + val pill: Dp = 999.dp, + val hero: Dp = 16.dp, + val card: Dp = 14.dp, +) + +private fun MusyxRadius.toShapes() = Shapes( + extraSmall = RoundedCornerShape(smallCover), + small = RoundedCornerShape(control), + medium = RoundedCornerShape(cover), + large = RoundedCornerShape(card), + extraLarge = RoundedCornerShape(hero), +) + +// ---- Cover placeholder ---- + +/** Placeholder art for an item without a cover yet: two hues on a 135° diagonal. */ +fun coverBrush(h1: Float, h2: Float): Brush = Brush.linearGradient( + 0f to hsl(h1, 0.70f, 0.60f), + 0.55f to hsl((h1 + h2) / 2f, 0.45f, 0.30f), + 1f to hsl(h2, 0.40f, 0.16f), + start = Offset.Zero, + end = Offset.Infinite, +) + +@Composable +fun CoverPlaceholder(hues: Pair, modifier: Modifier = Modifier) { + Box(modifier.background(coverBrush(hues.first, hues.second))) +} + +internal fun hsl(h: Float, s: Float, l: Float): Color { + val c = (1f - abs(2f * l - 1f)) * s + val hp = h.mod(360f) / 60f + val x = c * (1f - abs(hp % 2f - 1f)) + val (r, g, b) = when (hp.toInt()) { + 0 -> Triple(c, x, 0f) + 1 -> Triple(x, c, 0f) + 2 -> Triple(0f, c, x) + 3 -> Triple(0f, x, c) + 4 -> Triple(x, 0f, c) + else -> Triple(c, 0f, x) + } + val m = l - c / 2f + return Color(r + m, g + m, b + m) +} + +/** Linear blend of two colours; `amount` is the share of `b`. */ +fun mix(a: Color, b: Color, amount: Float): Color = Color( + red = a.red + (b.red - a.red) * amount, + green = a.green + (b.green - a.green) * amount, + blue = a.blue + (b.blue - a.blue) * amount, + alpha = a.alpha + (b.alpha - a.alpha) * amount, +) + +// ---- Theme ---- + +val LocalMusyxColors = staticCompositionLocalOf { DarkColors } +val LocalMusyxType = staticCompositionLocalOf { musyxType(1f) } +val LocalMusyxSpacing = staticCompositionLocalOf { MusyxSpacing() } +val LocalMusyxRadius = staticCompositionLocalOf { MusyxRadius() } + +/** Material 3 built from the tokens, with the tokens themselves through [MusyxTheme]. */ +@Composable +fun MusyxTheme(dark: Boolean = isMusyxDark(), typeScale: Float = 1f, content: @Composable () -> Unit) { + val colors = if (dark) DarkColors else LightColors + val type = remember(typeScale) { musyxType(typeScale) } + val radius = MusyxRadius() + CompositionLocalProvider( + LocalMusyxColors provides colors, + LocalMusyxType provides type, + LocalMusyxSpacing provides MusyxSpacing(), + LocalMusyxRadius provides radius, + ) { + MaterialTheme( + colorScheme = colors.toColorScheme(), + shapes = radius.toShapes(), + typography = type.toTypography(), + content = content, + ) + } +} + +object MusyxTheme { + val colors: MusyxColors + @Composable @ReadOnlyComposable get() = LocalMusyxColors.current + val type: MusyxType + @Composable @ReadOnlyComposable get() = LocalMusyxType.current + val space: MusyxSpacing + @Composable @ReadOnlyComposable get() = LocalMusyxSpacing.current + val radius: MusyxRadius + @Composable @ReadOnlyComposable get() = LocalMusyxRadius.current +} diff --git a/mobile/src/main/res/drawable/ic_audio_lines.xml b/mobile/src/main/res/drawable/ic_audio_lines.xml new file mode 100644 index 0000000..ca5e6cd --- /dev/null +++ b/mobile/src/main/res/drawable/ic_audio_lines.xml @@ -0,0 +1,44 @@ + + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_ban.xml b/mobile/src/main/res/drawable/ic_ban.xml new file mode 100644 index 0000000..5765099 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_ban.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_check.xml b/mobile/src/main/res/drawable/ic_check.xml new file mode 100644 index 0000000..ee2c0f2 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_check.xml @@ -0,0 +1,14 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_chevron_left.xml b/mobile/src/main/res/drawable/ic_chevron_left.xml new file mode 100644 index 0000000..d4e839b --- /dev/null +++ b/mobile/src/main/res/drawable/ic_chevron_left.xml @@ -0,0 +1,14 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_chevron_right.xml b/mobile/src/main/res/drawable/ic_chevron_right.xml new file mode 100644 index 0000000..a499100 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_chevron_right.xml @@ -0,0 +1,14 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_clock_3.xml b/mobile/src/main/res/drawable/ic_clock_3.xml new file mode 100644 index 0000000..9fbf73f --- /dev/null +++ b/mobile/src/main/res/drawable/ic_clock_3.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_copy.xml b/mobile/src/main/res/drawable/ic_copy.xml new file mode 100644 index 0000000..db20574 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_copy.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_disc_3.xml b/mobile/src/main/res/drawable/ic_disc_3.xml new file mode 100644 index 0000000..3598abc --- /dev/null +++ b/mobile/src/main/res/drawable/ic_disc_3.xml @@ -0,0 +1,32 @@ + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_ellipsis.xml b/mobile/src/main/res/drawable/ic_ellipsis.xml new file mode 100644 index 0000000..a73675a --- /dev/null +++ b/mobile/src/main/res/drawable/ic_ellipsis.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_globe.xml b/mobile/src/main/res/drawable/ic_globe.xml new file mode 100644 index 0000000..64416b1 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_globe.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_grip_vertical.xml b/mobile/src/main/res/drawable/ic_grip_vertical.xml new file mode 100644 index 0000000..5745587 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_grip_vertical.xml @@ -0,0 +1,44 @@ + + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_heart.xml b/mobile/src/main/res/drawable/ic_heart.xml new file mode 100644 index 0000000..d1b7be8 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_heart.xml @@ -0,0 +1,14 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_heart_fill.xml b/mobile/src/main/res/drawable/ic_heart_fill.xml new file mode 100644 index 0000000..b766b24 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_heart_fill.xml @@ -0,0 +1,15 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_house.xml b/mobile/src/main/res/drawable/ic_house.xml new file mode 100644 index 0000000..eb6a476 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_house.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_library.xml b/mobile/src/main/res/drawable/ic_library.xml new file mode 100644 index 0000000..ee28bf8 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_library.xml @@ -0,0 +1,32 @@ + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_list_music.xml b/mobile/src/main/res/drawable/ic_list_music.xml new file mode 100644 index 0000000..306b3b6 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_list_music.xml @@ -0,0 +1,38 @@ + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_lock.xml b/mobile/src/main/res/drawable/ic_lock.xml new file mode 100644 index 0000000..1c595ee --- /dev/null +++ b/mobile/src/main/res/drawable/ic_lock.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_log_out.xml b/mobile/src/main/res/drawable/ic_log_out.xml new file mode 100644 index 0000000..d9de18d --- /dev/null +++ b/mobile/src/main/res/drawable/ic_log_out.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_mic_vocal.xml b/mobile/src/main/res/drawable/ic_mic_vocal.xml new file mode 100644 index 0000000..c960071 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_mic_vocal.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_pause.xml b/mobile/src/main/res/drawable/ic_pause.xml new file mode 100644 index 0000000..a907b18 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_pause.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_pause_fill.xml b/mobile/src/main/res/drawable/ic_pause_fill.xml new file mode 100644 index 0000000..95afe43 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_pause_fill.xml @@ -0,0 +1,22 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_pencil.xml b/mobile/src/main/res/drawable/ic_pencil.xml new file mode 100644 index 0000000..847c43f --- /dev/null +++ b/mobile/src/main/res/drawable/ic_pencil.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_play.xml b/mobile/src/main/res/drawable/ic_play.xml new file mode 100644 index 0000000..99560c9 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_play.xml @@ -0,0 +1,14 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_play_fill.xml b/mobile/src/main/res/drawable/ic_play_fill.xml new file mode 100644 index 0000000..45545fc --- /dev/null +++ b/mobile/src/main/res/drawable/ic_play_fill.xml @@ -0,0 +1,15 @@ + + + + + diff --git a/mobile/src/main/res/drawable/ic_plus.xml b/mobile/src/main/res/drawable/ic_plus.xml new file mode 100644 index 0000000..ef345aa --- /dev/null +++ b/mobile/src/main/res/drawable/ic_plus.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_podcast.xml b/mobile/src/main/res/drawable/ic_podcast.xml new file mode 100644 index 0000000..77e33cb --- /dev/null +++ b/mobile/src/main/res/drawable/ic_podcast.xml @@ -0,0 +1,32 @@ + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_repeat.xml b/mobile/src/main/res/drawable/ic_repeat.xml new file mode 100644 index 0000000..c45d05a --- /dev/null +++ b/mobile/src/main/res/drawable/ic_repeat.xml @@ -0,0 +1,32 @@ + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_repeat_1.xml b/mobile/src/main/res/drawable/ic_repeat_1.xml new file mode 100644 index 0000000..6742a85 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_repeat_1.xml @@ -0,0 +1,38 @@ + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_search.xml b/mobile/src/main/res/drawable/ic_search.xml new file mode 100644 index 0000000..291375d --- /dev/null +++ b/mobile/src/main/res/drawable/ic_search.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_settings.xml b/mobile/src/main/res/drawable/ic_settings.xml new file mode 100644 index 0000000..de09c5c --- /dev/null +++ b/mobile/src/main/res/drawable/ic_settings.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_shuffle.xml b/mobile/src/main/res/drawable/ic_shuffle.xml new file mode 100644 index 0000000..5374549 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_shuffle.xml @@ -0,0 +1,38 @@ + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_skip_back.xml b/mobile/src/main/res/drawable/ic_skip_back.xml new file mode 100644 index 0000000..fed7d98 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_skip_back.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_skip_forward.xml b/mobile/src/main/res/drawable/ic_skip_forward.xml new file mode 100644 index 0000000..a9c4ec6 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_skip_forward.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_sliders_horizontal.xml b/mobile/src/main/res/drawable/ic_sliders_horizontal.xml new file mode 100644 index 0000000..db7abab --- /dev/null +++ b/mobile/src/main/res/drawable/ic_sliders_horizontal.xml @@ -0,0 +1,62 @@ + + + + + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_trash_2.xml b/mobile/src/main/res/drawable/ic_trash_2.xml new file mode 100644 index 0000000..8d88f08 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_trash_2.xml @@ -0,0 +1,38 @@ + + + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_trending_up.xml b/mobile/src/main/res/drawable/ic_trending_up.xml new file mode 100644 index 0000000..012fe0c --- /dev/null +++ b/mobile/src/main/res/drawable/ic_trending_up.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/drawable/ic_volume_2.xml b/mobile/src/main/res/drawable/ic_volume_2.xml new file mode 100644 index 0000000..6bb1c0d --- /dev/null +++ b/mobile/src/main/res/drawable/ic_volume_2.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_volume_x.xml b/mobile/src/main/res/drawable/ic_volume_x.xml new file mode 100644 index 0000000..99fe04a --- /dev/null +++ b/mobile/src/main/res/drawable/ic_volume_x.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/mobile/src/main/res/drawable/ic_x.xml b/mobile/src/main/res/drawable/ic_x.xml new file mode 100644 index 0000000..303db65 --- /dev/null +++ b/mobile/src/main/res/drawable/ic_x.xml @@ -0,0 +1,20 @@ + + + + + + diff --git a/mobile/src/main/res/font/onest_medium.ttf b/mobile/src/main/res/font/onest_medium.ttf new file mode 100644 index 0000000000000000000000000000000000000000..bf4d81d571352bd212a9d655eb81f0d407048fd3 GIT binary patch literal 90544 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≥@xTn;N?oNHr87$xmDZGQD7~We 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 literal 0 HcmV?d00001 diff --git a/mobile/src/main/res/font/onest_regular.ttf b/mobile/src/main/res/font/onest_regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..c5d829987f7b50f1fd026578ef8c7d9f133ce1cb GIT binary patch literal 90296 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 literal 0 HcmV?d00001 diff --git a/mobile/src/main/res/font/onest_semibold.ttf b/mobile/src/main/res/font/onest_semibold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..25c2dc5505789e7c9c3b860870e98c39cecc8fb3 GIT binary patch literal 90568 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
6i2?dIdh3 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 literal 0 HcmV?d00001 diff --git a/mobile/src/main/res/mipmap-hdpi/ic_launcher.png b/mobile/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..da5798770796f384bff215c9f92f377ea4b35a66 GIT binary patch literal 6278 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 literal 0 HcmV?d00001 diff --git a/mobile/src/main/res/mipmap-mdpi/ic_launcher.png b/mobile/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..3e3d14fe2282e2cbcd71bc854ed25b9e34f78f9b GIT binary patch literal 3405 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 E9}vJ$2><{9 literal 0 HcmV?d00001 diff --git a/mobile/src/main/res/values-notnight/colors.xml b/mobile/src/main/res/values-notnight/colors.xml new file mode 100644 index 0000000..4327d57 --- /dev/null +++ b/mobile/src/main/res/values-notnight/colors.xml @@ -0,0 +1,4 @@ + + + #F1F2F5 + diff --git a/mobile/src/main/res/values-ru/strings.xml b/mobile/src/main/res/values-ru/strings.xml new file mode 100644 index 0000000..1c05d69 --- /dev/null +++ b/mobile/src/main/res/values-ru/strings.xml @@ -0,0 +1,246 @@ + + + + ru + Главная + Моя волна + Поиск + Коллекция + Подкасты + Настройки + Неизвестный исполнитель + Проверяем вход… + Входим… + Яндекс Музыка недоступна + Вы по-прежнему в аккаунте. Проверьте подключение к интернету и попробуйте ещё раз. + Войдите с аккаунтом Яндекса + Musyx играет вашу коллекцию Яндекс Музыки, Мою волну и плейлисты. Вход подтверждается на странице самого Яндекса, поэтому пароль никогда не проходит через это приложение. + Musyx — неофициальный клиент, не связанный с Яндексом. Токен входа хранится на этом устройстве в зашифрованном виде. + Получить код для входа + Получаем код… + Введите этот код + Ждём подтверждения · код действует ещё %1$s + Войти с готовым токеном + Скрыть вход по токену + Вставьте OAuth-токен + Слушать + Вперемешку + Пауза + Продолжить + Повторить + Отмена + Войти + Выйти + Показать все %1$d + Показать ещё + Включить радио + Переименовать + Сделать закрытым + Сделать открытым + Удалить + Создать + Новый плейлист… + Очистить кеш обложек + Вы недавно слушали + Собрано для вас + Чарт + Новые релизы + Новые плейлисты + Жанры + Станции + Ваши плейлисты + Понравившиеся плейлисты + Популярные треки + Участвует в + Похожие исполнители + Ваши + Самые популярные треки Яндекс Музыки сегодня + Чарт сейчас пуст. + Этот жанр больше недоступен. + В этом жанре пока нет плейлистов. + Подкасты и книги + Загрузка… + Загружаем %1$s… + Не удалось загрузить %1$s. Проверьте подключение и попробуйте ещё раз. + Не удалось загрузить %1$s. Попробуйте чуть позже. + Подбираем музыку для вас… + Загружаем чарт… + Загружаем жанры… + Загружаем подкасты… + Загружаем плейлисты… + Загружаем ваши любимые треки… + Загружаем альбом… + Загружаем исполнителя… + Загружаем плейлист… + Загружаем настройки… + Загружаем станции… + главную страницу + чарт + жанры + подкасты + станции + настройки волны + ваши альбомы + ваших исполнителей + ваши плейлисты + ваши клипы + ваши любимые треки + альбом + исполнителя + плейлист + плейлисты + результаты + Мне нравится + Альбомы + Исполнители + Плейлисты + Клипы + Любимых треков пока нет. Нажмите на сердечко у любого трека, и он появится здесь. + Понравившихся альбомов пока нет. Отметьте альбом сердечком, и он появится здесь. + Понравившихся исполнителей пока нет. Отметьте исполнителя сердечком, и он появится здесь. + Плейлистов пока нет. Здесь появятся ваши плейлисты и те, что вам понравились. + Понравившихся клипов пока нет. Отметьте клип на странице исполнителя, и он появится здесь. + Альбом + Сингл + Сборник + Подкаст + Аудиокнига + Исполнитель + Исполнитель · %1$s + Плейлист · %1$s + Трек · %1$s + Открытый + Закрытый + Этого альбома больше нет в Яндекс Музыке. + Этого исполнителя больше нет в Яндекс Музыке. + Этого плейлиста больше нет в Яндекс Музыке. + В этом плейлисте пока пусто. + Исполнители, треки, подкасты + Обзор + Всё + Треки + Все треки + Альбомы + Исполнители + Плейлисты + Подкасты + По запросу «%1$s» ничего не нашлось. Проверьте написание или сократите запрос. + Показаны результаты по запросу «%1$s» + Лучшее совпадение + Ищем… + Слушать Мою волну + Бесконечный поток музыки, который подстраивается под то, что вы слушаете, лайкаете и пропускаете. + Настроено: настроение — %1$s, характер — %2$s, язык — %3$s. + Настроение + Характер + Язык + Не важно + Бодрое + Весёлое + Спокойное + Грустное + Любимое + Незнакомое + Популярное + Русский + Иностранный + Других станций сейчас не предлагается. + Качество звука + FLAC, если Яндекс даёт его для вашей подписки и региона, иначе лучшее из доступного. Трафика в 3–5 раз больше, чем у MP3, и треки дольше запускаются. + Самый высокий битрейт MP3, который даёт Яндекс, до 320 кбит/с. + До 192 кбит/с. Примерно на 40% меньше трафика. + До 128 кбит/с, для медленного или платного интернета. + Оформление + Как в системе + Светлое + Тёмное + Размер шрифта + Мелкий + Средний + Крупный + Язык + Хранилище + Обложки хранятся на диске, чтобы страницы открывались мгновенно. Очистка освободит место, а обложки снова загрузятся по мере просмотра. + Musyx %1$s · неофициальный клиент Яндекс Музыки + Яндекс Плюс + Яндекс Плюс до %1$s + Нет подписки Плюс. Треки играют фрагментами по 30 секунд. + Ничего не играет + Выберите трек + Фрагмент + Сейчас играет + Дальше ничего нет + Далее · %1$d + Текст этого трека не найден. + Не удалось загрузить текст. Проверьте подключение и попробуйте ещё раз. + Загружаем текст… + Авторы: %1$s + Текст из LRCLIB + Не удалось загрузить продолжение станции. Проверьте подключение и попробуйте ещё раз. + Несколько треков подряд не удалось воспроизвести. Проверьте подключение и попробуйте ещё раз. + Не удалось воспроизвести «%1$s», трек пропущен. + Следующий трек + Играть следующим + Добавить в очередь + Добавить в «Мне нравится» + Убрать из «Мне нравится» + Добавить в плейлист… + Слушать похожие + Перейти к альбому + Перейти: %1$s + Не рекомендовать этот трек + Снова рекомендовать этот трек + Переместить выше + Переместить ниже + Удалить из этого плейлиста + Новый плейлист… + Добавить в плейлист + Новый плейлист + Переименовать плейлист + Название плейлиста + Трек добавится, как только плейлист будет создан. + Его видите только вы, пока не сделаете его открытым. + Удалить «%1$s»? + Плейлист и порядок треков удалятся навсегда. Сами треки останутся в Яндекс Музыке. + На этом телевизоре нет браузера, чтобы открыть клип. + %1$d мин + %1$d ч %2$d мин + + и ещё %1$d + и ещё %1$d + и ещё %1$d + и ещё %1$d + + + %1$d трек + %1$d трека + %1$d треков + %1$d трека + + + %1$s слушатель в месяц + %1$s слушателя в месяц + %1$s слушателей в месяц + %1$s слушателя в месяц + + + %1$s лайк + %1$s лайка + %1$s лайков + %1$s лайка + + + января + февраля + марта + апреля + мая + июня + июля + августа + сентября + октября + ноября + декабря + + diff --git a/mobile/src/main/res/values-ru/strings_phone.xml b/mobile/src/main/res/values-ru/strings_phone.xml new file mode 100644 index 0000000..7d9abc0 --- /dev/null +++ b/mobile/src/main/res/values-ru/strings_phone.xml @@ -0,0 +1,7 @@ + + + Скопировать + Открыть страницу входа Яндекса + Код копируется, когда открывается страница. Вставьте его там, подтвердите вход и вернитесь сюда — дальше всё произойдёт само. + Войдите в Musyx, чтобы ваша музыка появилась здесь. + diff --git a/mobile/src/main/res/values/colors.xml b/mobile/src/main/res/values/colors.xml new file mode 100644 index 0000000..7bdc3d6 --- /dev/null +++ b/mobile/src/main/res/values/colors.xml @@ -0,0 +1,5 @@ + + + + #1C1A22 + diff --git a/mobile/src/main/res/values/strings.xml b/mobile/src/main/res/values/strings.xml new file mode 100644 index 0000000..fda4fc6 --- /dev/null +++ b/mobile/src/main/res/values/strings.xml @@ -0,0 +1,239 @@ + + + + Musyx + en + Home + My Wave + Search + Collection + Podcasts + Settings + Unknown artist + Checking your sign-in… + Signing in… + Can\'t reach Yandex Music + You\'re still signed in. Check your internet connection, then try again. + Sign in with your Yandex account + Musyx plays your Yandex Music library, My Wave and playlists. You confirm sign-in on Yandex\'s own page, so your password never passes through this app. + Musyx is an unofficial client and isn\'t affiliated with Yandex. Your sign-in token is kept encrypted on this device. + Get sign-in code + Getting a code… + Enter this code + Waiting for confirmation · code expires in %1$s + Sign in with an existing token instead + Hide token sign-in + Paste OAuth token + Play + Shuffle + Pause + Resume + Try again + Cancel + Sign in + Sign out + Show all %1$d + Show more + Play radio + Rename + Make private + Make public + Delete + Create + New playlist… + Clear cover cache + Recently played + Made for you + Chart + New releases + New playlists + Genres + Stations + Your playlists + Liked playlists + Popular tracks + Appears on + Similar artists + Yours + The most played tracks on Yandex Music today + The chart is empty right now. + This genre isn\'t available any more. + No playlists in this genre yet. + Podcasts and books + Loading… + Loading %1$s… + Couldn\'t load %1$s. Check your connection and try again. + Couldn\'t load %1$s. Try again in a moment. + Loading your picks… + Loading the chart… + Loading genres… + Loading podcasts… + Loading playlists… + Loading your liked tracks… + Loading the album… + Loading the artist… + Loading the playlist… + Loading your settings… + Loading stations… + your home page + the chart + genres + podcasts + stations + your station settings + your albums + your artists + your playlists + your clips + your liked tracks + the album + the artist + the playlist + the playlists + the results + Liked tracks + Albums + Artists + Playlists + Clips + No liked tracks yet. Select the heart on any track and it lands here. + No liked albums yet. Like an album and it lands here. + No liked artists yet. Like an artist and they land here. + No playlists yet. Playlists you make or like show up here. + No liked clips yet. Like a clip on an artist\'s page and it lands here. + Album + Single + Compilation + Podcast + Audiobook + Artist + Artist · %1$s + Playlist · %1$s + Track · %1$s + Public + Private + This album isn\'t available on Yandex Music any more. + This artist isn\'t available on Yandex Music any more. + This playlist isn\'t available on Yandex Music any more. + This playlist is empty. + Search artists, tracks, podcasts + Browse + All + Tracks + Show all tracks + Albums + Artists + Playlists + Podcasts + Nothing found for “%1$s”. Check the spelling or try fewer words. + Showing results for “%1$s” + Top result + Searching… + Play My Wave + An endless stream picked from what you play, like and skip. + Tuned to: %1$s mood, %2$s tracks, %3$s language. + Mood + Character + Language + Any + Energetic + Cheerful + Calm + Sad + Favourite + Unfamiliar + Popular + Russian + Foreign + No other stations suggested right now. + Streaming quality + FLAC when Yandex offers it for your subscription and region, otherwise the best it allows. About 3–5 times the data of MP3, and tracks take longer to start. + Highest MP3 bitrate Yandex offers, up to 320 kbps. + Up to 192 kbps. About 40% less data. + Up to 128 kbps, for slow or metered connections. + Appearance + Match system + Light + Dark + Font size + Small + Medium + Large + Language + Storage + Covers are kept on disk so pages open instantly next time. Clearing them frees the space; they download again as you browse. + Musyx %1$s · unofficial Yandex Music client + Yandex Plus + Yandex Plus until %1$s + No Plus subscription. Tracks play as 30-second previews. + Nothing playing + Pick a track to start + Preview + Now playing + Nothing after this + Next up · %1$d + No lyrics found for this track. + Couldn\'t load the lyrics. Check your connection and try again. + Loading lyrics… + Written by %1$s + Lyrics from LRCLIB + Couldn\'t load more of this station. Check your connection and try again. + Several tracks in a row couldn\'t be played. Check your connection and try again. + Couldn\'t play “%1$s”, so it was skipped. + Next track + Play next + Add to queue + Add to Liked tracks + Remove from Liked tracks + Add to playlist… + Play similar tracks + Go to album + Go to %1$s + Don\'t recommend this track + Recommend this track again + Move up + Move down + Remove from this playlist + New playlist… + Add to playlist + New playlist + Rename playlist + Playlist name + The track goes in once it\'s created. + Only you can see it until you make it public. + Delete “%1$s”? + The playlist and its track order go away for good. The tracks stay in Yandex Music. + There\'s no browser on this TV to play clips in. + %1$d min + %1$d h %2$d min + + and %1$d more + and %1$d more + + + %1$d track + %1$d tracks + + + %1$s listener a month + %1$s listeners a month + + + %1$s like + %1$s likes + + + January + February + March + April + May + June + July + August + September + October + November + December + + diff --git a/mobile/src/main/res/values/strings_phone.xml b/mobile/src/main/res/values/strings_phone.xml new file mode 100644 index 0000000..c07949c --- /dev/null +++ b/mobile/src/main/res/values/strings_phone.xml @@ -0,0 +1,9 @@ + + + + Copy + Open Yandex\'s sign-in page + Opening the page copies the code. Paste it there, confirm, and come back: sign-in finishes on its own. + + Sign in to Musyx to see your music here. + diff --git a/mobile/src/main/res/values/themes.xml b/mobile/src/main/res/values/themes.xml new file mode 100644 index 0000000..9ac6b60 --- /dev/null +++ b/mobile/src/main/res/values/themes.xml @@ -0,0 +1,8 @@ + + + + + diff --git a/mobile/src/main/res/xml/automotive_app_desc.xml b/mobile/src/main/res/xml/automotive_app_desc.xml new file mode 100644 index 0000000..0dc9407 --- /dev/null +++ b/mobile/src/main/res/xml/automotive_app_desc.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/mobile/src/main/res/xml/backup_rules.xml b/mobile/src/main/res/xml/backup_rules.xml new file mode 100644 index 0000000..e082e78 --- /dev/null +++ b/mobile/src/main/res/xml/backup_rules.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/mobile/src/main/res/xml/data_extraction_rules.xml b/mobile/src/main/res/xml/data_extraction_rules.xml new file mode 100644 index 0000000..f34e78e --- /dev/null +++ b/mobile/src/main/res/xml/data_extraction_rules.xml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + diff --git a/settings.gradle.kts b/settings.gradle.kts index 0bfb773..0c7eb12 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -21,4 +21,4 @@ dependencyResolutionManagement { } rootProject.name = "musyx-mobile" -include(":core", ":tv") +include(":core", ":tv", ":mobile")