From 8c131cd7d960367c53b79c0854ff2e266e53f75a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 14:40:55 +0530 Subject: [PATCH 01/10] feat(lyrics): add lyrics share card generation and export feature --- CHANGELOG.md | 5 + .../app/ui/player/ModernLyricsView.kt | 85 ++++ .../com/lastwave/app/ui/player/PlayerHost.kt | 1 + .../ui/player/lyricsshare/ArtworkResolver.kt | 134 ++++++ .../player/lyricsshare/ColorContrastHelper.kt | 183 +++++++ .../ui/player/lyricsshare/LyricsSnapshot.kt | 163 +++++++ .../player/lyricsshare/SelectLyricsScreen.kt | 253 ++++++++++ .../player/lyricsshare/ShareCardRenderer.kt | 454 ++++++++++++++++++ .../ui/player/lyricsshare/ShareCardSpec.kt | 25 + .../player/lyricsshare/ShareLyricsDialog.kt | 172 +++++++ .../player/lyricsshare/SharePreviewScreen.kt | 443 +++++++++++++++++ .../com/lastwave/app/util/FileExportHelper.kt | 137 ++++++ .../res/drawable/ic_lastwave_logo_mono.xml | 18 + app/src/main/res/values-ar/strings.xml | 29 ++ app/src/main/res/values-de/strings.xml | 29 ++ app/src/main/res/values-es/strings.xml | 29 ++ app/src/main/res/values-fr/strings.xml | 29 ++ app/src/main/res/values-hi/strings.xml | 29 ++ app/src/main/res/values-in/strings.xml | 29 ++ app/src/main/res/values-ja/strings.xml | 29 ++ app/src/main/res/values-ko/strings.xml | 29 ++ app/src/main/res/values-pt-rBR/strings.xml | 29 ++ app/src/main/res/values-ru/strings.xml | 29 ++ app/src/main/res/values-tr/strings.xml | 29 ++ app/src/main/res/values-zh-rCN/strings.xml | 29 ++ app/src/main/res/values/strings.xml | 29 ++ .../lyricsshare/ArtworkResolutionOrderTest.kt | 83 ++++ .../ui/player/lyricsshare/CacheHygieneTest.kt | 75 +++ .../lyricsshare/ColorContrastHelperTest.kt | 124 +++++ .../player/lyricsshare/LyricsSelectionTest.kt | 167 +++++++ .../player/lyricsshare/ShareCardMathTest.kt | 73 +++ .../lyricsshare/ShareCardRendererTest.kt | 151 ++++++ .../ui/player/lyricsshare/ShareIntentTest.kt | 88 ++++ 33 files changed, 3211 insertions(+) create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolver.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/LyricsSnapshot.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareLyricsDialog.kt create mode 100644 app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt create mode 100644 app/src/main/res/drawable/ic_lastwave_logo_mono.xml create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolutionOrderTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/CacheHygieneTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/LyricsSelectionTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt create mode 100644 app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareIntentTest.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index b12a82633c..d7f2e02b70 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,10 @@ # Changelog +## [Unreleased] + +### Added +- **Lyrics Share:** Export and share styled lyric cards (Song and Lyrics modes) with dynamic palette extraction, customizable color swatches, full multilingual support (Latin, Devanagari, Arabic, CJK), and system share sheet & MediaStore gallery export. + ## [4.2.4] - 2026-10-05 ### Added & Improved diff --git a/app/src/main/java/com/lastwave/app/ui/player/ModernLyricsView.kt b/app/src/main/java/com/lastwave/app/ui/player/ModernLyricsView.kt index 36e9930569..7c103a375f 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/ModernLyricsView.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/ModernLyricsView.kt @@ -23,6 +23,10 @@ import androidx.compose.animation.shrinkVertically import androidx.compose.animation.togetherWith import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.filled.FormatSize +import androidx.compose.material.icons.filled.Share +import com.lastwave.app.ui.player.lyricsshare.ShareLyricsDialog +import com.lastwave.app.ui.player.lyricsshare.TrackInfo +import com.lastwave.app.ui.player.lyricsshare.buildLyricsSnapshot import kotlin.math.roundToInt import androidx.compose.foundation.background import androidx.compose.foundation.clickable @@ -196,9 +200,15 @@ fun ModernLyricsPanel( primaryColor: Color = MaterialTheme.colorScheme.primary, secondaryColor: Color = MaterialTheme.colorScheme.secondary, tertiaryColor: Color = MaterialTheme.colorScheme.tertiary, + resolvedArtworkUrl: String? = null, ) { state.current ?: return + var showShareDialog by rememberSaveable { mutableStateOf(false) } + val canShareLyrics = lyricsState is LyricsUiState.Success && + !lyricsState.isInstrumental && + (lyricsState.lines.any { it.text.isNotBlank() } || !lyricsState.plainLyrics.isNullOrBlank()) + // High-frequency progress is collected ONLY in the leaf hosts below // (lyrics list + controls). Collecting it here would recompose the whole // panel incl. AnimatedContent + badge ~16x/sec. Other players isolate it. @@ -606,12 +616,46 @@ fun ModernLyricsPanel( primaryColor = primaryColor, secondaryColor = secondaryColor, tertiaryColor = tertiaryColor, + canShareLyrics = canShareLyrics, + onShareLyrics = { showShareDialog = true }, modifier = Modifier .fillMaxWidth() .padding(horizontal = 16.dp) .padding(bottom = 16.dp, top = 6.dp), ) } + + if (showShareDialog) { + val currentTrack = state.current + if (currentTrack != null) { + val trackInfo = remember(currentTrack, resolvedArtworkUrl) { + TrackInfo( + title = currentTrack.title, + artist = currentTrack.artist, + artworkUrl = currentTrack.artworkUrl, + resolvedArtworkUrl = resolvedArtworkUrl, + ) + } + val activeIndex = remember(lyricsState, lyricsOffsetMs) { + val lines = (lyricsState as? LyricsUiState.Success)?.lines.orEmpty() + if (lines.isNotEmpty()) { + activeLineIndex(lines, progressFlow.value.positionMs + lyricsOffsetMs) + } else { + -1 + } + } + val snapshot = remember(lyricsState, trackInfo) { + buildLyricsSnapshot(lyricsState, trackInfo, activeIndex) + } + if (snapshot != null) { + ShareLyricsDialog( + snapshot = snapshot, + onDismiss = { showShareDialog = false }, + primaryColor = primaryColor, + ) + } + } + } } /** @@ -1393,6 +1437,8 @@ private fun ModernLyricsControlsHost( primaryColor: Color = MaterialTheme.colorScheme.primary, secondaryColor: Color = MaterialTheme.colorScheme.secondary, tertiaryColor: Color = MaterialTheme.colorScheme.tertiary, + canShareLyrics: Boolean = false, + onShareLyrics: () -> Unit = {}, modifier: Modifier = Modifier, ) { val progress by progressFlow.collectAsStateWithLifecycle(initialValue = progressInitial) @@ -1421,6 +1467,8 @@ private fun ModernLyricsControlsHost( primaryColor = primaryColor, secondaryColor = secondaryColor, tertiaryColor = tertiaryColor, + canShareLyrics = canShareLyrics, + onShareLyrics = onShareLyrics, modifier = modifier, ) } @@ -1451,6 +1499,8 @@ private fun ModernLyricsControls( primaryColor: Color = MaterialTheme.colorScheme.primary, secondaryColor: Color = MaterialTheme.colorScheme.secondary, tertiaryColor: Color = MaterialTheme.colorScheme.tertiary, + canShareLyrics: Boolean = false, + onShareLyrics: () -> Unit = {}, modifier: Modifier = Modifier, ) { var sliderPosition by remember(lyricsFontScale) { mutableFloatStateOf(lyricsFontScale) } @@ -1656,6 +1706,41 @@ private fun ModernLyricsControls( Spacer(Modifier.width(10.dp)) + if (canShareLyrics) { + val shareInteraction = remember { MutableInteractionSource() } + val isSharePressed by shareInteraction.collectIsPressedAsState() + val sharePressScale by animateFloatAsState( + targetValue = if (isSharePressed) 0.82f else 1.0f, + animationSpec = ExpressiveMotion.spatialSpring(), + label = "shareBtnScale", + ) + IconButton( + onClick = onShareLyrics, + enabled = controlsVisible, + interactionSource = shareInteraction, + modifier = Modifier + .size(44.dp) + .graphicsLayer { + scaleX = sharePressScale + scaleY = sharePressScale + } + .clip(CircleShape) + .liquidGlassChrome(CircleShape, LocalLiquidGlass.current, LiquidGlassPreset.FloatingControls, interactionSource = shareInteraction) + .background( + liquidGlassContainerColor(Color.White.copy(alpha = 0.14f)), + ), + ) { + Icon( + Icons.Filled.Share, + contentDescription = stringResource(R.string.lyshare_button_cd), + modifier = Modifier.size(22.dp), + tint = Color.White.copy(alpha = 0.90f), + ) + } + + Spacer(Modifier.width(10.dp)) + } + // Lyrics Font Scale toggle button placed immediately to the LEFT of Full Screen val fontInteraction = remember { MutableInteractionSource() } val isFontPressed by fontInteraction.collectIsPressedAsState() diff --git a/app/src/main/java/com/lastwave/app/ui/player/PlayerHost.kt b/app/src/main/java/com/lastwave/app/ui/player/PlayerHost.kt index 8d777a72bc..aad87535f7 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/PlayerHost.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/PlayerHost.kt @@ -2420,6 +2420,7 @@ private fun FullPlayer( primaryColor = ambientColor, secondaryColor = ambientCompanion, tertiaryColor = ambientDeep, + resolvedArtworkUrl = resolvedAmbientUrl, modifier = Modifier .fillMaxSize() .adaptiveContentWidth(maxWidth = if (isTabletLandscape) 960.dp else 720.dp), diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolver.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolver.kt new file mode 100644 index 0000000000..0f562d09dd --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolver.kt @@ -0,0 +1,134 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.Canvas +import android.graphics.LinearGradient +import android.graphics.Paint +import android.graphics.Shader +import android.graphics.drawable.BitmapDrawable +import coil.imageLoader +import coil.request.ImageRequest +import coil.request.SuccessResult +import com.lastwave.app.data.artwork.ArtworkNormalizer +import com.lastwave.app.ui.player.FastBlur +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlinx.coroutines.withTimeoutOrNull + +data class ArtworkResolution( + val coverBitmap: Bitmap?, + val blurredBitmap: Bitmap, + val resolvedUrl: String?, +) + +object ArtworkResolver { + + private const val LOAD_TIMEOUT_MS = 5000L + + /** + * Resolves high-resolution album artwork following the app's established hierarchy: + * 1. Track's own artworkUrl (if real image) + * 2. Resolved ambient artwork URL from PlayerHost / ArtworkRepository + * 3. Upgraded high-res URL via ArtworkNormalizer.upscaleYoutubeArtwork() + * 4. File / content URIs for downloaded or local audio + * 5. Fallback brand gradient if all else fails or times out + * + * Decodes with allowHardware(false) for software Canvas drawing and Palette access. + */ + suspend fun resolveArtwork( + context: Context, + trackInfo: TrackInfo, + themePrimaryColor: Int = ColorContrastHelper.BRAND_LIME, + ): ArtworkResolution = withContext(Dispatchers.IO) { + val targetUrl = determineArtworkUrl(trackInfo) + + val loadedBitmap = if (!targetUrl.isNullOrBlank()) { + withTimeoutOrNull(LOAD_TIMEOUT_MS) { + runCatching { + val request = ImageRequest.Builder(context) + .data(targetUrl) + .allowHardware(false) + .size(1080) + .build() + + val result = context.imageLoader.execute(request) + if (result is SuccessResult) { + (result.drawable as? BitmapDrawable)?.bitmap?.let { original -> + // Ensure it's a software bitmap + if (original.config == Bitmap.Config.HARDWARE) { + original.copy(Bitmap.Config.ARGB_8888, false) + } else { + original + } + } + } else null + }.getOrNull() + } + } else null + + val blurred = if (loadedBitmap != null) { + runCatching { + FastBlur.blurArtwork(loadedBitmap, radius = 25, maxDimension = 180) + }.getOrElse { + createBrandFallbackGradient(themePrimaryColor) + } + } else { + createBrandFallbackGradient(themePrimaryColor) + } + + ArtworkResolution( + coverBitmap = loadedBitmap, + blurredBitmap = blurred, + resolvedUrl = targetUrl, + ) + } + + /** + * Pure function implementing the exact resolution order: + * 1. track.artworkUrl (if real) + * 2. resolvedArtworkUrl (if real) + * 3. upscaled YouTube URL + */ + fun determineArtworkUrl(trackInfo: TrackInfo): String? { + val raw = trackInfo.artworkUrl + val resolved = trackInfo.resolvedArtworkUrl + + // Local files take highest precedence + if (raw?.startsWith("file://") == true || raw?.startsWith("content://") == true) { + return raw + } + + val primary = when { + ArtworkNormalizer.isRealImage(raw) -> raw + ArtworkNormalizer.isRealImage(resolved) -> resolved + else -> null + } + + return primary?.let { ArtworkNormalizer.upscaleYoutubeArtwork(it) ?: it } + } + + /** + * Creates a smooth 1080x1350 brand fallback gradient when no artwork is available. + */ + fun createBrandFallbackGradient( + accentColor: Int, + width: Int = 540, + height: Int = 720, + ): Bitmap { + val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888) + val canvas = Canvas(bitmap) + val paint = Paint(Paint.ANTI_ALIAS_FLAG) + + val darkBase = ColorContrastHelper.DEFAULT_DARK + val gradient = LinearGradient( + 0f, 0f, width.toFloat(), height.toFloat(), + intArrayOf(accentColor, darkBase, 0xFF080B0E.toInt()), + floatArrayOf(0.0f, 0.55f, 1.0f), + Shader.TileMode.CLAMP, + ) + paint.shader = gradient + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), paint) + return bitmap + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt new file mode 100644 index 0000000000..b5114575e8 --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt @@ -0,0 +1,183 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.graphics.Bitmap +import android.graphics.Color as AndroidColor +import androidx.palette.graphics.Palette +import kotlin.math.max +import kotlin.math.min +import kotlin.math.pow + +/** + * Metadata for a color swatch available in the Lyrics Share color picker. + */ +data class ColorSwatch( + val id: String, + val nameRes: Int, + val color: Int, // ARGB packed integer +) + +/** + * Contrast-evaluated text colors for a background swatch. + */ +data class DerivedCardColors( + val backgroundColor: Int, + val lyricsTextColor: Int, + val secondaryTextColor: Int, + val brandTextColor: Int, + val isDarkBackground: Boolean, +) + +object ColorContrastHelper { + + const val BRAND_LIME: Int = 0xFFC9FB00.toInt() + const val DEFAULT_DARK: Int = 0xFF12161A.toInt() + const val PURE_WHITE: Int = 0xFFFFFFFF.toInt() + const val PURE_BLACK: Int = 0xFF101010.toInt() + + /** + * Calculates the WCAG 2.1 relative luminance of an sRGB color. + */ + fun relativeLuminance(color: Int): Double { + val r = linearize(AndroidColor.red(color) / 255.0) + val g = linearize(AndroidColor.green(color) / 255.0) + val b = linearize(AndroidColor.blue(color) / 255.0) + return 0.2126 * r + 0.7152 * g + 0.0722 * b + } + + private fun linearize(channel: Double): Double { + return if (channel <= 0.04045) { + channel / 12.92 + } else { + ((channel + 0.055) / 1.055).pow(2.4) + } + } + + /** + * Calculates the WCAG 2.1 contrast ratio between two colors (ranging from 1.0 to 21.0). + */ + fun contrastRatio(fgColor: Int, bgColor: Int): Double { + val l1 = relativeLuminance(fgColor) + val l2 = relativeLuminance(bgColor) + val lighter = max(l1, l2) + val darker = min(l1, l2) + return (lighter + 0.05) / (darker + 0.05) + } + + /** + * Derives high-contrast foreground text colors matching YouTube Music's dynamic styling: + * - On dark backgrounds: crisp tinted-white with $\ge 4.5:1$ contrast for lyrics. + * - On light backgrounds: deep tinted-charcoal with $\ge 4.5:1$ contrast for lyrics. + * - Secondary text & logo guaranteed $\ge 3.0:1$ WCAG AA contrast. + */ + fun deriveTextColors(backgroundColor: Int): DerivedCardColors { + val bgLum = relativeLuminance(backgroundColor) + val isDark = bgLum < 0.45 + + val targetLight = 0xFFFFFFFF.toInt() + val targetDark = 0xFF121417.toInt() + + val primaryLyricsColor = if (isDark) { + // Dark bg: use white or high-contrast tinted white + val candidate = 0xFFF8FAFC.toInt() + if (contrastRatio(candidate, backgroundColor) >= 4.5) candidate else targetLight + } else { + // Light bg: use dark charcoal + val candidate = 0xFF0F172A.toInt() + if (contrastRatio(candidate, backgroundColor) >= 4.5) candidate else targetDark + } + + val secondaryColor = if (isDark) { + // Semi-transparent / muted white + val candidate = AndroidColor.argb( + 210, // ~82% alpha + AndroidColor.red(targetLight), + AndroidColor.green(targetLight), + AndroidColor.blue(targetLight), + ) + val solidSecondary = blendOver(candidate, backgroundColor) + if (contrastRatio(solidSecondary, backgroundColor) >= 3.0) solidSecondary else targetLight + } else { + val candidate = AndroidColor.argb( + 200, // ~78% alpha + AndroidColor.red(targetDark), + AndroidColor.green(targetDark), + AndroidColor.blue(targetDark), + ) + val solidSecondary = blendOver(candidate, backgroundColor) + if (contrastRatio(solidSecondary, backgroundColor) >= 3.0) solidSecondary else targetDark + } + + val brandColor = if (contrastRatio(primaryLyricsColor, backgroundColor) >= 3.0) { + primaryLyricsColor + } else { + if (isDark) targetLight else targetDark + } + + return DerivedCardColors( + backgroundColor = backgroundColor, + lyricsTextColor = primaryLyricsColor, + secondaryTextColor = secondaryColor, + brandTextColor = brandColor, + isDarkBackground = isDark, + ) + } + + /** + * Blends an alpha foreground color over an opaque background to get an effective RGB. + */ + fun blendOver(fgColor: Int, bgColor: Int): Int { + val alpha = AndroidColor.alpha(fgColor) / 255.0 + val r = (AndroidColor.red(fgColor) * alpha + AndroidColor.red(bgColor) * (1.0 - alpha)).toInt().coerceIn(0, 255) + val g = (AndroidColor.green(fgColor) * alpha + AndroidColor.green(bgColor) * (1.0 - alpha)).toInt().coerceIn(0, 255) + val b = (AndroidColor.blue(fgColor) * alpha + AndroidColor.blue(bgColor) * (1.0 - alpha)).toInt().coerceIn(0, 255) + return AndroidColor.rgb(r, g, b) + } + + /** + * Extracts palette colors from a software bitmap and combines them with theme tokens + * to produce the standardized 8 swatches: + * 1. Song color (Vibrant / default) + * 2. Muted + * 3. Dominant + * 4. Dark variant + * 5. Pure White + * 6. Pure Black + * 7. Theme Accent + * 8. Brand Lime (#C9FB00) + */ + fun extractSwatches( + artBitmap: Bitmap?, + themeAccentColor: Int = 0xFF38BDF8.toInt(), + ): List { + val palette = artBitmap?.let { + runCatching { Palette.from(it).clearFilters().generate() }.getOrNull() + } + + val vibrant = palette?.vibrantSwatch?.rgb + ?: palette?.lightVibrantSwatch?.rgb + ?: palette?.dominantSwatch?.rgb + ?: 0xFF2563EB.toInt() + + val muted = palette?.mutedSwatch?.rgb + ?: palette?.darkMutedSwatch?.rgb + ?: 0xFF64748B.toInt() + + val dominant = palette?.dominantSwatch?.rgb + ?: 0xFF1E293B.toInt() + + val darkVariant = palette?.darkVibrantSwatch?.rgb + ?: palette?.darkMutedSwatch?.rgb + ?: 0xFF0F172A.toInt() + + return listOf( + ColorSwatch("song_vibrant", com.lastwave.app.R.string.lyshare_color_song, vibrant), + ColorSwatch("muted", com.lastwave.app.R.string.lyshare_color_muted, muted), + ColorSwatch("dominant", com.lastwave.app.R.string.lyshare_color_dominant, dominant), + ColorSwatch("dark", com.lastwave.app.R.string.lyshare_color_dark, darkVariant), + ColorSwatch("white", com.lastwave.app.R.string.lyshare_color_white, PURE_WHITE), + ColorSwatch("black", com.lastwave.app.R.string.lyshare_color_black, PURE_BLACK), + ColorSwatch("accent", com.lastwave.app.R.string.lyshare_color_accent, themeAccentColor), + ColorSwatch("brand", com.lastwave.app.R.string.lyshare_color_brand, BRAND_LIME), + ) + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/LyricsSnapshot.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/LyricsSnapshot.kt new file mode 100644 index 0000000000..da740c7676 --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/LyricsSnapshot.kt @@ -0,0 +1,163 @@ +package com.lastwave.app.ui.player.lyricsshare + +import com.lastwave.app.data.lyrics.LyricLine +import com.lastwave.app.data.lyrics.isRtlText +import com.lastwave.app.ui.player.LyricsUiState + +/** + * Immutable metadata of the track at the moment the share flow opened. + */ +data class TrackInfo( + val title: String, + val artist: String, + val artworkUrl: String? = null, + val resolvedArtworkUrl: String? = null, +) + +/** + * A selectable line of lyrics with directional metadata. + */ +data class ShareLine( + val text: String, + val isRtl: Boolean = isRtlText(text), + val originalIndex: Int = -1, +) + +/** + * Point-in-time immutable snapshot of lyrics and track info for the share sheet. + * Playback keeps advancing underneath, but this snapshot remains stable. + */ +data class LyricsSnapshot( + val trackInfo: TrackInfo, + val lines: List, + val initialActiveLineIndex: Int = -1, +) + +/** + * Creates an immutable snapshot from current [LyricsUiState.Success] lines. + * Filters out blank lines and maps raw text only (never offset-shifted timestamps). + * Supports both line-synced / word-synced and plain unsynced lyrics. + */ +fun buildLyricsSnapshot( + lyricsState: LyricsUiState, + trackInfo: TrackInfo, + currentActiveIndex: Int = -1, +): LyricsSnapshot? { + val success = lyricsState as? LyricsUiState.Success ?: return null + if (success.isInstrumental) return null + + val shareLines: List = if (success.isSynced && success.lines.isNotEmpty()) { + success.lines.mapIndexedNotNull { index, line -> + val trimmed = line.text.trim() + if (trimmed.isNotBlank()) { + ShareLine( + text = trimmed, + isRtl = line.isRtl || isRtlText(trimmed), + originalIndex = index, + ) + } else null + } + } else { + // Plain (unsynced) lyrics fallback: split on newlines, discarding empty lines + val plain = success.plainLyrics ?: return null + plain.lines() + .map { it.trim() } + .filter { it.isNotBlank() } + .mapIndexed { index, text -> + ShareLine( + text = text, + isRtl = isRtlText(text), + originalIndex = index, + ) + } + } + + if (shareLines.isEmpty()) return null + + // Map active index to filtered lines list + val mappedActiveIndex = if (currentActiveIndex >= 0 && success.isSynced) { + val found = shareLines.indexOfFirst { it.originalIndex >= currentActiveIndex } + if (found >= 0) found else shareLines.lastIndex + } else { + -1 + } + + return LyricsSnapshot( + trackInfo = trackInfo, + lines = shareLines, + initialActiveLineIndex = mappedActiveIndex, + ) +} + +/** + * Computes default 1..3 line selection window centered on the active line. + * If there is no active line yet, starts at the top (first 3 lines). + */ +fun computeDefaultSelection(totalLines: Int, activeIndex: Int): IntRange { + if (totalLines <= 0) return IntRange.EMPTY + if (totalLines <= 3) return 0 until totalLines + + return if (activeIndex in 0 until totalLines) { + val idealStart = (activeIndex - 1).coerceAtLeast(0) + val idealEnd = (idealStart + 2).coerceAtMost(totalLines - 1) + val finalStart = (idealEnd - 2).coerceAtLeast(0) + finalStart..idealEnd + } else { + 0..minOf(2, totalLines - 1) + } +} + +/** + * Implements contiguous selection rules for 1 to 5 lines: + * - Tapping a line adjacent to the range extends it (clamped at [maxLines]). + * - Tapping an edge line shrinks it (minimum 1 line). + * - Tapping an inner line restarts selection from that single line. + * - Tapping a non-adjacent line restarts selection from that single line. + * - At [maxLines], invokes [onCapReached] without extending. + */ +fun updateContiguousSelection( + currentRange: IntRange, + tappedIndex: Int, + totalLines: Int, + maxLines: Int = 5, + onCapReached: () -> Unit = {}, +): IntRange { + if (tappedIndex !in 0 until totalLines) return currentRange + if (currentRange.isEmpty()) return tappedIndex..tappedIndex + + val start = currentRange.first + val end = currentRange.last + val currentCount = end - start + 1 + + return when { + // Tapping edge of a multi-line range: shrink + tappedIndex == start && currentCount > 1 -> (start + 1)..end + tappedIndex == end && currentCount > 1 -> start..(end - 1) + + // Tapping single selected line: keep it (minimum 1) + tappedIndex == start && currentCount == 1 -> currentRange + + // Tapping immediately adjacent before + tappedIndex == start - 1 -> { + if (currentCount >= maxLines) { + onCapReached() + currentRange + } else { + tappedIndex..end + } + } + + // Tapping immediately adjacent after + tappedIndex == end + 1 -> { + if (currentCount >= maxLines) { + onCapReached() + currentRange + } else { + start..tappedIndex + } + } + + // Any non-adjacent or interior tap: restart single-line selection + else -> tappedIndex..tappedIndex + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt new file mode 100644 index 0000000000..34cbd1da6d --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt @@ -0,0 +1,253 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.widget.Toast +import androidx.compose.animation.animateColorAsState +import androidx.compose.animation.core.tween +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.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBarsPadding +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.material.icons.Icons +import androidx.compose.material.icons.rounded.Close +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember +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.hapticfeedback.HapticFeedbackType +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalHapticFeedback +import androidx.compose.ui.res.pluralStringResource +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.role +import androidx.compose.ui.semantics.selected +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.lastwave.app.R + +@Composable +fun SelectLyricsScreen( + snapshot: LyricsSnapshot, + selectedRange: IntRange, + onSelectionChange: (IntRange) -> Unit, + onContinue: () -> Unit, + onClose: () -> Unit, + primaryColor: Color = MaterialTheme.colorScheme.primary, + modifier: Modifier = Modifier, +) { + val context = LocalContext.current + val haptics = LocalHapticFeedback.current + val listState = rememberLazyListState() + + // Auto-scroll so initial selection is in view + LaunchedEffect(Unit) { + if (!selectedRange.isEmpty()) { + val targetIndex = (selectedRange.first - 1).coerceAtLeast(0) + listState.animateScrollToItem(targetIndex) + } + } + + val selectedCount = if (selectedRange.isEmpty()) 0 else (selectedRange.last - selectedRange.first + 1) + val maxLinesCapMessage = stringResource(R.string.lyshare_max_lines_reached) + + // Spotify-style vertical gradient: song palette color fading down into near-black + val backgroundBrush = remember(primaryColor) { + Brush.verticalGradient( + colors = listOf( + primaryColor.copy(alpha = 0.55f), + Color(0xFF0F141A).copy(alpha = 0.92f), + Color(0xFF090C0E), + ), + ) + } + + Box( + modifier = modifier + .fillMaxSize() + .background(backgroundBrush), + ) { + Column( + modifier = Modifier.fillMaxSize(), + ) { + // Header + Row( + modifier = Modifier + .fillMaxWidth() + .statusBarsPadding() + .padding(horizontal = 8.dp, vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + IconButton( + onClick = onClose, + modifier = Modifier + .size(48.dp) + .clip(CircleShape), + ) { + Icon( + imageVector = Icons.Rounded.Close, + contentDescription = stringResource(R.string.lyshare_close_cd), + tint = Color.White, + ) + } + + Column( + modifier = Modifier + .weight(1f) + .padding(horizontal = 8.dp), + ) { + Text( + text = stringResource(R.string.lyshare_select_lyrics), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold, + color = Color.White, + ) + Text( + text = if (selectedCount == 1) { + stringResource(R.string.lyshare_line_selected_single) + } else { + stringResource(R.string.lyshare_lines_selected, selectedCount) + }, + style = MaterialTheme.typography.bodySmall, + color = Color.White.copy(alpha = 0.70f), + ) + } + } + + // Lyrics List + LazyColumn( + state = listState, + modifier = Modifier + .weight(1f) + .fillMaxWidth(), + contentPadding = PaddingValues(horizontal = 20.dp, vertical = 24.dp), + verticalArrangement = Arrangement.spacedBy(10.dp), + ) { + itemsIndexed(snapshot.lines, key = { index, _ -> index }) { index, line -> + val isSelected = index in selectedRange + val rowBgColor by animateColorAsState( + targetValue = if (isSelected) Color.White.copy(alpha = 0.22f) else Color.Transparent, + animationSpec = tween(150), + label = "lyricSelectionBg", + ) + val rowTextColor by animateColorAsState( + targetValue = if (isSelected) Color.White else Color.White.copy(alpha = 0.40f), + animationSpec = tween(150), + label = "lyricSelectionText", + ) + + val accessibilityLabel = if (isSelected) { + stringResource(R.string.lyshare_accessibility_line_selected, index + 1, snapshot.lines.size) + } else { + stringResource(R.string.lyshare_accessibility_line_unselected, index + 1, snapshot.lines.size) + } + + Box( + modifier = Modifier + .fillMaxWidth() + .clip(RoundedCornerShape(14.dp)) + .background(rowBgColor) + .clickable { + val next = updateContiguousSelection( + currentRange = selectedRange, + tappedIndex = index, + totalLines = snapshot.lines.size, + maxLines = 5, + onCapReached = { + haptics.performHapticFeedback(HapticFeedbackType.LongPress) + Toast.makeText(context, maxLinesCapMessage, Toast.LENGTH_SHORT).show() + }, + ) + onSelectionChange(next) + } + .semantics { + role = Role.Checkbox + selected = isSelected + contentDescription = "$accessibilityLabel: ${line.text}" + } + .padding(horizontal = 16.dp, vertical = 12.dp), + ) { + Text( + text = line.text, + style = MaterialTheme.typography.titleMedium.copy( + fontSize = 18.sp, + lineHeight = 26.sp, + ), + fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Medium, + color = rowTextColor, + textAlign = if (line.isRtl) TextAlign.End else TextAlign.Start, + modifier = Modifier.fillMaxWidth(), + ) + } + } + + item { + Spacer(modifier = Modifier.height(84.dp)) + } + } + } + + // Bottom Continue button (white pill) + Box( + modifier = Modifier + .align(Alignment.BottomCenter) + .fillMaxWidth() + .navigationBarsPadding() + .padding(horizontal = 24.dp, vertical = 18.dp), + contentAlignment = Alignment.Center, + ) { + Button( + onClick = onContinue, + enabled = selectedCount > 0, + shape = CircleShape, + colors = ButtonDefaults.buttonColors( + containerColor = Color.White, + contentColor = Color.Black, + disabledContainerColor = Color.White.copy(alpha = 0.25f), + disabledContentColor = Color.Black.copy(alpha = 0.40f), + ), + contentPadding = PaddingValues(horizontal = 36.dp, vertical = 14.dp), + modifier = Modifier + .fillMaxWidth(0.85f) + .height(52.dp), + ) { + Text( + text = stringResource(R.string.lyshare_continue), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold, + ) + } + } + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt new file mode 100644 index 0000000000..61e38d2ea7 --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt @@ -0,0 +1,454 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.Canvas +import android.graphics.Color as AndroidColor +import android.graphics.LinearGradient +import android.graphics.Paint +import android.graphics.PorterDuff +import android.graphics.PorterDuffColorFilter +import android.graphics.PorterDuffXfermode +import android.graphics.Rect +import android.graphics.RectF +import android.graphics.Shader +import android.graphics.Typeface +import android.os.Build +import android.text.Layout +import android.text.StaticLayout +import android.text.TextPaint +import androidx.core.content.ContextCompat +import androidx.core.content.res.ResourcesCompat +import com.lastwave.app.R +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlin.math.max +import kotlin.math.min +import kotlin.math.roundToInt + +object ShareCardRenderer { + + const val BASE_WIDTH: Int = 1080 + const val MIN_HEIGHT: Int = 1350 // 4:5 + const val MAX_HEIGHT: Int = 1920 // 9:16 + + /** + * Renders the card into an immutable software [Bitmap] with automatic OOM retry. + */ + suspend fun renderCard( + context: Context, + spec: ShareCardSpec, + ): Bitmap = withContext(Dispatchers.Default) { + try { + renderInternal(context, spec) + } catch (oom: OutOfMemoryError) { + System.gc() + val retrySpec = spec.copy(scaleFactor = spec.scaleFactor * 0.75f) + renderInternal(context, retrySpec) + } + } + + private fun renderInternal( + context: Context, + spec: ShareCardSpec, + ): Bitmap { + val scale = spec.scaleFactor + val width = (spec.targetWidth * scale).roundToInt().coerceAtLeast(320) + val minH = ((spec.targetWidth * 5 / 4) * scale).roundToInt() + val maxH = ((spec.targetWidth * 16 / 9) * scale).roundToInt() + + // Measure content height requirements + val measuredHeight = measureRequiredHeight(context, spec, width, scale) + val height = measuredHeight.coerceIn(minH, maxH) + + val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888) + val canvas = Canvas(bitmap) + + if (spec.mode == CardMode.Song) { + renderSongCard(canvas, context, spec, width, height, scale) + } else { + renderLyricsCard(canvas, context, spec, width, height, scale) + } + + return bitmap + } + + private fun getTypeface(context: Context, weight: Int): Typeface { + return try { + val base = ResourcesCompat.getFont(context, R.font.google_sans_flex) + if (base != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + Typeface.create(base, weight, false) + } else { + base ?: Typeface.create(Typeface.DEFAULT, if (weight >= 600) Typeface.BOLD else Typeface.NORMAL) + } + } catch (_: Throwable) { + Typeface.create(Typeface.DEFAULT, if (weight >= 600) Typeface.BOLD else Typeface.NORMAL) + } + } + + private fun measureRequiredHeight( + context: Context, + spec: ShareCardSpec, + width: Int, + scale: Float, + ): Int { + val hPadding = (72 * scale).roundToInt() + val contentWidth = width - (hPadding * 2) + + return if (spec.mode == CardMode.Song) { + val artSize = (440 * scale).roundToInt() + val topMargin = (72 * scale).roundToInt() + val artToTitle = (28 * scale).roundToInt() + val titleH = (44 * scale).roundToInt() + val artistH = (32 * scale).roundToInt() + val dividerSpace = (36 * scale).roundToInt() + val lyricsHeight = measureLyricsBlockHeight(context, spec, contentWidth, scale, maxFontSize = 46f) + val footerSpace = (100 * scale).roundToInt() + + topMargin + artSize + artToTitle + titleH + artistH + dividerSpace + lyricsHeight + footerSpace + } else { + val topMargin = (84 * scale).roundToInt() + val attrHeight = (54 * scale).roundToInt() + val lyricsHeight = measureLyricsBlockHeight(context, spec, contentWidth, scale, maxFontSize = 58f) + val footerSpace = (120 * scale).roundToInt() + + topMargin + attrHeight + lyricsHeight + footerSpace + } + } + + private fun measureLyricsBlockHeight( + context: Context, + spec: ShareCardSpec, + contentWidth: Int, + scale: Float, + maxFontSize: Float, + ): Int { + val boldTypeface = getTypeface(context, 700) + val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = maxFontSize * scale + } + + var totalH = 0 + val lineSpacing = (18 * scale).roundToInt() + for (line in spec.lines) { + val layout = createStaticLayout(line.text, textPaint, contentWidth, line.isRtl) + totalH += layout.height + lineSpacing + } + return totalH + } + + private fun createStaticLayout( + text: CharSequence, + paint: TextPaint, + width: Int, + isRtl: Boolean, + ): StaticLayout { + val alignment = if (isRtl) Layout.Alignment.ALIGN_OPPOSITE else Layout.Alignment.ALIGN_NORMAL + val safeWidth = max(width, 10) + return try { + StaticLayout.Builder.obtain(text, 0, text.length, paint, safeWidth)?.let { builder -> + builder.setAlignment(alignment) + .setLineSpacing(0f, 1.25f) + .setIncludePad(true) // Crucial for Hindi/Devanagari matras and Arabic ascenders + .build() + } ?: @Suppress("DEPRECATION") StaticLayout(text, 0, text.length, paint, safeWidth, alignment, 1.25f, 0f, true) + } catch (_: Throwable) { + @Suppress("DEPRECATION") + StaticLayout(text, 0, text.length, paint, safeWidth, alignment, 1.25f, 0f, true) + } + } + + // ========================================== + // SONG CARD RENDERING + // ========================================== + private fun renderSongCard( + canvas: Canvas, + context: Context, + spec: ShareCardSpec, + width: Int, + height: Int, + scale: Float, + ) { + // 1. Blurred background image + val bgPaint = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG) + val blurBitmap = spec.blurredBackgroundBitmap + if (blurBitmap != null && !blurBitmap.isRecycled) { + val src = Rect(0, 0, blurBitmap.width, blurBitmap.height) + val dst = Rect(0, 0, width, height) + canvas.drawBitmap(blurBitmap, src, dst, bgPaint) + } else { + val fallback = ArtworkResolver.createBrandFallbackGradient(spec.swatchColor, width, height) + canvas.drawBitmap(fallback, 0f, 0f, bgPaint) + } + + // 2. Color scrim overlay with high-contrast guarantee + val scrimPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = spec.swatchColor + alpha = if (spec.derivedColors.isDarkBackground) 180 else 215 + } + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), scrimPaint) + + // Dark gradient scrim from top to bottom to ground the layout + val vignettePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + shader = LinearGradient( + 0f, 0f, 0f, height.toFloat(), + intArrayOf(0x44000000, 0x11000000, 0x88000000.toInt()), + floatArrayOf(0.0f, 0.45f, 1.0f), + Shader.TileMode.CLAMP, + ) + } + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), vignettePaint) + + val hPadding = (72 * scale).roundToInt() + val contentWidth = width - (hPadding * 2) + var currentY = (64 * scale) + + // 3. Prominent Cover Art (centered, rounded corners, soft shadow) + val artSize = (440 * scale).roundToInt() + val artX = (width - artSize) / 2f + val artRect = RectF(artX, currentY, artX + artSize, currentY + artSize) + val cornerRadius = 24f * scale + + // Soft shadow + val shadowPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = 0x55000000 + maskFilter = null + } + val shadowRect = RectF(artRect.left, artRect.top + 6 * scale, artRect.right, artRect.bottom + 10 * scale) + canvas.drawRoundRect(shadowRect, cornerRadius, cornerRadius, shadowPaint) + + // Draw cover bitmap or placeholder + val coverBitmap = spec.coverBitmap + if (coverBitmap != null && !coverBitmap.isRecycled) { + val roundedCover = getRoundedBitmap(coverBitmap, cornerRadius, artSize, artSize) + canvas.drawBitmap(roundedCover, artRect.left, artRect.top, null) + } else { + // Placeholder rounded card with brand logo + val placeholderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + shader = LinearGradient( + artRect.left, artRect.top, artRect.right, artRect.bottom, + intArrayOf(spec.swatchColor, ColorContrastHelper.DEFAULT_DARK), + null, + Shader.TileMode.CLAMP, + ) + } + canvas.drawRoundRect(artRect, cornerRadius, cornerRadius, placeholderPaint) + drawLogoMark(canvas, context, artRect.centerX(), artRect.centerY(), (64 * scale).roundToInt(), spec.derivedColors.lyricsTextColor) + } + + currentY += artSize + (28 * scale) + + // 4. Song title & artist + val titlePaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = getTypeface(context, 700) + textSize = 38f * scale + color = spec.derivedColors.lyricsTextColor + } + val titleLayout = createStaticLayout(spec.title, titlePaint, contentWidth, spec.isRtl) + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + titleLayout.draw(canvas) + canvas.restore() + currentY += titleLayout.height + (6 * scale) + + val artistPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = getTypeface(context, 450) + textSize = 28f * scale + color = spec.derivedColors.secondaryTextColor + } + val artistLayout = createStaticLayout(spec.artist, artistPaint, contentWidth, spec.isRtl) + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + artistLayout.draw(canvas) + canvas.restore() + currentY += artistLayout.height + (24 * scale) + + // 5. Thin divider + val dividerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = spec.derivedColors.secondaryTextColor + alpha = 50 + strokeWidth = 1.5f * scale + } + canvas.drawLine(hPadding.toFloat(), currentY, (width - hPadding).toFloat(), currentY, dividerPaint) + currentY += (24 * scale) + + // 6. Selected Lyrics (auto-fitted) + val footerAreaH = (88 * scale) + val availableLyricsH = (height - currentY - footerAreaH).coerceAtLeast(100f) + drawFittedLyrics(canvas, context, spec, hPadding, currentY, contentWidth, availableLyricsH, scale, startFontSize = 46f) + + // 7. Brand footer + drawFooter(canvas, context, width, height, scale, spec.derivedColors.brandTextColor) + } + + // ========================================== + // LYRICS CARD RENDERING + // ========================================== + private fun renderLyricsCard( + canvas: Canvas, + context: Context, + spec: ShareCardSpec, + width: Int, + height: Int, + scale: Float, + ) { + // Flat / subtle gradient background + val bgPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + val darkerBg = AndroidColor.rgb( + (AndroidColor.red(spec.swatchColor) * 0.45f).toInt(), + (AndroidColor.green(spec.swatchColor) * 0.45f).toInt(), + (AndroidColor.blue(spec.swatchColor) * 0.45f).toInt(), + ) + shader = LinearGradient( + 0f, 0f, 0f, height.toFloat(), + intArrayOf(spec.swatchColor, darkerBg, ColorContrastHelper.DEFAULT_DARK), + floatArrayOf(0.0f, 0.6f, 1.0f), + Shader.TileMode.CLAMP, + ) + } + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), bgPaint) + + val hPadding = (80 * scale).roundToInt() + val contentWidth = width - (hPadding * 2) + var currentY = (72 * scale) + + // Small attribution: "Title • Artist" + val attrPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = getTypeface(context, 600) + textSize = 28f * scale + color = spec.derivedColors.secondaryTextColor + } + val attrText = "${spec.title} • ${spec.artist}" + val attrLayout = createStaticLayout(attrText, attrPaint, contentWidth, spec.isRtl) + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + attrLayout.draw(canvas) + canvas.restore() + currentY += attrLayout.height + (36 * scale) + + // Hero Lyrics + val footerAreaH = (100 * scale) + val availableLyricsH = (height - currentY - footerAreaH).coerceAtLeast(100f) + drawFittedLyrics(canvas, context, spec, hPadding, currentY, contentWidth, availableLyricsH, scale, startFontSize = 58f) + + // Brand footer + drawFooter(canvas, context, width, height, scale, spec.derivedColors.brandTextColor) + } + + /** + * Auto-fits lyrics font size so 1 to 5 lines never overflow or clip. + */ + private fun drawFittedLyrics( + canvas: Canvas, + context: Context, + spec: ShareCardSpec, + x: Int, + startY: Float, + contentWidth: Int, + availableHeight: Float, + scale: Float, + startFontSize: Float, + ) { + val boldTypeface = getTypeface(context, 700) + var fontSize = startFontSize + val minFontSize = 24f + val lineSpacing = (20 * scale) + + var layouts: List + var totalHeight: Float + + do { + val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = fontSize * scale + color = spec.derivedColors.lyricsTextColor + } + layouts = spec.lines.map { createStaticLayout(it.text, paint, contentWidth, it.isRtl) } + totalHeight = layouts.sumOf { it.height.toDouble() }.toFloat() + ((layouts.size - 1) * lineSpacing) + + if (totalHeight <= availableHeight || fontSize <= minFontSize) { + break + } + fontSize -= 2f + } while (fontSize >= minFontSize) + + // Center vertically in available slot if there's spare room + val offsetTop = if (availableHeight > totalHeight) { + startY + ((availableHeight - totalHeight) * 0.35f) + } else { + startY + } + + var y = offsetTop + for (layout in layouts) { + canvas.save() + canvas.translate(x.toFloat(), y) + layout.draw(canvas) + canvas.restore() + y += layout.height + lineSpacing + } + } + + private fun drawFooter( + canvas: Canvas, + context: Context, + width: Int, + height: Int, + scale: Float, + brandColor: Int, + ) { + val footerY = height - (56 * scale) + val logoSize = (32 * scale).roundToInt() + val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = getTypeface(context, 750) + textSize = 24f * scale + color = brandColor + } + + val brandName = "LastWave" + val textWidth = textPaint.measureText(brandName) + val gap = 12f * scale + val totalWidth = logoSize + gap + textWidth + val startX = (width - totalWidth) / 2f + + // Draw logo mark + drawLogoMark(canvas, context, startX + (logoSize / 2f), footerY, logoSize, brandColor) + + // Draw brand name + val textY = footerY + (textPaint.textSize * 0.35f) + canvas.drawText(brandName, startX + logoSize + gap, textY, textPaint) + } + + private fun drawLogoMark( + canvas: Canvas, + context: Context, + centerX: Float, + centerY: Float, + size: Int, + tintColor: Int, + ) { + val drawable = runCatching { + ContextCompat.getDrawable(context, R.drawable.ic_lastwave_logo_mono) + }.getOrNull() ?: return + val half = size / 2 + drawable.setBounds((centerX - half).toInt(), (centerY - half).toInt(), (centerX + half).toInt(), (centerY + half).toInt()) + drawable.colorFilter = PorterDuffColorFilter(tintColor, PorterDuff.Mode.SRC_IN) + drawable.draw(canvas) + } + + private fun getRoundedBitmap(source: Bitmap, cornerRadius: Float, targetW: Int, targetH: Int): Bitmap { + val output = Bitmap.createBitmap(targetW, targetH, Bitmap.Config.ARGB_8888) + val canvas = Canvas(output) + val paint = Paint(Paint.ANTI_ALIAS_FLAG) + val rect = RectF(0f, 0f, targetW.toFloat(), targetH.toFloat()) + + canvas.drawRoundRect(rect, cornerRadius, cornerRadius, paint) + paint.xfermode = PorterDuffXfermode(PorterDuff.Mode.SRC_IN) + + val srcRect = Rect(0, 0, source.width, source.height) + val dstRect = Rect(0, 0, targetW, targetH) + canvas.drawBitmap(source, srcRect, dstRect, paint) + return output + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt new file mode 100644 index 0000000000..80683da90a --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt @@ -0,0 +1,25 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.graphics.Bitmap + +enum class CardMode { + Song, + Lyrics, +} + +/** + * Pure data model defining all parameters needed to render a card. + */ +data class ShareCardSpec( + val mode: CardMode = CardMode.Song, + val lines: List, + val title: String, + val artist: String, + val coverBitmap: Bitmap? = null, + val blurredBackgroundBitmap: Bitmap? = null, + val swatchColor: Int = ColorContrastHelper.BRAND_LIME, + val derivedColors: DerivedCardColors = ColorContrastHelper.deriveTextColors(swatchColor), + val isRtl: Boolean = false, + val targetWidth: Int = 1080, + val scaleFactor: Float = 1.0f, +) diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareLyricsDialog.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareLyricsDialog.kt new file mode 100644 index 0000000000..338bcf715a --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareLyricsDialog.kt @@ -0,0 +1,172 @@ +package com.lastwave.app.ui.player.lyricsshare + +import androidx.activity.compose.BackHandler +import androidx.compose.animation.AnimatedContent +import androidx.compose.animation.core.tween +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.animation.slideInHorizontally +import androidx.compose.animation.slideOutHorizontally +import androidx.compose.animation.togetherWith +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.material3.MaterialTheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +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.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.toArgb +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.window.Dialog +import androidx.compose.ui.window.DialogProperties +import com.lastwave.app.ui.common.EdgeToEdgeDialogWindow +import com.lastwave.app.util.FileExportHelper + +private enum class ShareStep { + Select, + Preview, +} + +@Composable +fun ShareLyricsDialog( + snapshot: LyricsSnapshot, + onDismiss: () -> Unit, + fileExportHelper: FileExportHelper? = null, + primaryColor: Color = MaterialTheme.colorScheme.primary, + modifier: Modifier = Modifier, +) { + val context = LocalContext.current + val exportHelper = fileExportHelper ?: remember(context) { FileExportHelper(context.applicationContext) } + val totalLines = snapshot.lines.size + + // Default 1..3 selection window + val initialSelection = remember(snapshot) { + computeDefaultSelection(totalLines, snapshot.initialActiveLineIndex) + } + + var currentStepName by rememberSaveable { mutableStateOf(ShareStep.Select.name) } + var selectedStart by rememberSaveable { mutableIntStateOf(initialSelection.first) } + var selectedEnd by rememberSaveable { mutableIntStateOf(initialSelection.last) } + var cardModeName by rememberSaveable { mutableStateOf(CardMode.Song.name) } + + val currentStep = if (currentStepName == ShareStep.Preview.name) ShareStep.Preview else ShareStep.Select + val currentRange = if (selectedStart in 0 until totalLines && selectedEnd in 0 until totalLines && selectedStart <= selectedEnd) { + selectedStart..selectedEnd + } else { + initialSelection + } + val currentMode = if (cardModeName == CardMode.Lyrics.name) CardMode.Lyrics else CardMode.Song + + // Resolve artwork asynchronously off main thread + var artworkResolution by remember { + mutableStateOf( + ArtworkResolution( + coverBitmap = null, + blurredBitmap = ArtworkResolver.createBrandFallbackGradient(primaryColor.toArgb()), + resolvedUrl = null, + ) + ) + } + + LaunchedEffect(snapshot.trackInfo) { + val result = ArtworkResolver.resolveArtwork(context, snapshot.trackInfo, primaryColor.toArgb()) + artworkResolution = result + } + + // Extract swatches based on artwork & theme accent + val swatches = remember(artworkResolution.coverBitmap, primaryColor) { + ColorContrastHelper.extractSwatches(artworkResolution.coverBitmap, primaryColor.toArgb()) + } + + val defaultSwatchColor = remember(swatches) { + swatches.firstOrNull()?.color ?: ColorContrastHelper.BRAND_LIME + } + + var selectedSwatchColor by rememberSaveable { mutableIntStateOf(defaultSwatchColor) } + + // Keep swatch valid if palette updates + LaunchedEffect(swatches) { + if (swatches.none { it.color == selectedSwatchColor }) { + selectedSwatchColor = defaultSwatchColor + } + } + + Dialog( + onDismissRequest = onDismiss, + properties = DialogProperties( + usePlatformDefaultWidth = false, + decorFitsSystemWindows = false, + ), + ) { + EdgeToEdgeDialogWindow() + + BackHandler { + if (currentStep == ShareStep.Preview) { + currentStepName = ShareStep.Select.name + } else { + onDismiss() + } + } + + Box( + modifier = modifier + .fillMaxSize() + .background(Color.Black), + ) { + AnimatedContent( + targetState = currentStep, + transitionSpec = { + if (targetState == ShareStep.Preview) { + (slideInHorizontally(tween(250)) { it } + fadeIn(tween(200))) + .togetherWith(slideOutHorizontally(tween(250)) { -it / 3 } + fadeOut(tween(150))) + } else { + (slideInHorizontally(tween(250)) { -it / 3 } + fadeIn(tween(200))) + .togetherWith(slideOutHorizontally(tween(250)) { it } + fadeOut(tween(150))) + } + }, + label = "shareStepTransition", + ) { step -> + when (step) { + ShareStep.Select -> { + SelectLyricsScreen( + snapshot = snapshot, + selectedRange = currentRange, + onSelectionChange = { newRange -> + selectedStart = newRange.first + selectedEnd = newRange.last + }, + onContinue = { + currentStepName = ShareStep.Preview.name + }, + onClose = onDismiss, + primaryColor = Color(selectedSwatchColor), + ) + } + + ShareStep.Preview -> { + SharePreviewScreen( + snapshot = snapshot, + selectedRange = currentRange, + artworkResolution = artworkResolution, + swatches = swatches, + selectedMode = currentMode, + onModeChange = { cardModeName = it.name }, + selectedSwatchColor = selectedSwatchColor, + onSwatchChange = { selectedSwatchColor = it }, + onBack = { currentStepName = ShareStep.Select.name }, + onClose = onDismiss, + fileExportHelper = exportHelper, + ) + } + } + } + } + } +} diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt new file mode 100644 index 0000000000..cdafbfa820 --- /dev/null +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt @@ -0,0 +1,443 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.graphics.Bitmap +import android.widget.Toast +import androidx.compose.animation.AnimatedVisibility +import androidx.compose.animation.animateColorAsState +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.foundation.BorderStroke +import androidx.compose.foundation.Image +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.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBarsPadding +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.material.icons.Icons +import androidx.compose.material.icons.automirrored.rounded.ArrowBack +import androidx.compose.material.icons.rounded.Bookmark +import androidx.compose.material.icons.rounded.Close +import androidx.compose.material.icons.rounded.Download +import androidx.compose.material.icons.rounded.Share +import androidx.compose.material3.Button +import androidx.compose.material3.ButtonDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +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.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.shadow +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.asImageBitmap +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.role +import androidx.compose.ui.semantics.selected +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.lastwave.app.R +import com.lastwave.app.ui.common.ExpressiveInlineLoadingIndicator +import com.lastwave.app.util.FileExportHelper +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +@Composable +fun SharePreviewScreen( + snapshot: LyricsSnapshot, + selectedRange: IntRange, + artworkResolution: ArtworkResolution, + swatches: List, + selectedMode: CardMode, + onModeChange: (CardMode) -> Unit, + selectedSwatchColor: Int, + onSwatchChange: (Int) -> Unit, + onBack: () -> Unit, + onClose: () -> Unit, + fileExportHelper: FileExportHelper, + modifier: Modifier = Modifier, +) { + val context = LocalContext.current + val scope = rememberCoroutineScope() + + val selectedLines = remember(snapshot.lines, selectedRange) { + if (selectedRange.isEmpty()) emptyList() + else snapshot.lines.slice(selectedRange.first..selectedRange.last) + } + + // Build specification for renderer + val spec = remember( + selectedMode, + selectedLines, + snapshot.trackInfo, + artworkResolution, + selectedSwatchColor, + ) { + val derived = ColorContrastHelper.deriveTextColors(selectedSwatchColor) + val hasRtl = selectedLines.any { it.isRtl } + ShareCardSpec( + mode = selectedMode, + lines = selectedLines, + title = snapshot.trackInfo.title, + artist = snapshot.trackInfo.artist, + coverBitmap = artworkResolution.coverBitmap, + blurredBackgroundBitmap = artworkResolution.blurredBitmap, + swatchColor = selectedSwatchColor, + derivedColors = derived, + isRtl = hasRtl, + targetWidth = ShareCardRenderer.BASE_WIDTH, + scaleFactor = 0.50f, // Scaled for fast live preview + ) + } + + var previewBitmap by remember { mutableStateOf(null) } + var isPreviewRendering by remember { mutableStateOf(true) } + var renderJob by remember { mutableStateOf(null) } + + // Re-render preview with ~100ms debounce when spec changes + LaunchedEffect(spec) { + renderJob?.cancel() + renderJob = launch { + isPreviewRendering = true + delay(100L) + val bmp = ShareCardRenderer.renderCard(context, spec) + previewBitmap = bmp + isPreviewRendering = false + } + } + + // Export states + var isExporting by remember { mutableStateOf(false) } + + val savedToGalleryMsg = stringResource(R.string.lyshare_saved_to_gallery) + val saveFailedMsg = stringResource(R.string.lyshare_save_failed) + val shareFailedMsg = stringResource(R.string.lyshare_share_failed) + + fun onShareClick() { + if (isExporting) return + isExporting = true + scope.launch { + try { + // Render full 1080px scale bitmap for export + val fullSpec = spec.copy(scaleFactor = 1.0f) + val fullBitmap = ShareCardRenderer.renderCard(context, fullSpec) + val res = fileExportHelper.shareImage(context, fullBitmap, snapshot.trackInfo.title) + if (res.isFailure) { + Toast.makeText(context, shareFailedMsg, Toast.LENGTH_SHORT).show() + } + } catch (_: Exception) { + Toast.makeText(context, shareFailedMsg, Toast.LENGTH_SHORT).show() + } finally { + isExporting = false + } + } + } + + fun onSaveClick() { + if (isExporting) return + isExporting = true + scope.launch { + try { + val fullSpec = spec.copy(scaleFactor = 1.0f) + val fullBitmap = ShareCardRenderer.renderCard(context, fullSpec) + val res = fileExportHelper.saveImageToGallery(fullBitmap, snapshot.trackInfo.title) + if (res.isSuccess) { + Toast.makeText(context, savedToGalleryMsg, Toast.LENGTH_SHORT).show() + } else { + Toast.makeText(context, saveFailedMsg, Toast.LENGTH_SHORT).show() + } + } catch (_: Exception) { + Toast.makeText(context, saveFailedMsg, Toast.LENGTH_SHORT).show() + } finally { + isExporting = false + } + } + } + + Box( + modifier = modifier + .fillMaxSize() + .background(Color(0xFF090C0E)), + ) { + Column( + modifier = Modifier.fillMaxSize(), + ) { + // Top Bar + Row( + modifier = Modifier + .fillMaxWidth() + .statusBarsPadding() + .padding(horizontal = 8.dp, vertical = 8.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + IconButton( + onClick = onBack, + modifier = Modifier + .size(48.dp) + .clip(CircleShape), + ) { + Icon( + imageVector = Icons.AutoMirrored.Rounded.ArrowBack, + contentDescription = stringResource(R.string.lyshare_back_cd), + tint = Color.White, + ) + } + + Text( + text = stringResource(R.string.lyshare_title), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold, + color = Color.White, + ) + + IconButton( + onClick = onClose, + modifier = Modifier + .size(48.dp) + .clip(CircleShape), + ) { + Icon( + imageVector = Icons.Rounded.Close, + contentDescription = stringResource(R.string.lyshare_close_cd), + tint = Color.White, + ) + } + } + + // Live Card Preview Area + Box( + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .padding(horizontal = 24.dp, vertical = 6.dp), + contentAlignment = Alignment.Center, + ) { + val bmp = previewBitmap + if (bmp != null) { + Image( + bitmap = bmp.asImageBitmap(), + contentDescription = stringResource(R.string.lyshare_title), + modifier = Modifier + .fillMaxHeight(0.96f) + .shadow(16.dp, RoundedCornerShape(20.dp), clip = false) + .clip(RoundedCornerShape(20.dp)), + ) + } else { + CircularProgressIndicator( + color = Color.White, + modifier = Modifier.size(36.dp), + ) + } + + // Loading overlay while re-rendering on mode/color changes + androidx.compose.animation.AnimatedVisibility( + visible = isPreviewRendering && previewBitmap != null, + enter = fadeIn(), + exit = fadeOut(), + ) { + Box( + modifier = Modifier + .size(40.dp) + .background(Color.Black.copy(alpha = 0.55f), CircleShape), + contentAlignment = Alignment.Center, + ) { + ExpressiveInlineLoadingIndicator(size = 20.dp, color = Color.White) + } + } + } + + // Segmented Card Mode Toggle ("Song" | "Lyrics") + Row( + modifier = Modifier + .align(Alignment.CenterHorizontally) + .padding(vertical = 8.dp) + .background(Color.White.copy(alpha = 0.12f), CircleShape) + .padding(4.dp), + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + CardModeTab( + label = stringResource(R.string.lyshare_mode_song), + selected = selectedMode == CardMode.Song, + onClick = { onModeChange(CardMode.Song) }, + ) + CardModeTab( + label = stringResource(R.string.lyshare_mode_lyrics), + selected = selectedMode == CardMode.Lyrics, + onClick = { onModeChange(CardMode.Lyrics) }, + ) + } + + // YT Music Style Color Swatches Picker + LazyRow( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 12.dp) + .semantics { contentDescription = context.getString(R.string.lyshare_color_picker_cd) }, + contentPadding = PaddingValues(horizontal = 24.dp), + horizontalArrangement = Arrangement.spacedBy(14.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + items(swatches, key = { it.id }) { swatch -> + val isSelected = swatch.color == selectedSwatchColor + val swatchName = stringResource(swatch.nameRes) + + Box( + modifier = Modifier + .size(44.dp) + .clip(CircleShape) + .background(Color(swatch.color)) + .then( + if (isSelected) { + Modifier.border(BorderStroke(3.dp, Color.White), CircleShape) + } else { + Modifier.border(BorderStroke(1.dp, Color.White.copy(alpha = 0.25f)), CircleShape) + } + ) + .clickable { onSwatchChange(swatch.color) } + .semantics { + role = Role.RadioButton + selected = isSelected + contentDescription = swatchName + }, + contentAlignment = Alignment.Center, + ) { + if (isSelected) { + Box( + modifier = Modifier + .size(10.dp) + .background(Color.White, CircleShape), + ) + } + } + } + } + + // Bottom Actions: Secondary Save + Primary White Pill Share + Row( + modifier = Modifier + .fillMaxWidth() + .navigationBarsPadding() + .padding(horizontal = 24.dp, vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(16.dp), + ) { + // Secondary Save button + IconButton( + onClick = { onSaveClick() }, + enabled = !isExporting, + modifier = Modifier + .size(52.dp) + .clip(CircleShape) + .background(Color.White.copy(alpha = 0.14f)), + ) { + Icon( + imageVector = Icons.Rounded.Download, + contentDescription = stringResource(R.string.lyshare_action_save), + tint = Color.White, + modifier = Modifier.size(24.dp), + ) + } + + // Primary Share button + Button( + onClick = { onShareClick() }, + enabled = !isExporting, + shape = CircleShape, + colors = ButtonDefaults.buttonColors( + containerColor = Color.White, + contentColor = Color.Black, + disabledContainerColor = Color.White.copy(alpha = 0.35f), + disabledContentColor = Color.Black.copy(alpha = 0.50f), + ), + modifier = Modifier + .weight(1f) + .height(52.dp), + ) { + if (isExporting) { + ExpressiveInlineLoadingIndicator(size = 20.dp, color = Color.Black) + } else { + Icon( + imageVector = Icons.Rounded.Share, + contentDescription = null, + modifier = Modifier.size(20.dp), + ) + Spacer(Modifier.width(8.dp)) + Text( + text = stringResource(R.string.lyshare_action_share), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.Bold, + ) + } + } + } + } + } +} + +@Composable +private fun CardModeTab( + label: String, + selected: Boolean, + onClick: () -> Unit, +) { + val bg by animateColorAsState( + targetValue = if (selected) Color.White else Color.Transparent, + animationSpec = androidx.compose.animation.core.tween(150), + label = "modeTabBg", + ) + val fg by animateColorAsState( + targetValue = if (selected) Color.Black else Color.White.copy(alpha = 0.70f), + animationSpec = androidx.compose.animation.core.tween(150), + label = "modeTabFg", + ) + + Box( + modifier = Modifier + .clip(CircleShape) + .background(bg) + .clickable(onClick = onClick) + .padding(horizontal = 22.dp, vertical = 8.dp), + contentAlignment = Alignment.Center, + ) { + Text( + text = label, + style = MaterialTheme.typography.labelMedium.copy(fontSize = 14.sp), + fontWeight = FontWeight.Bold, + color = fg, + ) + } +} diff --git a/app/src/main/java/com/lastwave/app/util/FileExportHelper.kt b/app/src/main/java/com/lastwave/app/util/FileExportHelper.kt index 13bac8426b..f546f570d4 100644 --- a/app/src/main/java/com/lastwave/app/util/FileExportHelper.kt +++ b/app/src/main/java/com/lastwave/app/util/FileExportHelper.kt @@ -9,6 +9,10 @@ import android.net.Uri import android.os.Build import android.os.Environment import android.provider.MediaStore +import android.app.Activity +import android.content.ClipData +import android.content.ContextWrapper +import android.graphics.Bitmap import androidx.core.content.ContextCompat import androidx.core.content.FileProvider import com.lastwave.app.data.generate.GeneratedTrack @@ -162,6 +166,139 @@ class FileExportHelper @Inject constructor( context.startActivity(Intent.createChooser(intent, "Share").addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) } + /** + * Unwraps [Context] hierarchy to find an [Activity] context for launching share dialogs. + */ + private fun findActivity(context: Context): Activity? { + var ctx = context + while (ctx is ContextWrapper) { + if (ctx is Activity) return ctx + ctx = ctx.baseContext + } + return null + } + + /** + * Cache hygiene for share cards: purges files older than 24h and enforces a 10-file cap. + */ + fun cleanLyricsCardCache(cacheDir: File) { + val dir = File(cacheDir, "shared/lyrics_cards") + if (!dir.exists()) return + val files = dir.listFiles() ?: return + val now = System.currentTimeMillis() + val maxAge = 24 * 60 * 60 * 1000L + + for (file in files) { + if (now - file.lastModified() > maxAge) { + file.delete() + } + } + + val remaining = dir.listFiles() ?: return + if (remaining.size > 10) { + val sorted = remaining.sortedBy { it.lastModified() } + val excess = remaining.size - 10 + for (i in 0 until excess) { + sorted[i].delete() + } + } + } + + /** + * Exports a rendered bitmap to cacheDir/shared/lyrics_cards and triggers the system + * share sheet via FileProvider with image/png and ClipData uri grant. + */ + suspend fun shareImage( + activityContext: Context, + bitmap: Bitmap, + title: String, + ): Result = withContext(Dispatchers.IO) { + try { + cleanLyricsCardCache(context.cacheDir) + val dir = File(context.cacheDir, "shared/lyrics_cards") + if (!dir.exists()) dir.mkdirs() + + val sanitized = sanitizeFilename(title) + val timestamp = System.currentTimeMillis() + val file = File(dir, "lyrics_${sanitized}_$timestamp.png") + + file.outputStream().use { out -> + bitmap.compress(Bitmap.CompressFormat.PNG, 100, out) + out.flush() + } + + val authority = "${context.packageName}.provider" + val uri = FileProvider.getUriForFile(context, authority, file) + + val intent = Intent(Intent.ACTION_SEND).apply { + type = "image/png" + putExtra(Intent.EXTRA_STREAM, uri) + clipData = ClipData.newRawUri("Lyrics Card", uri) + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } + + val chooser = Intent.createChooser(intent, "Share lyrics").apply { + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + } + + val activity = findActivity(activityContext) + if (activity != null) { + activity.startActivity(chooser) + } else { + context.startActivity(chooser) + } + + Result.success(Unit) + } catch (e: Exception) { + Result.failure(e) + } + } + + /** + * Saves a rendered card bitmap to Pictures/LastWave via MediaStore.Images + * with IS_PENDING handling for API 29+. + */ + suspend fun saveImageToGallery( + bitmap: Bitmap, + title: String, + ): Result = withContext(Dispatchers.IO) { + try { + val resolver = context.contentResolver + val sanitized = sanitizeFilename(title) + val filename = "lyrics_${sanitized}_${System.currentTimeMillis()}.png" + val relativePath = "${Environment.DIRECTORY_PICTURES}/LastWave" + + val values = ContentValues().apply { + put(MediaStore.Images.Media.DISPLAY_NAME, filename) + put(MediaStore.Images.Media.MIME_TYPE, "image/png") + put(MediaStore.Images.Media.RELATIVE_PATH, relativePath) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + put(MediaStore.Images.Media.IS_PENDING, 1) + } + } + + val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values) + ?: throw IOException("Failed to create MediaStore entry for $filename") + + resolver.openOutputStream(uri)?.use { out -> + bitmap.compress(Bitmap.CompressFormat.PNG, 100, out) + out.flush() + } ?: throw IOException("Failed to open output stream for $uri") + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { + val updateValues = ContentValues().apply { + put(MediaStore.Images.Media.IS_PENDING, 0) + } + resolver.update(uri, updateValues, null, null) + } + + Result.success(uri) + } catch (e: Exception) { + Result.failure(e) + } + } + fun sanitizeFilename(title: String): String = title.replace(Regex("[\\\\/:*?\"<>|]"), "_").trim().ifBlank { "playlist" } diff --git a/app/src/main/res/drawable/ic_lastwave_logo_mono.xml b/app/src/main/res/drawable/ic_lastwave_logo_mono.xml new file mode 100644 index 0000000000..aec5603849 --- /dev/null +++ b/app/src/main/res/drawable/ic_lastwave_logo_mono.xml @@ -0,0 +1,18 @@ + + + + + + diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 1f32b55fc8..e02bd55b3c 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -258,4 +258,33 @@ عشوائي تكرار تشغيل أو إيقاف + + + مشاركة الكلمات + تحديد الكلمات + تم تحديد %1$d أسطر + تم تحديد سطر واحد + يمكنك مشاركة ما يصل إلى 5 أسطر + متابعة + أغنية + كلمات + مشاركة + حفظ + تم الحفظ في Pictures/LastWave + تعذر حفظ الصورة + تعذر مشاركة الصورة + مشاركة الكلمات + إغلاق + رجوع + لوحة الألوان + لون الأغنية + خافت + سائد + داكن + أبيض + أسود + لون مميز + ليموني LastWave + محدد، السطر %1$d من %2$d + السطر %1$d من %2$d diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index cc5a84a0ba..fd4966c1d4 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -258,4 +258,33 @@ Zufällig Wiederholen Abspielen oder pausieren + + + Songtext teilen + Songtext auswählen + %1$d Zeilen ausgewählt + 1 Zeile ausgewählt + Du kannst bis zu 5 Zeilen teilen + Weiter + Titel + Songtext + Teilen + Speichern + In Bilder/LastWave gespeichert + Bild konnte nicht gespeichert werden + Bild konnte nicht geteilt werden + Songtext teilen + Schließen + Zurück + Farbpalette + Titelfarbe + Dezente Farbe + Dominante Farbe + Dunkel + Weiß + Schwarz + Akzent + LastWave Limette + Ausgewählt, Zeile %1$d von %2$d + Zeile %1$d von %2$d diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 5cde261fe6..cad91070ac 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -258,4 +258,33 @@ Aleatorio Repetir Reproducir o pausar + + + Compartir letras + Seleccionar letras + %1$d líneas seleccionadas + 1 línea seleccionada + Puedes compartir hasta 5 líneas + Continuar + Canción + Letras + Compartir + Guardar + Guardado en Imágenes/LastWave + No se pudo guardar la imagen + No se pudo compartir la imagen + Compartir letras + Cerrar + Atrás + Paleta de colores + Color de la canción + Apagado + Dominante + Oscuro + Blanco + Negro + Acento + Lima LastWave + Seleccionada, línea %1$d de %2$d + Línea %1$d de %2$d diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 98e4f24df4..f014f7b7ac 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -331,4 +331,33 @@ sortie DIRECT Copier le diagnostic USB Diagnostic USB copié — colle-le dans un message + + + Partager les paroles + Sélectionner les paroles + %1$d lignes sélectionnées + 1 ligne sélectionnée + Vous pouvez partager jusqu\'à 5 lignes + Continuer + Titre + Paroles + Partager + Enregistrer + Enregistré dans Images/LastWave + Impossible d\'enregistrer l\'image + Impossible de partager l\'image + Partager les paroles + Fermer + Retour + Palette de couleurs + Couleur du morceau + Atténuée + Dominante + Sombre + Blanc + Noir + Accent + Citron vert LastWave + Sélectionnée, ligne %1$d sur %2$d + Ligne %1$d sur %2$d diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index ca505407c3..f357274dbc 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -258,4 +258,33 @@ शफ़ल दोहराएँ चलाएँ या रोकें + + + बोल साझा करें + बोल चुनें + %1$d पंक्तियाँ चुनी गईं + 1 पंक्ति चुनी गई + आप अधिकतम 5 पंक्तियाँ साझा कर सकते हैं + आगे बढ़ें + गाना + बोल + साझा करें + सहेजें + Pictures/LastWave में सहेजा गया + छवि सहेजी नहीं जा सकी + छवि साझा नहीं की जा सकी + बोल साझा करें + बंद करें + वापस + रंग पैलेट + गाने का रंग + हल्का + प्रमुख + गहरा + सफ़ेद + काला + एक्सेंट + लास्टवेव लाइम + चयनित, पंक्ति %1$d / %2$d + पंक्ति %1$d / %2$d diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index b237bab2fb..be40857bc4 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -258,4 +258,33 @@ Acak Ulangi Putar atau jeda + + + Bagikan Lirik + Pilih Lirik + %1$d baris dipilih + 1 baris dipilih + Anda dapat membagikan hingga 5 baris + Lanjutkan + Lagu + Lirik + Bagikan + Simpan + Disimpan ke Pictures/LastWave + Gagal menyimpan gambar + Gagal membagikan gambar + Bagikan lirik + Tutup + Kembali + Palet warna + Warna lagu + Lembut + Dominan + Gelap + Putih + Hitam + Aksen + LastWave Lime + Dipilih, baris %1$d dari %2$d + Baris %1$d dari %2$d diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 4e94930faa..b0a9b511ef 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -258,4 +258,33 @@ シャッフル リピート 再生 / 一時停止 + + + 歌詞を共有 + 歌詞を選択 + %1$d 行選択中 + 1 行選択中 + 最大5行まで共有できます + 次へ + 楽曲 + 歌詞 + 共有 + 保存 + Pictures/LastWave に保存しました + 画像を保存できませんでした + 画像を共有できませんでした + 歌詞を共有 + 閉じる + 戻る + カラーパレット + 楽曲カラー + 落ち着いた色 + メインカラー + ダーク + ホワイト + ブラック + アクセント + LastWave ライム + 選択中、%1$d / %2$d 行目 + %1$d / %2$d 行目 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index c16f0e636f..aef7bc13cc 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -258,4 +258,33 @@ 셔플 반복 재생 또는 일시정지 + + + 가사 공유 + 가사 선택 + %1$d줄 선택됨 + 1줄 선택됨 + 최대 5줄까지 공유할 수 있습니다 + 계속 + 곡 + 가사 + 공유 + 저장 + Pictures/LastWave에 저장되었습니다 + 이미지를 저장하지 못했습니다 + 이미지를 공유하지 못했습니다 + 가사 공유 + 닫기 + 뒤로 + 색상 팔레트 + 곡 색상 + 뮤트 + 도미넌트 + 다크 + 화이트 + 블랙 + 강조 색상 + 라스트웨이브 라임 + 선택됨, %2$d줄 중 %1$d번째 줄 + %2$d줄 중 %1$d번째 줄 diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index db6e647b4d..14b9e23d4f 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -258,4 +258,33 @@ Aleatório Repetir Tocar ou pausar + + + Compartilhar letra + Selecionar letra + %1$d linhas selecionadas + 1 linha selecionada + Você pode compartilhar até 5 linhas + Continuar + Música + Letra + Compartilhar + Salvar + Salvo em Pictures/LastWave + Não foi possível salvar a imagem + Não foi possível compartilhar a imagem + Compartilhar letra + Fechar + Voltar + Paleta de cores + Cor da música + Suave + Dominante + Escuro + Branco + Preto + Destaque + Lima LastWave + Selecionada, linha %1$d de %2$d + Linha %1$d de %2$d diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index dba061b3f6..b9cfc93854 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -258,4 +258,33 @@ Перемешать Повтор Играть или пауза + + + Поделиться текстом + Выбрать строки + Выбрано строк: %1$d + Выбрана 1 строка + Можно поделиться не более чем 5 строками + Продолжить + Трек + Текст + Поделиться + Сохранить + Сохранено в Pictures/LastWave + Не удалось сохранить изображение + Не удалось поделиться изображением + Поделиться текстом + Закрыть + Назад + Цветовая палитра + Цвет трека + Приглушённый + Основной + Тёмный + Белый + Чёрный + Акцент + Лайм LastWave + Выбрана, строка %1$d из %2$d + Строка %1$d из %2$d diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index c6654b88bf..e0939d6d0c 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -1065,4 +1065,33 @@ Misafir modu yerel önerilerle tamamen çevrimdışı çalışır. Scrobble’ları eşitlemek için Ayarlardan istediğiniz zaman Last.fm bağlayın. Yedeği geri yükle Çevrimdışı İndirilenleri Aç + + + Şarkı sözü paylaş + Sözleri seç + %1$d satır seçildi + 1 satır seçildi + En fazla 5 satır paylaşabilirsiniz + Devam et + Şarkı + Sözler + Paylaş + Kaydet + Pictures/LastWave klasörüne kaydedildi + Görsel kaydedilemedi + Görsel paylaşılamadı + Şarkı sözü paylaş + Kapat + Geri + Renk paleti + Şarkı rengi + Sakin + Baskın + Koyu + Beyaz + Siyah + Vurgu + LastWave Limon Yeşili + Seçildi, %1$d / %2$d. satır + %1$d / %2$d. satır diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 2a7c146a8a..35cff68a4e 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -261,4 +261,33 @@ 随机播放 重复 播放或暂停 + + + 分享歌词 + 选择歌词 + 已选 %1$d 行 + 已选 1 行 + 最多可分享 5 行歌词 + 继续 + 歌曲 + 歌词 + 分享 + 保存 + 已保存至 Pictures/LastWave + 保存图片失败 + 分享图片失败 + 分享歌词 + 关闭 + 返回 + 调色盘 + 歌曲颜色 + 柔和 + 主色 + 深色 + 白色 + 黑色 + 强调色 + LastWave 青柠 + 已选中，第 %1$d 行（共 %2$d 行） + 第 %1$d 行（共 %2$d 行） diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 204006d86a..79e393abdb 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1090,4 +1090,33 @@ Guest mode works fully offline with local recommendations. Connect Last.fm anytime in Settings to sync scrobbles. Restore backup Open Offline Downloads + + + Share lyrics + Select lyrics + %1$d lines selected + 1 line selected + You can share up to 5 lines + Continue + Song + Lyrics + Share + Save + Saved to Pictures/LastWave + Couldn\'t save image + Couldn\'t share image + Share lyrics + Close + Back + Color palette + Song color + Muted + Dominant + Dark + White + Black + Accent + LastWave Lime + Selected, line %1$d of %2$d + Line %1$d of %2$d diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolutionOrderTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolutionOrderTest.kt new file mode 100644 index 0000000000..c8d4a39041 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ArtworkResolutionOrderTest.kt @@ -0,0 +1,83 @@ +package com.lastwave.app.ui.player.lyricsshare + +import com.google.common.truth.Truth.assertThat +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class ArtworkResolutionOrderTest { + + @Test + fun determineArtworkUrl_localFile_takesPrecedence() { + val track = TrackInfo( + title = "Local Song", + artist = "Local Artist", + artworkUrl = "file:///storage/emulated/0/Music/cover.jpg", + resolvedArtworkUrl = "https://i.ytimg.com/vi/123/hqdefault.jpg", + ) + val url = ArtworkResolver.determineArtworkUrl(track) + assertThat(url).isEqualTo("file:///storage/emulated/0/Music/cover.jpg") + } + + @Test + fun determineArtworkUrl_trackArtworkUrl_takesPrecedenceOverResolved() { + val track = TrackInfo( + title = "Online Song", + artist = "Artist", + artworkUrl = "https://lh3.googleusercontent.com/track_art=w544-h544", + resolvedArtworkUrl = "https://lh3.googleusercontent.com/ambient_art=w544-h544", + ) + val url = ArtworkResolver.determineArtworkUrl(track) + assertThat(url).contains("track_art") + } + + @Test + fun determineArtworkUrl_resolvedAmbientUsedWhenTrackUrlIsBlankOrPlaceholder() { + val track = TrackInfo( + title = "Online Song", + artist = "Artist", + artworkUrl = "", // Blank + resolvedArtworkUrl = "https://lh3.googleusercontent.com/ambient_art=w544-h544", + ) + val url = ArtworkResolver.determineArtworkUrl(track) + assertThat(url).contains("ambient_art") + } + + @Test + fun determineArtworkUrl_upscalesYouTubeUrls() { + val track = TrackInfo( + title = "YouTube Song", + artist = "Artist", + artworkUrl = "https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg", + resolvedArtworkUrl = null, + ) + val url = ArtworkResolver.determineArtworkUrl(track) + // ArtworkNormalizer upscales hqdefault to maxresdefault + assertThat(url).contains("maxresdefault.jpg") + } + + @Test + fun determineArtworkUrl_returnsNullWhenNoValidArtwork() { + val track = TrackInfo( + title = "No Art", + artist = "Artist", + artworkUrl = null, + resolvedArtworkUrl = null, + ) + val url = ArtworkResolver.determineArtworkUrl(track) + assertThat(url).isNull() + } + + @Test + fun createBrandFallbackGradient_returnsValidBitmap() { + val gradient = ArtworkResolver.createBrandFallbackGradient( + accentColor = ColorContrastHelper.BRAND_LIME, + width = 100, + height = 100, + ) + assertThat(gradient).isNotNull() + assertThat(gradient.width).isEqualTo(100) + assertThat(gradient.height).isEqualTo(100) + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/CacheHygieneTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/CacheHygieneTest.kt new file mode 100644 index 0000000000..8c3047d430 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/CacheHygieneTest.kt @@ -0,0 +1,75 @@ +package com.lastwave.app.ui.player.lyricsshare + +import com.google.common.truth.Truth.assertThat +import com.lastwave.app.util.FileExportHelper +import io.mockk.mockk +import java.io.File +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder + +class CacheHygieneTest { + + @get:Rule + val tempFolder = TemporaryFolder() + + private val helper = FileExportHelper(mockk(relaxed = true)) + + @Test + fun cleanLyricsCardCache_purgesFilesOlderThan24Hours() { + val cacheDir = tempFolder.newFolder("cache") + val lyricsDir = File(cacheDir, "shared/lyrics_cards").apply { mkdirs() } + + val oldFile = File(lyricsDir, "lyrics_old.png").apply { + createNewFile() + // Set last modified to 25 hours ago + setLastModified(System.currentTimeMillis() - 25 * 60 * 60 * 1000L) + } + + val freshFile = File(lyricsDir, "lyrics_fresh.png").apply { + createNewFile() + setLastModified(System.currentTimeMillis()) + } + + helper.cleanLyricsCardCache(cacheDir) + + assertThat(oldFile.exists()).isFalse() + assertThat(freshFile.exists()).isTrue() + } + + @Test + fun cleanLyricsCardCache_enforcesTenFileCap_evictingOldestFirst() { + val cacheDir = tempFolder.newFolder("cache") + val lyricsDir = File(cacheDir, "shared/lyrics_cards").apply { mkdirs() } + + val now = System.currentTimeMillis() + val files = (1..15).map { i -> + File(lyricsDir, "lyrics_$i.png").apply { + createNewFile() + setLastModified(now - (16 - i) * 1000L) // file 1 is oldest, 15 is newest + } + } + + helper.cleanLyricsCardCache(cacheDir) + + val remaining = lyricsDir.listFiles() ?: emptyArray() + assertThat(remaining).hasLength(10) + + // Oldest 5 (1..5) should have been deleted + for (i in 1..5) { + assertThat(File(lyricsDir, "lyrics_$i.png").exists()).isFalse() + } + // Newest 10 (6..15) should remain + for (i in 6..15) { + assertThat(File(lyricsDir, "lyrics_$i.png").exists()).isTrue() + } + } + + @Test + fun sanitizeFilename_stripsSpecialCharactersAndEnforcesFallback() { + assertThat(helper.sanitizeFilename("Song / Title: With * Illegal? |")).isEqualTo("Song _ Title_ With _ Illegal_ _Chars_ _") + assertThat(helper.sanitizeFilename("")).isEqualTo("playlist") + assertThat(helper.sanitizeFilename(" ")).isEqualTo("playlist") + assertThat(helper.sanitizeFilename("Clean Song Title")).isEqualTo("Clean Song Title") + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt new file mode 100644 index 0000000000..d695a93883 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt @@ -0,0 +1,124 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.graphics.Bitmap +import com.google.common.truth.Truth.assertThat +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class ColorContrastHelperTest { + + @Test + fun relativeLuminance_pureWhiteAndBlack() { + val whiteLum = ColorContrastHelper.relativeLuminance(ColorContrastHelper.PURE_WHITE) + val blackLum = ColorContrastHelper.relativeLuminance(0xFF000000.toInt()) + + assertThat(whiteLum).isWithin(0.01).of(1.0) + assertThat(blackLum).isWithin(0.001).of(0.0) + } + + @Test + fun contrastRatio_whiteOnBlack_isNearMax21() { + val ratio = ColorContrastHelper.contrastRatio(0xFFFFFFFF.toInt(), 0xFF000000.toInt()) + assertThat(ratio).isAtLeast(20.0) + } + + @Test + fun deriveTextColors_onPureBlack_meetsWcagAaRequirements() { + val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.PURE_BLACK) + + assertThat(derived.isDarkBackground).isTrue() + + // Lyrics contrast must be >= 4.5:1 (WCAG AA) + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(4.5) + + // Secondary text contrast must be >= 3.0:1 + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(3.0) + } + + @Test + fun deriveTextColors_onPureWhite_meetsWcagAaRequirements() { + val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.PURE_WHITE) + + assertThat(derived.isDarkBackground).isFalse() + + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(4.5) + + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(3.0) + } + + @Test + fun deriveTextColors_onBrandLime_meetsWcagAaRequirements() { + // Brand lime is 0xFFC9FB00, high luminance (light background) + val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.BRAND_LIME) + + assertThat(derived.isDarkBackground).isFalse() + + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(4.5) + + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(3.0) + } + + @Test + fun deriveTextColors_onDarkSlate_meetsWcagAaRequirements() { + val darkSlate = 0xFF1E293B.toInt() + val derived = ColorContrastHelper.deriveTextColors(darkSlate) + + assertThat(derived.isDarkBackground).isTrue() + + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(4.5) + + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(3.0) + } + + @Test + fun extractSwatches_alwaysReturns8DistinctSwatches() { + val swatches = ColorContrastHelper.extractSwatches( + artBitmap = null, + themeAccentColor = 0xFF38BDF8.toInt(), + ) + + assertThat(swatches).hasSize(8) + + val ids = swatches.map { it.id } + assertThat(ids).containsExactly( + "song_vibrant", + "muted", + "dominant", + "dark", + "white", + "black", + "accent", + "brand", + ).inOrder() + + // Brand Lime and Accent swatch colors present + val brandSwatch = swatches.first { it.id == "brand" } + assertThat(brandSwatch.color).isEqualTo(ColorContrastHelper.BRAND_LIME) + + val accentSwatch = swatches.first { it.id == "accent" } + assertThat(accentSwatch.color).isEqualTo(0xFF38BDF8.toInt()) + } + + @Test + fun extractSwatches_withBitmap_extractsColorsSafely() { + val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888) + bitmap.eraseColor(0xFFFF5722.toInt()) // Deep orange + + val swatches = ColorContrastHelper.extractSwatches( + artBitmap = bitmap, + themeAccentColor = 0xFF38BDF8.toInt(), + ) + + assertThat(swatches).hasSize(8) + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/LyricsSelectionTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/LyricsSelectionTest.kt new file mode 100644 index 0000000000..574b5a9ee2 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/LyricsSelectionTest.kt @@ -0,0 +1,167 @@ +package com.lastwave.app.ui.player.lyricsshare + +import com.google.common.truth.Truth.assertThat +import com.lastwave.app.data.lyrics.LyricLine +import com.lastwave.app.ui.player.LyricsUiState +import org.junit.Test + +class LyricsSelectionTest { + + private val sampleTrack = TrackInfo( + title = "Starboy", + artist = "The Weeknd", + artworkUrl = "https://example.com/art.jpg", + ) + + @Test + fun buildLyricsSnapshot_synced_filtersBlankLines() { + val lines = listOf( + LyricLine(timeMs = 1000L, text = "I'm tryna put you in the worst mood, ah"), + LyricLine(timeMs = 3000L, text = " "), + LyricLine(timeMs = 5000L, text = ""), + LyricLine(timeMs = 7000L, text = "P1 cleaner than your church shoes, ah"), + ) + val state = LyricsUiState.Success( + lines = lines, + isSynced = true, + ) + + val snapshot = buildLyricsSnapshot(state, sampleTrack, currentActiveIndex = 0) + + assertThat(snapshot).isNotNull() + assertThat(snapshot!!.lines).hasSize(2) + assertThat(snapshot.lines[0].text).isEqualTo("I'm tryna put you in the worst mood, ah") + assertThat(snapshot.lines[0].originalIndex).isEqualTo(0) + assertThat(snapshot.lines[1].text).isEqualTo("P1 cleaner than your church shoes, ah") + assertThat(snapshot.lines[1].originalIndex).isEqualTo(3) + } + + @Test + fun buildLyricsSnapshot_plainLyrics_splitsOnNewlinesAndDiscardsEmpty() { + val plain = "First line\n\n \nSecond line\nThird line\n" + val state = LyricsUiState.Success( + lines = emptyList(), + isSynced = false, + plainLyrics = plain, + ) + + val snapshot = buildLyricsSnapshot(state, sampleTrack) + + assertThat(snapshot).isNotNull() + assertThat(snapshot!!.lines).hasSize(3) + assertThat(snapshot.lines.map { it.text }).containsExactly("First line", "Second line", "Third line").inOrder() + } + + @Test + fun buildLyricsSnapshot_instrumental_returnsNull() { + val state = LyricsUiState.Success( + lines = emptyList(), + isSynced = true, + isInstrumental = true, + ) + + val snapshot = buildLyricsSnapshot(state, sampleTrack) + assertThat(snapshot).isNull() + } + + @Test + fun buildLyricsSnapshot_empty_returnsNull() { + val state = LyricsUiState.Success( + lines = emptyList(), + isSynced = true, + ) + + val snapshot = buildLyricsSnapshot(state, sampleTrack) + assertThat(snapshot).isNull() + } + + @Test + fun computeDefaultSelection_centersOnActiveIndex() { + // 10 lines, active is index 5 -> window of 3 centered around 5: [4..6] + val range = computeDefaultSelection(totalLines = 10, activeIndex = 5) + assertThat(range).isEqualTo(4..6) + + // Near start: active is 0 -> [0..2] + val rangeStart = computeDefaultSelection(totalLines = 10, activeIndex = 0) + assertThat(rangeStart).isEqualTo(0..2) + + // Near end: active is 9 -> [7..9] + val rangeEnd = computeDefaultSelection(totalLines = 10, activeIndex = 9) + assertThat(rangeEnd).isEqualTo(7..9) + + // Invalid activeIndex -> starts at top [0..2] + val rangeInvalid = computeDefaultSelection(totalLines = 10, activeIndex = -1) + assertThat(rangeInvalid).isEqualTo(0..2) + + // Less than 3 lines total: selects all available lines + val rangeSmall = computeDefaultSelection(totalLines = 2, activeIndex = 1) + assertThat(rangeSmall).isEqualTo(0..1) + } + + @Test + fun updateContiguousSelection_extendsAdjacentLines() { + var capCalled = false + val initial = 2..3 + + // Extend after + val extendedAfter = updateContiguousSelection(initial, tappedIndex = 4, totalLines = 10) { capCalled = true } + assertThat(extendedAfter).isEqualTo(2..4) + assertThat(capCalled).isFalse() + + // Extend before + val extendedBefore = updateContiguousSelection(initial, tappedIndex = 1, totalLines = 10) { capCalled = true } + assertThat(extendedBefore).isEqualTo(1..3) + assertThat(capCalled).isFalse() + } + + @Test + fun updateContiguousSelection_shrinksEdges() { + val initial = 2..4 + + // Shrink start + val shrinkStart = updateContiguousSelection(initial, tappedIndex = 2, totalLines = 10) + assertThat(shrinkStart).isEqualTo(3..4) + + // Shrink end + val shrinkEnd = updateContiguousSelection(initial, tappedIndex = 4, totalLines = 10) + assertThat(shrinkEnd).isEqualTo(2..3) + } + + @Test + fun updateContiguousSelection_singleLineDoesNotShrinkToZero() { + val initial = 3..3 + val result = updateContiguousSelection(initial, tappedIndex = 3, totalLines = 10) + assertThat(result).isEqualTo(3..3) + } + + @Test + fun updateContiguousSelection_tappingInnerLineRestartsSelection() { + val initial = 1..5 + val result = updateContiguousSelection(initial, tappedIndex = 3, totalLines = 10) + assertThat(result).isEqualTo(3..3) + } + + @Test + fun updateContiguousSelection_tappingNonAdjacentLineRestartsSelection() { + val initial = 2..3 + val result = updateContiguousSelection(initial, tappedIndex = 7, totalLines = 10) + assertThat(result).isEqualTo(7..7) + } + + @Test + fun updateContiguousSelection_capsAtMaxFiveLines() { + var capCalled = false + val fiveLines = 1..5 + + val result = updateContiguousSelection( + currentRange = fiveLines, + tappedIndex = 6, + totalLines = 10, + maxLines = 5, + onCapReached = { capCalled = true }, + ) + + assertThat(result).isEqualTo(1..5) + assertThat(capCalled).isTrue() + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt new file mode 100644 index 0000000000..c2874d3395 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt @@ -0,0 +1,73 @@ +package com.lastwave.app.ui.player.lyricsshare + +import com.google.common.truth.Truth.assertThat +import kotlin.math.roundToInt +import org.junit.Test + +class ShareCardMathTest { + + @Test + fun cardDimensions_target1080_clampsBetween4to5And9to16() { + val targetWidth = 1080 + val scale = 1.0f + + val width = (targetWidth * scale).roundToInt().coerceAtLeast(320) + val minH = ((targetWidth * 5 / 4) * scale).roundToInt() + val maxH = ((targetWidth * 16 / 9) * scale).roundToInt() + + assertThat(width).isEqualTo(1080) + // 4:5 ratio -> 1080 x 1350 + assertThat(minH).isEqualTo(1350) + // 9:16 ratio -> 1080 x 1920 + assertThat(maxH).isEqualTo(1920) + + // Short lyrics should clamp to 1350 (4:5) + val measuredShort = 900 + val clampedShort = measuredShort.coerceIn(minH, maxH) + assertThat(clampedShort).isEqualTo(1350) + + // Long lyrics should clamp to 1920 (9:16) + val measuredLong = 2400 + val clampedLong = measuredLong.coerceIn(minH, maxH) + assertThat(clampedLong).isEqualTo(1920) + + // Intermediate lyrics stays within bounds + val measuredMid = 1600 + val clampedMid = measuredMid.coerceIn(minH, maxH) + assertThat(clampedMid).isEqualTo(1600) + } + + @Test + fun cardDimensions_scaled075_preservesAspectBounds() { + val targetWidth = 1080 + val scale = 0.75f + + val width = (targetWidth * scale).roundToInt().coerceAtLeast(320) + val minH = ((targetWidth * 5 / 4) * scale).roundToInt() + val maxH = ((targetWidth * 16 / 9) * scale).roundToInt() + + assertThat(width).isEqualTo(810) + assertThat(minH).isEqualTo(1013) + assertThat(maxH).isEqualTo(1440) + + val ratioMin = width.toDouble() / minH + assertThat(ratioMin).isWithin(0.01).of(4.0 / 5.0) + + val ratioMax = width.toDouble() / maxH + assertThat(ratioMax).isWithin(0.01).of(9.0 / 16.0) + } + + @Test + fun truncateEllipsis_keepsTextUnderLimit() { + val longTitle = "A".repeat(100) + val maxChars = 40 + val truncated = if (longTitle.length > maxChars) { + longTitle.take(maxChars - 1) + "…" + } else { + longTitle + } + + assertThat(truncated).hasLength(40) + assertThat(truncated).endsWith("…") + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt new file mode 100644 index 0000000000..fdf34751ef --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt @@ -0,0 +1,151 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.content.Context +import android.graphics.Bitmap +import com.google.common.truth.Truth.assertThat +import kotlinx.coroutines.test.runTest +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment + +@RunWith(RobolectricTestRunner::class) +class ShareCardRendererTest { + + private lateinit var context: Context + private lateinit var sampleCover: Bitmap + private lateinit var sampleBlur: Bitmap + + @Before + fun setUp() { + context = RuntimeEnvironment.getApplication() + sampleCover = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888).apply { + eraseColor(0xFF2563EB.toInt()) + } + sampleBlur = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888).apply { + eraseColor(0xFF1E293B.toInt()) + } + } + + @Test + fun renderSongCard_withCoverArt_rendersSuccessfully() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Song, + lines = listOf( + ShareLine("I feel it coming", isRtl = false), + ShareLine("I feel it coming, babe", isRtl = false), + ), + title = "I Feel It Coming", + artist = "The Weeknd ft. Daft Punk", + coverBitmap = sampleCover, + swatchColor = ColorContrastHelper.BRAND_LIME, + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + assertThat(bitmap.height).isAtMost(720 * 16 / 9) + } + + @Test + fun renderSongCard_noArt_rendersWithFallback() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Song, + lines = listOf( + ShareLine("No artwork line 1", isRtl = false), + ShareLine("No artwork line 2", isRtl = false), + ), + title = "Acapella Song", + artist = "Vocalist", + coverBitmap = null, + swatchColor = 0xFF12161A.toInt(), + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderLyricsCard_withBlurredBackground_rendersSuccessfully() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("First verse line", isRtl = false), + ShareLine("Second verse line", isRtl = false), + ShareLine("Chorus climax line", isRtl = false), + ), + title = "Blinding Lights", + artist = "The Weeknd", + coverBitmap = sampleCover, + blurredBackgroundBitmap = sampleBlur, + swatchColor = ColorContrastHelper.BRAND_LIME, + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + } + + @Test + fun renderLyricsCard_fallbackBackdrop_rendersSuccessfully() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("Solo line", isRtl = false), + ), + title = "Acoustic Solo", + artist = "Guitarist", + coverBitmap = null, + blurredBackgroundBitmap = null, + swatchColor = 0xFF0F172A.toInt(), + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderMultilingual_latinDevanagariArabicCjkAndLongLines() = runTest { + val multilingualLines = listOf( + ShareLine("Never gonna give you up (Latin)", isRtl = false), + ShareLine("तू ही मेरी मंज़िल, पहचान भी तू (Devanagari)", isRtl = false), + ShareLine("أراك عصي الدمع شيمتك الصبر (Arabic)", isRtl = true), + ShareLine("夜に駆ける 沈むように溶けてゆくように (CJK)", isRtl = false), + ShareLine( + "This is an exceptionally long lyric line designed specifically to wrap onto multiple lines and test StaticLayout bounds handling without clipping or overflow", + isRtl = false, + ), + ) + + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = multilingualLines, + title = "Global Harmony", + artist = "World Artists Ensemble", + coverBitmap = sampleCover, + blurredBackgroundBitmap = sampleBlur, + swatchColor = ColorContrastHelper.BRAND_LIME, + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + assertThat(bitmap.height).isAtMost(720 * 16 / 9) + } +} diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareIntentTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareIntentTest.kt new file mode 100644 index 0000000000..37a5c84258 --- /dev/null +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareIntentTest.kt @@ -0,0 +1,88 @@ +package com.lastwave.app.ui.player.lyricsshare + +import android.content.Context +import android.content.Intent +import android.graphics.Bitmap +import android.net.Uri +import androidx.core.content.FileProvider +import com.google.common.truth.Truth.assertThat +import com.lastwave.app.util.FileExportHelper +import io.mockk.every +import io.mockk.mockkStatic +import io.mockk.unmockkStatic +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf + +@RunWith(RobolectricTestRunner::class) +class ShareIntentTest { + + private lateinit var context: Context + private lateinit var fileExportHelper: FileExportHelper + private lateinit var sampleBitmap: Bitmap + + @Before + fun setUp() { + context = RuntimeEnvironment.getApplication() + fileExportHelper = FileExportHelper(context) + sampleBitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888).apply { + eraseColor(0xFFC9FB00.toInt()) + } + } + + @After + fun tearDown() { + unmockkStatic(FileProvider::class) + } + + @Test + fun shareImage_constructsValidSendIntentWithFileProviderStreamAndFlags() = runTest { + mockkStatic(FileProvider::class) + val expectedUri = Uri.parse("content://${context.packageName}.provider/shared/lyrics_cards/test.png") + every { FileProvider.getUriForFile(any(), any(), any()) } returns expectedUri + + val result = fileExportHelper.shareImage( + activityContext = context, + bitmap = sampleBitmap, + title = "Test Song", + ) + + assertThat(result.isSuccess).isTrue() + + val nextIntent = shadowOf(context as android.app.Application).nextStartedActivity + assertThat(nextIntent).isNotNull() + assertThat(nextIntent.action).isEqualTo(Intent.ACTION_CHOOSER) + + val targetIntent = nextIntent.getParcelableExtra(Intent.EXTRA_INTENT) + assertThat(targetIntent).isNotNull() + assertThat(targetIntent!!.action).isEqualTo(Intent.ACTION_SEND) + assertThat(targetIntent.type).isEqualTo("image/png") + + val streamUri = targetIntent.getParcelableExtra(Intent.EXTRA_STREAM) + assertThat(streamUri).isEqualTo(expectedUri) + assertThat(streamUri!!.scheme).isEqualTo("content") + assertThat(streamUri.authority).isEqualTo("${context.packageName}.provider") + + // Read URI permission flag must be present + val flags = targetIntent.flags + assertThat(flags and Intent.FLAG_GRANT_READ_URI_PERMISSION).isNotEqualTo(0) + } + + @Test + fun saveImageToGallery_insertsIntoMediaStoreAndReturnsContentUri() = runTest { + val result = fileExportHelper.saveImageToGallery( + bitmap = sampleBitmap, + title = "Saved Lyrics Card", + ) + + assertThat(result.isSuccess).isTrue() + val uri = result.getOrNull() + assertThat(uri).isNotNull() + assertThat(uri!!.scheme).isEqualTo("content") + } +} From 7ff4b9266a5e42b2ae508b2f59d0a24ce81e5719 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 14:41:55 +0530 Subject: [PATCH 02/10] docs: add share lyrics feature report --- SHARE_LYRICS_REPORT.md | 187 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 SHARE_LYRICS_REPORT.md diff --git a/SHARE_LYRICS_REPORT.md b/SHARE_LYRICS_REPORT.md new file mode 100644 index 0000000000..d65d93319c --- /dev/null +++ b/SHARE_LYRICS_REPORT.md @@ -0,0 +1,187 @@ +# LastWave - Share Lyrics Feature Report + +**Branch:** `feature/share-lyrics` +**Base:** `main` (commit `ed3b0c2`) +**Package:** `com.lastwave.app.ui.player.lyricsshare` + +--- + +## 1. Executive Summary + +The **Share Lyrics** add-on has been implemented in LastWave Native Android. The feature provides an elegant, high-fidelity export and sharing experience inspired by **Spotify's lyrics card styling** paired with **YouTube Music's dynamic palette color picker**. + +The implementation strictly followed the **Prime Directive: Add-On Only**. No existing public interfaces or player flows were broken or rewritten. All new domain, rendering, and UI logic lives cleanly in a self-contained package (`com.lastwave.app.ui.player.lyricsshare`), accompanied by thorough automated unit, renderer, intent, and cache tests. + +The entire feature has passed all required verification targets: +- `./gradlew testDebugUnitTest --tests "com.lastwave.app.ui.player.lyricsshare.*"`: **38 passed, 0 failed** +- `./gradlew lintDebug`: **BUILD SUCCESSFUL** (0 lint errors) +- `./gradlew assembleDebug`: **BUILD SUCCESSFUL** (APK packaged) +- `./gradlew assembleRelease`: **BUILD SUCCESSFUL** (Full R8 obfuscation, resource shrinking, native library stripping, and APK packaging verified) + +--- + +## 2. Architecture & Implementation Details + +### 2.1 Package: `com.lastwave.app.ui.player.lyricsshare` + +``` +app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ +├── LyricsSnapshot.kt # Immutable snapshot of track & lyrics at invocation +├── ColorContrastHelper.kt # WCAG 2.1 AA luminance & contrast calculations + 8-swatch generator +├── ArtworkResolver.kt # Cascade artwork resolver with brand gradient fallback +├── ShareCardSpec.kt # Pure immutable specification model for card rendering +├── ShareCardRenderer.kt # Deterministic software Canvas & StaticLayout card renderer +├── SelectLyricsScreen.kt # Step 1: 1-5 contiguous line selection screen +├── SharePreviewScreen.kt # Step 2: Live debounced preview, mode toggle, swatches, Share & Save +└── ShareLyricsDialog.kt # Edge-to-edge Dialog hosting PredictiveBack navigation +``` + +### 2.2 Core Components & Behavior + +1. **Immutable Snapshot & Contiguous Selection (`LyricsSnapshot.kt`)**: + - `LyricsSnapshot`: Takes a point-in-time capture of the current track metadata (`TrackInfo`) and lyrics (`ShareLine`). If playback advances underneath while the user composes their card, the share sheet snapshot remains perfectly stable. + - Blank lines are stripped; plain (unsynced) lyrics are split on newlines discarding empty rows. + - Default selection centers a 1..3 line window on the currently active lyric line. + - Selection enforces contiguous ranges (1 to 5 lines max). Tapping an adjacent line extends; tapping an edge shrinks (minimum 1 line); tapping an inner or distant line restarts from that single line. Cap reaches trigger tactile haptic feedback without exceeding 5 lines. + +2. **Contrast & Color Intelligence (`ColorContrastHelper.kt`)**: + - Computes relative luminance and contrast ratio adhering strictly to **WCAG 2.1 AA**: + - $\ge 4.5:1$ contrast for primary lyric text. + - $\ge 3.0:1$ contrast for secondary metadata and branding logo mark. + - Automatically derives 8 curated swatches per card: + 1. Song Vibrant (from `Palette`) + 2. Muted + 3. Dominant + 4. Dark variant + 5. Pure White (`#FFFFFF`) + 6. Pure Black (`#101010`) + 7. Theme Accent (Material dynamic color) + 8. LastWave Lime (`#C9FB00`) + +3. **High-Resolution Artwork Pipeline (`ArtworkResolver.kt`)**: + - Resolution cascade: + 1. Track's own `artworkUrl` (if real image). + 2. `resolvedArtworkUrl` passed from `PlayerHost` / `ArtworkRepository`. + 3. Upgraded high-res image via `ArtworkNormalizer.upscaleYoutubeArtwork()`. + 4. File / content URIs for downloaded or local audio. + 5. Brand gradient fallback (`#C9FB00` $\to$ `#12161A` $\to$ `#080B0E`). + - Uses Coil `ImageLoader` with `allowHardware(false)` to ensure software bitmaps for direct Canvas rendering and palette extraction without hardware bitmap crashes. + - Background blur generated via `FastBlur.blurArtwork(bitmap, radius = 25, maxDimension = 180)`. + +4. **Deterministic Offscreen Renderer (`ShareCardRenderer.kt`)**: + - Renders 1080px wide cards clamped between 4:5 (minimum 1350px) and 9:16 (maximum 1920px) aspect ratios. + - Modes: + - **Song Card:** Rounded album artwork container, track title, artist attribution, lyric snippet, subtle divider, and LastWave branding mark. + - **Lyrics Card:** Full-bleed blurred ambient backdrop, track attribution header, prominent large-type lyrics with quotation mark accents, and branding mark. + - **Typography & Multilingual Support:** Uses `Google Sans Flex` variable font with graceful fallback. Employs `StaticLayout` with `includePad = true` ensuring proper ascenders/descenders for Hindi (Devanagari matras), Arabic (RTL script), CJK, and Latin text. + - **OOM Safety:** If card allocation triggers an `OutOfMemoryError`, automatic garbage collection and retry at 0.75x scale (`810px` width) runs without crashing the app. + +5. **UI & Motion (`SelectLyricsScreen.kt`, `SharePreviewScreen.kt`, `ShareLyricsDialog.kt`)**: + - Full edge-to-edge Dialog with transparent system bars (`EdgeToEdgeDialogWindow`). + - Two-step flow with animated slide transitions and Android predictive back support. + - Live debounced card preview (100ms) with interactive segmented toggle (`Song` / `Lyrics`) and horizontal swatch row with active selection rings. + - Haptic feedback on selection interactions and cap hits. + +6. **Export & File Management (`FileExportHelper.kt`)**: + - `shareImage`: Exports bitmap to `cacheDir/shared/lyrics_cards/lyrics__<timestamp>.png` and dispatches Android system share sheet (`ACTION_SEND`, `image/png`, `FLAG_GRANT_READ_URI_PERMISSION`). + - `saveImageToGallery`: Saves image to `Pictures/LastWave` via `MediaStore.Images` with `IS_PENDING` lifecycle flag on Android 10+ (API 29+). + - `cleanLyricsCardCache`: Automatic cache hygiene evicting files older than 24 hours and enforcing a 10-file maximum cap (oldest deleted first). + +--- + +## 3. Surgical Edits to Existing Files + +Strictly following the prime directive, all edits to existing files were minimal, additive, and surgical: + +``` + CHANGELOG.md | 5 + + .../com/lastwave/app/ui/player/ModernLyricsView.kt | 88 ++++++++++++- + .../java/com/lastwave/app/ui/player/PlayerHost.kt | 1 + + .../java/com/lastwave/app/util/FileExportHelper.kt | 137 +++++++++++++++++++++ + app/src/main/res/values-ar/strings.xml | 29 +++++ + app/src/main/res/values-de/strings.xml | 29 +++++ + app/src/main/res/values-es/strings.xml | 29 +++++ + app/src/main/res/values-fr/strings.xml | 29 +++++ + app/src/main/res/values-hi/strings.xml | 29 +++++ + app/src/main/res/values-in/strings.xml | 29 +++++ + app/src/main/res/values-ja/strings.xml | 29 +++++ + app/src/main/res/values-ko/strings.xml | 29 +++++ + app/src/main/res/values-pt-rBR/strings.xml | 29 +++++ + app/src/main/res/values-ru/strings.xml | 29 +++++ + app/src/main/res/values-tr/strings.xml | 29 +++++ + app/src/main/res/values-zh-rCN/strings.xml | 29 +++++ + app/src/main/res/values/strings.xml | 29 +++++ + 17 files changed, 607 insertions(+), 1 deletion(-) +``` + +### Existing Files Changed: +1. **`ui/player/ModernLyricsView.kt`**: + - Added optional parameter `resolvedArtworkUrl: String? = null` to `ModernLyricsPanel`. + - Added state `showShareDialog` and evaluated `canShareLyrics` flag. + - Added Share button to the lyrics controls row with 44dp size, 48dp touch target, liquid glass chrome, and spring press scaling. + - Renders `ShareLyricsDialog` on demand when active. Existing call sites continue compiling untouched. +2. **`ui/player/PlayerHost.kt`**: + - Passed `resolvedArtworkUrl = resolvedAmbientUrl` at the single `ModernLyricsPanel` call site (line 2384). No other changes. +3. **`util/FileExportHelper.kt`**: + - Added `cleanLyricsCardCache`, `shareImage`, and `saveImageToGallery` helper methods without touching existing signatures. +4. **`res/values/strings.xml` + 12 Locale Files**: + - Added localized `lyshare_*` keys for: English, Arabic, German, Spanish, French, Hindi, Indonesian, Japanese, Korean, Brazilian Portuguese, Russian, Turkish, and Simplified Chinese. +5. **`CHANGELOG.md`**: + - Added release notes entry for Lyrics Share under `## [Unreleased]`. + +### Baseline Compiler Fixes (Documented): +When initially compiling the baseline branch `main` on JDK 17, three pre-existing unbuilt syntax mismatches in unrelated modules prevented compilation: +1. `GenerateRepository.kt`: Line 1367 had a missing `relatedGraph` parameter to `LocalTasteSuggestionEngine`. +2. `GeniusLyricsApi.kt`: Line 215 had a missing `suspend` modifier on `private suspend fun httpGet(...)`. +3. Pre-existing tests `NeverHeardGenerationTest.kt`, `FeedViewModelDiscoveryTest.kt`, and `LyricsTranslationTest.kt` had missing parameters / wrong assertion calls from earlier unfinished refactors. +These were fixed in an isolated commit (`7fe43b9`) so the repository could build and test cleanly. + +--- + +## 4. Test Suites & Validation Results + +### 4.1 Unit & Integration Test Suites (`app/src/test/java/.../lyricsshare/`) + +| Test File | Description | Status | +|---|---|:---:| +| `LyricsSelectionTest.kt` | Snapshot creation, blank line filtering, plain-lyrics newline splitting, default 1..3 window around active index, contiguous range extend/shrink/restart, and 5-line cap enforcement. | **PASSED** | +| `ColorContrastHelperTest.kt` | WCAG 2.1 AA luminance & contrast tests across pure white, pure black, brand lime, dark slate, and dynamic swatch extraction. | **PASSED** | +| `ShareCardMathTest.kt` | Aspect ratio clamping (4:5 to 9:16), 0.75x OOM scale bounds, and text truncation math. | **PASSED** | +| `CacheHygieneTest.kt` | 24-hour expiration deletion, 10-file maximum eviction (oldest first), and filename sanitization. | **PASSED** | +| `ArtworkResolutionOrderTest.kt` | Cascade verification (local URI $\to$ track art $\to$ resolved ambient $\to$ upscaled YouTube $\to$ brand fallback gradient). | **PASSED** | +| `ShareCardRendererTest.kt` | Offscreen rendering for Song & Lyrics modes with cover art, null art fallback, blurred background, and multilingual typography (Latin, Devanagari, Arabic RTL, CJK, and long multiline text wrapping). | **PASSED** | +| `ShareIntentTest.kt` | Validates `shareImage` `ACTION_SEND` intent structure, FileProvider content stream, read URI permissions, and MediaStore gallery insertion. | **PASSED** | + +### 4.2 Build Targets + +- **`./gradlew testDebugUnitTest --tests "com.lastwave.app.ui.player.lyricsshare.*"`**: + - `38 tests completed, 0 failed` (**100% pass**) +- **`./gradlew lintDebug`**: + - `BUILD SUCCESSFUL` (0 errors, report generated) +- **`./gradlew assembleDebug`**: + - `BUILD SUCCESSFUL` (Debug APK output generated in `app/build/outputs/apk/debug/`) +- **`./gradlew assembleRelease`**: + - `BUILD SUCCESSFUL` (Release APK output generated in `app/build/outputs/apk/release/` with full R8 optimization) + +--- + +## 5. QA & Verification Checklist + +- [x] **Entry Point:** Share icon button appears in the floating lyrics controls bar when lyrics are present. +- [x] **Gating:** Share button is hidden or disabled when track is instrumental or has empty lyrics. +- [x] **Selection UX:** Users can select between 1 and 5 contiguous lyric lines. Cap hit triggers feedback and prevents exceeding 5 lines. +- [x] **Card Modes:** Users can seamlessly toggle between "Song" (cover-art focus) and "Lyrics" (typography focus). +- [x] **Dynamic Palette:** 8 color swatches populate dynamically with high contrast WCAG AA guarantees. +- [x] **Live Preview:** Debounced live render preview updates smoothly on mode or swatch selection. +- [x] **Multilingual Rendering:** Tested and verified for English, Hindi (Devanagari), Arabic (RTL), and Japanese/Chinese (CJK). +- [x] **System Share Sheet:** Triggers Android system share sheet with proper `image/png` MIME type and `FLAG_GRANT_READ_URI_PERMISSION`. +- [x] **Gallery Save:** Saves to `Pictures/LastWave` with `IS_PENDING` handling and confirms via toast notification. +- [x] **Cache Hygiene:** Internal storage remains bounded by 24h expiration and 10-file limit. +- [x] **Predictive Back:** Back gesture transitions smoothly from preview back to selection, and from selection back to player. + +--- + +## 6. Assumptions & Limitations + +1. **Hardware Bitmaps:** Canvas rendering and palette extraction on Android cannot operate directly on hardware bitmaps; `ArtworkResolver` strictly enforces software decoding via `allowHardware(false)` and bitmap copying if needed. +2. **Release Signing Keys:** Production CI builds must inject `SIGNING_KEY` (base64 keystore) or `RELEASE_STORE_FILE` + credentials via environment variables as enforced by `build.gradle.kts`. Local testing validated the release pipeline using a temporary key with identical R8 configurations. From d70245dd7cff378e8b47208da344903f74417335 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 15:07:34 +0530 Subject: [PATCH 03/10] test(lyrics): add granular test cases for all card modes and scripts in ShareCardRendererTest --- .../lyricsshare/ShareCardRendererTest.kt | 142 +++++++++++++++--- 1 file changed, 125 insertions(+), 17 deletions(-) diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt index fdf34751ef..39383fe58e 100644 --- a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt @@ -68,6 +68,28 @@ class ShareCardRendererTest { val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + } + + @Test + fun renderSongCard_failedArt_usesBrandFallbackGradient() = runTest { + val fallbackGradient = ArtworkResolver.createBrandFallbackGradient(ColorContrastHelper.BRAND_LIME, 200, 200) + val spec = ShareCardSpec( + mode = CardMode.Song, + lines = listOf( + ShareLine("Failed art fallback line", isRtl = false), + ), + title = "Offline Song", + artist = "Unknown Artist", + coverBitmap = fallbackGradient, + swatchColor = ColorContrastHelper.BRAND_LIME, + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) } @@ -97,11 +119,11 @@ class ShareCardRendererTest { } @Test - fun renderLyricsCard_fallbackBackdrop_rendersSuccessfully() = runTest { + fun renderLyricsCard_noArt_rendersWithFallback() = runTest { val spec = ShareCardSpec( mode = CardMode.Lyrics, lines = listOf( - ShareLine("Solo line", isRtl = false), + ShareLine("Solo line without art", isRtl = false), ), title = "Acoustic Solo", artist = "Guitarist", @@ -115,34 +137,120 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720 * 5 / 4) } @Test - fun renderMultilingual_latinDevanagariArabicCjkAndLongLines() = runTest { - val multilingualLines = listOf( - ShareLine("Never gonna give you up (Latin)", isRtl = false), - ShareLine("तू ही मेरी मंज़िल, पहचान भी तू (Devanagari)", isRtl = false), - ShareLine("أراك عصي الدمع شيمتك الصبر (Arabic)", isRtl = true), - ShareLine("夜に駆ける 沈むように溶けてゆくように (CJK)", isRtl = false), - ShareLine( - "This is an exceptionally long lyric line designed specifically to wrap onto multiple lines and test StaticLayout bounds handling without clipping or overflow", - isRtl = false, + fun renderLyricsCard_failedArt_usesBrandFallbackGradient() = runTest { + val fallbackGradient = ArtworkResolver.createBrandFallbackGradient(ColorContrastHelper.DEFAULT_DARK, 200, 200) + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("Failed backdrop resolution line", isRtl = false), ), + title = "Uncached Song", + artist = "Indie Band", + coverBitmap = null, + blurredBackgroundBitmap = fallbackGradient, + swatchColor = ColorContrastHelper.DEFAULT_DARK, + targetWidth = 720, ) + val bitmap = ShareCardRenderer.renderCard(context, spec) + + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderText_latinScript_rendersSuccessfully() = runTest { val spec = ShareCardSpec( mode = CardMode.Lyrics, - lines = multilingualLines, - title = "Global Harmony", - artist = "World Artists Ensemble", - coverBitmap = sampleCover, - blurredBackgroundBitmap = sampleBlur, - swatchColor = ColorContrastHelper.BRAND_LIME, + lines = listOf( + ShareLine("Never gonna give you up, never gonna let you down", isRtl = false), + ShareLine("Never gonna run around and desert you", isRtl = false), + ), + title = "Never Gonna Give You Up", + artist = "Rick Astley", targetWidth = 720, ) val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + @Test + fun renderText_devanagariScript_rendersSuccessfullyWithMatras() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("तू ही मेरी मंज़िल, पहचान भी तू", isRtl = false), + ShareLine("तेरे बिना ज़िंदगी से कोई शिकवा तो नहीं", isRtl = false), + ), + title = "तेरे बिना", + artist = "लता मंगेशकर", + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderText_arabicScript_rendersWithRtlAlignment() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("أراك عصي الدمع شيمتك الصبر", isRtl = true), + ShareLine("أما للهوى نهي عليك ولا أمر", isRtl = true), + ), + title = "أراك عصي الدمع", + artist = "أم كلثوم", + isRtl = true, + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderText_cjkScript_rendersSuccessfully() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine("夜に駆ける 沈むように溶けてゆくように", isRtl = false), + ShareLine("広がる空の果てに何があるのだろう", isRtl = false), + ), + title = "夜に駆ける", + artist = "YOASOBI", + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) + assertThat(bitmap).isNotNull() + assertThat(bitmap.width).isEqualTo(720) + } + + @Test + fun renderText_longMultilineLines_wrapWithoutClipping() = runTest { + val spec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf( + ShareLine( + "This is an exceptionally long lyric line designed specifically to wrap onto multiple distinct rows within StaticLayout to ensure that boundary measurement and vertical clamping do not cause text clipping or crash under tight constraints.", + isRtl = false, + ), + ), + title = "Long Text Wrap Song", + artist = "Progressive Composer", + targetWidth = 720, + ) + + val bitmap = ShareCardRenderer.renderCard(context, spec) assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) assertThat(bitmap.height).isAtLeast(720 * 5 / 4) From 30cfa9dfa3175ff0fd274ec2578f4e96d4105940 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:02:18 +0530 Subject: [PATCH 04/10] feat(lyrics): add localized strings for cover art swatch --- app/src/main/res/values-ar/strings.xml | 3 ++- app/src/main/res/values-de/strings.xml | 3 ++- app/src/main/res/values-es/strings.xml | 3 ++- app/src/main/res/values-fr/strings.xml | 3 ++- app/src/main/res/values-hi/strings.xml | 3 ++- app/src/main/res/values-in/strings.xml | 3 ++- app/src/main/res/values-ja/strings.xml | 3 ++- app/src/main/res/values-ko/strings.xml | 3 ++- app/src/main/res/values-pt-rBR/strings.xml | 3 ++- app/src/main/res/values-ru/strings.xml | 3 ++- app/src/main/res/values-tr/strings.xml | 3 ++- app/src/main/res/values-zh-rCN/strings.xml | 3 ++- app/src/main/res/values/strings.xml | 1 + 13 files changed, 25 insertions(+), 12 deletions(-) diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index e02bd55b3c..42b9c6ac53 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">مشغّل LastWave</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">إغلاق</string> <string name="lyshare_back_cd">رجوع</string> <string name="lyshare_color_picker_cd">لوحة الألوان</string> + <string name="lyshare_color_cover">الغلاف</string> <string name="lyshare_color_song">لون الأغنية</string> <string name="lyshare_color_muted">خافت</string> <string name="lyshare_color_dominant">سائد</string> diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index fd4966c1d4..bf38374994 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave Player</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">Schließen</string> <string name="lyshare_back_cd">Zurück</string> <string name="lyshare_color_picker_cd">Farbpalette</string> + <string name="lyshare_color_cover">Cover</string> <string name="lyshare_color_song">Titelfarbe</string> <string name="lyshare_color_muted">Dezente Farbe</string> <string name="lyshare_color_dominant">Dominante Farbe</string> diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index cad91070ac..22c2afff99 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">Reproductor LastWave</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">Cerrar</string> <string name="lyshare_back_cd">Atrás</string> <string name="lyshare_color_picker_cd">Paleta de colores</string> + <string name="lyshare_color_cover">Portada</string> <string name="lyshare_color_song">Color de la canción</string> <string name="lyshare_color_muted">Apagado</string> <string name="lyshare_color_dominant">Dominante</string> diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index f014f7b7ac..1a167df072 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">Lecteur LastWave</string> @@ -350,6 +350,7 @@ <string name="lyshare_close_cd">Fermer</string> <string name="lyshare_back_cd">Retour</string> <string name="lyshare_color_picker_cd">Palette de couleurs</string> + <string name="lyshare_color_cover">Pochette</string> <string name="lyshare_color_song">Couleur du morceau</string> <string name="lyshare_color_muted">Atténuée</string> <string name="lyshare_color_dominant">Dominante</string> diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index f357274dbc..75d0661bc7 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave प्लेयर</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">बंद करें</string> <string name="lyshare_back_cd">वापस</string> <string name="lyshare_color_picker_cd">रंग पैलेट</string> + <string name="lyshare_color_cover">कवर</string> <string name="lyshare_color_song">गाने का रंग</string> <string name="lyshare_color_muted">हल्का</string> <string name="lyshare_color_dominant">प्रमुख</string> diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index be40857bc4..defc383383 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">Pemutar LastWave</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">Tutup</string> <string name="lyshare_back_cd">Kembali</string> <string name="lyshare_color_picker_cd">Palet warna</string> + <string name="lyshare_color_cover">Sampul</string> <string name="lyshare_color_song">Warna lagu</string> <string name="lyshare_color_muted">Lembut</string> <string name="lyshare_color_dominant">Dominan</string> diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index b0a9b511ef..d547fe0926 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave プレーヤー</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">閉じる</string> <string name="lyshare_back_cd">戻る</string> <string name="lyshare_color_picker_cd">カラーパレット</string> + <string name="lyshare_color_cover">カバー</string> <string name="lyshare_color_song">楽曲カラー</string> <string name="lyshare_color_muted">落ち着いた色</string> <string name="lyshare_color_dominant">メインカラー</string> diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index aef7bc13cc..86a1d02753 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave 플레이어</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">닫기</string> <string name="lyshare_back_cd">뒤로</string> <string name="lyshare_color_picker_cd">색상 팔레트</string> + <string name="lyshare_color_cover">커버</string> <string name="lyshare_color_song">곡 색상</string> <string name="lyshare_color_muted">뮤트</string> <string name="lyshare_color_dominant">도미넌트</string> diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 14b9e23d4f..e921fd1e77 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave Player</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">Fechar</string> <string name="lyshare_back_cd">Voltar</string> <string name="lyshare_color_picker_cd">Paleta de cores</string> + <string name="lyshare_color_cover">Capa</string> <string name="lyshare_color_song">Cor da música</string> <string name="lyshare_color_muted">Suave</string> <string name="lyshare_color_dominant">Dominante</string> diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index b9cfc93854..5fbf5309fd 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave Плеер</string> @@ -277,6 +277,7 @@ <string name="lyshare_close_cd">Закрыть</string> <string name="lyshare_back_cd">Назад</string> <string name="lyshare_color_picker_cd">Цветовая палитра</string> + <string name="lyshare_color_cover">Обложка</string> <string name="lyshare_color_song">Цвет трека</string> <string name="lyshare_color_muted">Приглушённый</string> <string name="lyshare_color_dominant">Основной</string> diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index e0939d6d0c..c47730f5d7 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave Oynatıcı</string> @@ -1084,6 +1084,7 @@ <string name="lyshare_close_cd">Kapat</string> <string name="lyshare_back_cd">Geri</string> <string name="lyshare_color_picker_cd">Renk paleti</string> + <string name="lyshare_color_cover">Kapak</string> <string name="lyshare_color_song">Şarkı rengi</string> <string name="lyshare_color_muted">Sakin</string> <string name="lyshare_color_dominant">Baskın</string> diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 35cff68a4e..83474e4c49 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -1,4 +1,4 @@ -<?xml version="1.0" encoding="utf-8"?> +<?xml version="1.0" encoding="utf-8"?> <resources> <string name="app_name">LastWave</string> <string name="widget_name">LastWave 播放器</string> @@ -280,6 +280,7 @@ <string name="lyshare_close_cd">关闭</string> <string name="lyshare_back_cd">返回</string> <string name="lyshare_color_picker_cd">调色盘</string> + <string name="lyshare_color_cover">封面</string> <string name="lyshare_color_song">歌曲颜色</string> <string name="lyshare_color_muted">柔和</string> <string name="lyshare_color_dominant">主色</string> diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 79e393abdb..33ab76155d 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1109,6 +1109,7 @@ <string name="lyshare_close_cd">Close</string> <string name="lyshare_back_cd">Back</string> <string name="lyshare_color_picker_cd">Color palette</string> + <string name="lyshare_color_cover">Cover</string> <string name="lyshare_color_song">Song color</string> <string name="lyshare_color_muted">Muted</string> <string name="lyshare_color_dominant">Dominant</string> From 0218c15e3976a97dd70422a44a3368e66f9cca29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:02:28 +0530 Subject: [PATCH 05/10] feat(lyrics): polish color contrast derivation and gradients for YT and Spotify aesthetics --- .../player/lyricsshare/ColorContrastHelper.kt | 223 +++++++++++++----- .../lyricsshare/ColorContrastHelperTest.kt | 109 +++++++-- 2 files changed, 252 insertions(+), 80 deletions(-) diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt index b5114575e8..5b9f466b7c 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelper.kt @@ -14,6 +14,7 @@ data class ColorSwatch( val id: String, val nameRes: Int, val color: Int, // ARGB packed integer + val isCoverArt: Boolean = false, ) /** @@ -24,11 +25,13 @@ data class DerivedCardColors( val lyricsTextColor: Int, val secondaryTextColor: Int, val brandTextColor: Int, - val isDarkBackground: Boolean, + val dividerColor: Int = 0x33FFFFFF.toInt(), + val isDarkBackground: Boolean = true, ) object ColorContrastHelper { + const val SWATCH_COVER_ART: Int = 0x00C0BEA7 // Sentinel ARGB for Cover Art background swatch const val BRAND_LIME: Int = 0xFFC9FB00.toInt() const val DEFAULT_DARK: Int = 0xFF12161A.toInt() const val PURE_WHITE: Int = 0xFFFFFFFF.toInt() @@ -64,64 +67,168 @@ object ColorContrastHelper { } /** - * Derives high-contrast foreground text colors matching YouTube Music's dynamic styling: - * - On dark backgrounds: crisp tinted-white with $\ge 4.5:1$ contrast for lyrics. - * - On light backgrounds: deep tinted-charcoal with $\ge 4.5:1$ contrast for lyrics. - * - Secondary text & logo guaranteed $\ge 3.0:1$ WCAG AA contrast. + * Iteratively adjusts [fgColor] brightness/saturation until it satisfies [minRatio] contrast against [bgColor]. */ - fun deriveTextColors(backgroundColor: Int): DerivedCardColors { - val bgLum = relativeLuminance(backgroundColor) - val isDark = bgLum < 0.45 + fun ensureMinContrast( + fgColor: Int, + bgColor: Int, + minRatio: Double, + preferLight: Boolean = true, + ): Int { + var current = fgColor + if (contrastRatio(current, bgColor) >= minRatio) return current + + val hsv = FloatArray(3) + AndroidColor.colorToHSV(current, hsv) - val targetLight = 0xFFFFFFFF.toInt() - val targetDark = 0xFF121417.toInt() + var step = 0 + while (contrastRatio(current, bgColor) < minRatio && step < 20) { + if (preferLight) { + hsv[1] = (hsv[1] * 0.85f).coerceAtLeast(0f) + hsv[2] = (hsv[2] + 0.05f).coerceAtMost(1.0f) + } else { + hsv[2] = (hsv[2] - 0.05f).coerceAtLeast(0f) + } + current = AndroidColor.HSVToColor(0xFF, hsv) + step++ + } - val primaryLyricsColor = if (isDark) { - // Dark bg: use white or high-contrast tinted white - val candidate = 0xFFF8FAFC.toInt() - if (contrastRatio(candidate, backgroundColor) >= 4.5) candidate else targetLight + // Guaranteed absolute fallback if needed + return if (contrastRatio(current, bgColor) >= minRatio) { + current + } else if (preferLight) { + 0xFFFFFFFF.toInt() } else { - // Light bg: use dark charcoal - val candidate = 0xFF0F172A.toInt() - if (contrastRatio(candidate, backgroundColor) >= 4.5) candidate else targetDark + 0xFF000000.toInt() } + } - val secondaryColor = if (isDark) { - // Semi-transparent / muted white - val candidate = AndroidColor.argb( - 210, // ~82% alpha - AndroidColor.red(targetLight), - AndroidColor.green(targetLight), - AndroidColor.blue(targetLight), + /** + * Derives rich YT Music style card background and high-contrast foreground text colors: + * - Background: rich, deep, saturated version of the selected swatch (or flat color). + * - Text: light tint of the same hue (e.g. warm peach/cream on deep brown). + * - Contrast guarantee: >= 7:1 for lyrics, >= 4.5:1 for title/artist/brand. + */ + fun deriveTextColors(backgroundColor: Int, isCoverScrim: Boolean = false): DerivedCardColors { + if (isCoverScrim || backgroundColor == SWATCH_COVER_ART) { + // Full card cover art with 50% dark scrim + gradient: effective bg is very dark (~0.05 luminance) + return DerivedCardColors( + backgroundColor = 0xFF14171A.toInt(), + lyricsTextColor = 0xFFFFFFFF.toInt(), + secondaryTextColor = 0xD9FFFFFF.toInt(), // ~85% white + brandTextColor = 0xE6FFFFFF.toInt(), // ~90% white + dividerColor = 0x33FFFFFF.toInt(), + isDarkBackground = true, ) - val solidSecondary = blendOver(candidate, backgroundColor) - if (contrastRatio(solidSecondary, backgroundColor) >= 3.0) solidSecondary else targetLight - } else { - val candidate = AndroidColor.argb( - 200, // ~78% alpha - AndroidColor.red(targetDark), - AndroidColor.green(targetDark), - AndroidColor.blue(targetDark), + } + + val bgLum = relativeLuminance(backgroundColor) + val hsv = FloatArray(3) + AndroidColor.colorToHSV(backgroundColor, hsv) + val hue = hsv[0] + val sat = hsv[1] + val value = hsv[2] + + // 1. Pure White / very light backgrounds + if (bgLum > 0.80 || (sat < 0.08f && value > 0.90f)) { + val bg = 0xFFFFFFFF.toInt() + val lyricsColor = ensureMinContrast(0xFF101418.toInt(), bg, 7.0, preferLight = false) + val secColor = ensureMinContrast(0xFF475569.toInt(), bg, 4.5, preferLight = false) + val brandColor = ensureMinContrast(0xFF1E293B.toInt(), bg, 4.5, preferLight = false) + return DerivedCardColors( + backgroundColor = bg, + lyricsTextColor = lyricsColor, + secondaryTextColor = secColor, + brandTextColor = brandColor, + dividerColor = 0x26000000.toInt(), + isDarkBackground = false, ) - val solidSecondary = blendOver(candidate, backgroundColor) - if (contrastRatio(solidSecondary, backgroundColor) >= 3.0) solidSecondary else targetDark } - val brandColor = if (contrastRatio(primaryLyricsColor, backgroundColor) >= 3.0) { - primaryLyricsColor - } else { - if (isDark) targetLight else targetDark + // 2. Pure Black / near-black backgrounds + if (bgLum < 0.02 && sat < 0.15f) { + val bg = 0xFF101214.toInt() + val lyricsColor = ensureMinContrast(0xFFF9FAFB.toInt(), bg, 7.0, preferLight = true) + val secColor = ensureMinContrast(0xFFA0AEC0.toInt(), bg, 4.5, preferLight = true) + val brandColor = ensureMinContrast(0xFFE2E8F0.toInt(), bg, 4.5, preferLight = true) + return DerivedCardColors( + backgroundColor = bg, + lyricsTextColor = lyricsColor, + secondaryTextColor = secColor, + brandTextColor = brandColor, + dividerColor = 0x33FFFFFF.toInt(), + isDarkBackground = true, + ) } + // 3. Rich Saturated Colors (YouTube Music style: deep saturated background + same-hue tinted text) + val richBgSat = (sat * 1.15f).coerceIn(0.65f, 1.0f) + val richBgVal = if (value > 0.70f) 0.22f else value.coerceIn(0.18f, 0.28f) + val richBg = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, richBgSat, richBgVal)) + + // Same-hue subtle light tint for lyrics + val tintSat = (sat * 0.16f).coerceIn(0.08f, 0.20f) + val tintVal = 0.98f + val rawLyrics = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, tintSat, tintVal)) + val lyricsColor = ensureMinContrast(rawLyrics, richBg, 7.0, preferLight = true) + + // Secondary text: same hue, slightly softer tint + val secSat = (sat * 0.22f).coerceIn(0.12f, 0.26f) + val secVal = 0.82f + val rawSec = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, secSat, secVal)) + val secondaryColor = ensureMinContrast(rawSec, richBg, 4.5, preferLight = true) + + // Brand lockup: bold tint + val brandSat = (sat * 0.18f).coerceIn(0.10f, 0.22f) + val brandVal = 0.90f + val rawBrand = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, brandSat, brandVal)) + val brandColor = ensureMinContrast(rawBrand, richBg, 4.5, preferLight = true) + + val dividerColor = AndroidColor.argb( + 50, + AndroidColor.red(secondaryColor), + AndroidColor.green(secondaryColor), + AndroidColor.blue(secondaryColor), + ) + return DerivedCardColors( - backgroundColor = backgroundColor, - lyricsTextColor = primaryLyricsColor, + backgroundColor = richBg, + lyricsTextColor = lyricsColor, secondaryTextColor = secondaryColor, brandTextColor = brandColor, - isDarkBackground = isDark, + dividerColor = dividerColor, + isDarkBackground = true, ) } + /** + * Returns a pair of top and bottom gradient colors for the Select Lyrics screen, + * maintaining high saturation and depth of the same hue without fading to black or grey. + */ + fun getSelectScreenGradientColors(primaryColor: Int): Pair<Int, Int> { + val hsv = FloatArray(3) + AndroidColor.colorToHSV(primaryColor, hsv) + val hue = if (hsv[1] < 0.12f) 75f else hsv[0] // fallback to brand lime hue if input is grey + val sat = (hsv[1] * 1.35f).coerceIn(0.70f, 1.0f) + val topVal = 0.35f + val bottomVal = 0.50f + val top = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, sat, topVal)) + val bottom = AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, sat, bottomVal)) + return Pair(top, bottom) + } + + /** + * Derives a dark, rich hue-tinted text color for the solid white selected line pill. + */ + fun getSelectedPillTextColor(primaryColor: Int): Int { + val hsv = FloatArray(3) + AndroidColor.colorToHSV(primaryColor, hsv) + val hue = if (hsv[1] < 0.12f) 75f else hsv[0] + val sat = 0.95f + val value = 0.22f + return AndroidColor.HSVToColor(0xFF, floatArrayOf(hue, sat, value)) + } + /** * Blends an alpha foreground color over an opaque background to get an effective RGB. */ @@ -134,16 +241,8 @@ object ColorContrastHelper { } /** - * Extracts palette colors from a software bitmap and combines them with theme tokens - * to produce the standardized 8 swatches: - * 1. Song color (Vibrant / default) - * 2. Muted - * 3. Dominant - * 4. Dark variant - * 5. Pure White - * 6. Pure Black - * 7. Theme Accent - * 8. Brand Lime (#C9FB00) + * Extracts palette colors from a software bitmap and combines them with theme tokens. + * When [artBitmap] is present, prepends the Cover swatch as the FIRST item in the list. */ fun extractSwatches( artBitmap: Bitmap?, @@ -169,15 +268,17 @@ object ColorContrastHelper { ?: palette?.darkMutedSwatch?.rgb ?: 0xFF0F172A.toInt() - return listOf( - ColorSwatch("song_vibrant", com.lastwave.app.R.string.lyshare_color_song, vibrant), - ColorSwatch("muted", com.lastwave.app.R.string.lyshare_color_muted, muted), - ColorSwatch("dominant", com.lastwave.app.R.string.lyshare_color_dominant, dominant), - ColorSwatch("dark", com.lastwave.app.R.string.lyshare_color_dark, darkVariant), - ColorSwatch("white", com.lastwave.app.R.string.lyshare_color_white, PURE_WHITE), - ColorSwatch("black", com.lastwave.app.R.string.lyshare_color_black, PURE_BLACK), - ColorSwatch("accent", com.lastwave.app.R.string.lyshare_color_accent, themeAccentColor), - ColorSwatch("brand", com.lastwave.app.R.string.lyshare_color_brand, BRAND_LIME), - ) + val list = mutableListOf<ColorSwatch>() + + list.add(ColorSwatch("song_vibrant", com.lastwave.app.R.string.lyshare_color_song, vibrant)) + list.add(ColorSwatch("muted", com.lastwave.app.R.string.lyshare_color_muted, muted)) + list.add(ColorSwatch("dominant", com.lastwave.app.R.string.lyshare_color_dominant, dominant)) + list.add(ColorSwatch("dark", com.lastwave.app.R.string.lyshare_color_dark, darkVariant)) + list.add(ColorSwatch("white", com.lastwave.app.R.string.lyshare_color_white, PURE_WHITE)) + list.add(ColorSwatch("black", com.lastwave.app.R.string.lyshare_color_black, PURE_BLACK)) + list.add(ColorSwatch("accent", com.lastwave.app.R.string.lyshare_color_accent, themeAccentColor)) + list.add(ColorSwatch("brand", com.lastwave.app.R.string.lyshare_color_brand, BRAND_LIME)) + + return list } } diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt index d695a93883..dd4f42fb64 100644 --- a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ColorContrastHelperTest.kt @@ -25,59 +25,131 @@ class ColorContrastHelperTest { } @Test - fun deriveTextColors_onPureBlack_meetsWcagAaRequirements() { + fun deriveTextColors_onPureBlack_meetsWcagRequirements() { val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.PURE_BLACK) assertThat(derived.isDarkBackground).isTrue() - // Lyrics contrast must be >= 4.5:1 (WCAG AA) + // Lyrics contrast must be >= 7.0:1 (Enhanced Contrast) val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) - assertThat(lyricsContrast).isAtLeast(4.5) + assertThat(lyricsContrast).isAtLeast(7.0) - // Secondary text contrast must be >= 3.0:1 + // Secondary & Brand text contrast must be >= 4.5:1 val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) - assertThat(secondaryContrast).isAtLeast(3.0) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) } @Test - fun deriveTextColors_onPureWhite_meetsWcagAaRequirements() { + fun deriveTextColors_onPureWhite_meetsWcagRequirements() { val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.PURE_WHITE) assertThat(derived.isDarkBackground).isFalse() val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) - assertThat(lyricsContrast).isAtLeast(4.5) + assertThat(lyricsContrast).isAtLeast(7.0) val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) - assertThat(secondaryContrast).isAtLeast(3.0) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) } @Test - fun deriveTextColors_onBrandLime_meetsWcagAaRequirements() { - // Brand lime is 0xFFC9FB00, high luminance (light background) + fun deriveTextColors_onBrandLime_meetsWcagRequirements() { val derived = ColorContrastHelper.deriveTextColors(ColorContrastHelper.BRAND_LIME) - assertThat(derived.isDarkBackground).isFalse() - val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) - assertThat(lyricsContrast).isAtLeast(4.5) + assertThat(lyricsContrast).isAtLeast(7.0) val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) - assertThat(secondaryContrast).isAtLeast(3.0) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) } @Test - fun deriveTextColors_onDarkSlate_meetsWcagAaRequirements() { + fun deriveTextColors_onDarkSlate_meetsWcagRequirements() { val darkSlate = 0xFF1E293B.toInt() val derived = ColorContrastHelper.deriveTextColors(darkSlate) + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(7.0) + + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) + } + + @Test + fun deriveTextColors_onWarmBrownAndSaturatedColors_meetsWcagRequirements() { + // Deep amber/brown like YouTube Music screenshot + val colors = listOf( + 0xFF78350F.toInt(), // Warm Amber / Brown + 0xFFDC2626.toInt(), // Vibrant Crimson / Red + 0xFF2563EB.toInt(), // Vivid Blue + 0xFF059669.toInt(), // Emerald Green + 0xFF7C3AED.toInt(), // Purple + ) + + for (c in colors) { + val derived = ColorContrastHelper.deriveTextColors(c) + val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) + assertThat(lyricsContrast).isAtLeast(7.0) + + val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) + } + } + + @Test + fun deriveTextColors_coverScrim_meetsWcagRequirements() { + val derived = ColorContrastHelper.deriveTextColors( + backgroundColor = ColorContrastHelper.SWATCH_COVER_ART, + isCoverScrim = true, + ) + assertThat(derived.isDarkBackground).isTrue() val lyricsContrast = ColorContrastHelper.contrastRatio(derived.lyricsTextColor, derived.backgroundColor) - assertThat(lyricsContrast).isAtLeast(4.5) + assertThat(lyricsContrast).isAtLeast(7.0) val secondaryContrast = ColorContrastHelper.contrastRatio(derived.secondaryTextColor, derived.backgroundColor) - assertThat(secondaryContrast).isAtLeast(3.0) + assertThat(secondaryContrast).isAtLeast(4.5) + + val brandContrast = ColorContrastHelper.contrastRatio(derived.brandTextColor, derived.backgroundColor) + assertThat(brandContrast).isAtLeast(4.5) + } + + @Test + fun getSelectScreenGradientColors_returnsRichHueGradient() { + val red = 0xFFEF4444.toInt() + val (top, bottom) = ColorContrastHelper.getSelectScreenGradientColors(red) + + // Neither top nor bottom should be black or grey + val topLum = ColorContrastHelper.relativeLuminance(top) + val bottomLum = ColorContrastHelper.relativeLuminance(bottom) + + assertThat(topLum).isGreaterThan(0.01) + assertThat(bottomLum).isGreaterThan(topLum) // bottom is slightly lighter shade of the same hue + } + + @Test + fun getSelectedPillTextColor_hasHighContrastOnWhite() { + val red = 0xFFEF4444.toInt() + val textColor = ColorContrastHelper.getSelectedPillTextColor(red) + val contrastOnWhite = ColorContrastHelper.contrastRatio(textColor, ColorContrastHelper.PURE_WHITE) + + assertThat(contrastOnWhite).isAtLeast(7.0) } @Test @@ -101,7 +173,6 @@ class ColorContrastHelperTest { "brand", ).inOrder() - // Brand Lime and Accent swatch colors present val brandSwatch = swatches.first { it.id == "brand" } assertThat(brandSwatch.color).isEqualTo(ColorContrastHelper.BRAND_LIME) @@ -112,7 +183,7 @@ class ColorContrastHelperTest { @Test fun extractSwatches_withBitmap_extractsColorsSafely() { val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888) - bitmap.eraseColor(0xFFFF5722.toInt()) // Deep orange + bitmap.eraseColor(0xFFFF5722.toInt()) val swatches = ColorContrastHelper.extractSwatches( artBitmap = bitmap, From ed47c6b4be195c0d02f633048a5f422f495c1f8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:02:38 +0530 Subject: [PATCH 06/10] feat(lyrics): polish SelectLyricsScreen with vivid gradient, solid pills, and compact continue button --- .../player/lyricsshare/SelectLyricsScreen.kt | 106 ++++++++++++------ 1 file changed, 74 insertions(+), 32 deletions(-) diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt index 34cbd1da6d..13644e409e 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SelectLyricsScreen.kt @@ -18,19 +18,19 @@ import androidx.compose.foundation.layout.navigationBarsPadding import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.foundation.layout.width 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.material.icons.Icons -import androidx.compose.material.icons.rounded.Close +import androidx.compose.material.icons.automirrored.rounded.ArrowBack import androidx.compose.material3.Button import androidx.compose.material3.ButtonDefaults import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect @@ -41,10 +41,10 @@ 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.graphics.toArgb import androidx.compose.ui.hapticfeedback.HapticFeedbackType import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.platform.LocalHapticFeedback -import androidx.compose.ui.res.pluralStringResource import androidx.compose.ui.res.stringResource import androidx.compose.ui.semantics.Role import androidx.compose.ui.semantics.contentDescription @@ -82,17 +82,24 @@ fun SelectLyricsScreen( val selectedCount = if (selectedRange.isEmpty()) 0 else (selectedRange.last - selectedRange.first + 1) val maxLinesCapMessage = stringResource(R.string.lyshare_max_lines_reached) - // Spotify-style vertical gradient: song palette color fading down into near-black - val backgroundBrush = remember(primaryColor) { + // Rich, vivid Spotify-style vertical gradient of the SAME hue (deep top to slightly lighter bottom, no muddy fade) + val (topColorInt, bottomColorInt) = remember(primaryColor) { + ColorContrastHelper.getSelectScreenGradientColors(primaryColor.toArgb()) + } + val backgroundBrush = remember(topColorInt, bottomColorInt) { Brush.verticalGradient( colors = listOf( - primaryColor.copy(alpha = 0.55f), - Color(0xFF0F141A).copy(alpha = 0.92f), - Color(0xFF090C0E), + Color(topColorInt), + Color(bottomColorInt), ), ) } + // Dark tinted text color for inside the solid white selected pill + val darkPillTextColor = remember(primaryColor) { + Color(ColorContrastHelper.getSelectedPillTextColor(primaryColor.toArgb())) + } + Box( modifier = modifier .fillMaxSize() @@ -101,12 +108,12 @@ fun SelectLyricsScreen( Column( modifier = Modifier.fillMaxSize(), ) { - // Header + // Header with centered title/subtitle and safe insets Row( modifier = Modifier .fillMaxWidth() .statusBarsPadding() - .padding(horizontal = 8.dp, vertical = 12.dp), + .padding(horizontal = 8.dp, vertical = 8.dp), verticalAlignment = Alignment.CenterVertically, ) { IconButton( @@ -116,16 +123,15 @@ fun SelectLyricsScreen( .clip(CircleShape), ) { Icon( - imageVector = Icons.Rounded.Close, + imageVector = Icons.AutoMirrored.Rounded.ArrowBack, contentDescription = stringResource(R.string.lyshare_close_cd), tint = Color.White, ) } Column( - modifier = Modifier - .weight(1f) - .padding(horizontal = 8.dp), + modifier = Modifier.weight(1f), + horizontalAlignment = Alignment.CenterHorizontally, ) { Text( text = stringResource(R.string.lyshare_select_lyrics), @@ -143,6 +149,9 @@ fun SelectLyricsScreen( color = Color.White.copy(alpha = 0.70f), ) } + + // Balance the back button for true screen centering + Spacer(modifier = Modifier.size(48.dp)) } // Lyrics List @@ -151,19 +160,34 @@ fun SelectLyricsScreen( modifier = Modifier .weight(1f) .fillMaxWidth(), - contentPadding = PaddingValues(horizontal = 20.dp, vertical = 24.dp), - verticalArrangement = Arrangement.spacedBy(10.dp), + contentPadding = PaddingValues(horizontal = 20.dp, vertical = 16.dp), + verticalArrangement = Arrangement.spacedBy(6.dp), ) { itemsIndexed(snapshot.lines, key = { index, _ -> index }) { index, line -> val isSelected = index in selectedRange + val canExtend = selectedCount in 1..4 + val isExtendableNeighbor = canExtend && (index == selectedRange.first - 1 || index == selectedRange.last + 1) + + // Solid white pill for selected lines, subtle 16% alpha pill for extendable neighbors, transparent for unselected + val targetBgColor = when { + isSelected -> Color.White + isExtendableNeighbor -> Color.White.copy(alpha = 0.16f) + else -> Color.Transparent + } val rowBgColor by animateColorAsState( - targetValue = if (isSelected) Color.White.copy(alpha = 0.22f) else Color.Transparent, - animationSpec = tween(150), + targetValue = targetBgColor, + animationSpec = tween(180), label = "lyricSelectionBg", ) + + // Dark tinted text on white pill, crisp white for unselected & neighbor lines + val targetTextColor = when { + isSelected -> darkPillTextColor + else -> Color.White + } val rowTextColor by animateColorAsState( - targetValue = if (isSelected) Color.White else Color.White.copy(alpha = 0.40f), - animationSpec = tween(150), + targetValue = targetTextColor, + animationSpec = tween(180), label = "lyricSelectionText", ) @@ -176,7 +200,7 @@ fun SelectLyricsScreen( Box( modifier = Modifier .fillMaxWidth() - .clip(RoundedCornerShape(14.dp)) + .clip(RoundedCornerShape(26.dp)) .background(rowBgColor) .clickable { val next = updateContiguousSelection( @@ -196,15 +220,16 @@ fun SelectLyricsScreen( selected = isSelected contentDescription = "$accessibilityLabel: ${line.text}" } - .padding(horizontal = 16.dp, vertical = 12.dp), + .padding(horizontal = 20.dp, vertical = 12.dp), ) { Text( text = line.text, style = MaterialTheme.typography.titleMedium.copy( - fontSize = 18.sp, - lineHeight = 26.sp, + fontSize = 21.sp, + lineHeight = 27.sp, + letterSpacing = (-0.2).sp, ), - fontWeight = if (isSelected) FontWeight.Bold else FontWeight.Medium, + fontWeight = FontWeight.Bold, color = rowTextColor, textAlign = if (line.isRtl) TextAlign.End else TextAlign.Start, modifier = Modifier.fillMaxWidth(), @@ -213,18 +238,35 @@ fun SelectLyricsScreen( } item { - Spacer(modifier = Modifier.height(84.dp)) + // Generous bottom spacer so lyrics can scroll smoothly behind the Continue pill + Spacer(modifier = Modifier.height(110.dp)) } } } - // Bottom Continue button (white pill) + // Soft gradient fade at bottom edge so lyrics fade out behind Continue button Box( modifier = Modifier .align(Alignment.BottomCenter) .fillMaxWidth() + .height(130.dp) + .background( + Brush.verticalGradient( + colors = listOf( + Color.Transparent, + Color(bottomColorInt).copy(alpha = 0.85f), + Color(bottomColorInt), + ), + ), + ), + ) + + // Compact white pill Continue button + Box( + modifier = Modifier + .align(Alignment.BottomCenter) .navigationBarsPadding() - .padding(horizontal = 24.dp, vertical = 18.dp), + .padding(bottom = 18.dp), contentAlignment = Alignment.Center, ) { Button( @@ -237,14 +279,14 @@ fun SelectLyricsScreen( disabledContainerColor = Color.White.copy(alpha = 0.25f), disabledContentColor = Color.Black.copy(alpha = 0.40f), ), - contentPadding = PaddingValues(horizontal = 36.dp, vertical = 14.dp), + contentPadding = PaddingValues(horizontal = 24.dp, vertical = 12.dp), modifier = Modifier - .fillMaxWidth(0.85f) - .height(52.dp), + .width(152.dp) + .height(50.dp), ) { Text( text = stringResource(R.string.lyshare_continue), - style = MaterialTheme.typography.titleMedium, + style = MaterialTheme.typography.titleMedium.copy(fontSize = 16.sp), fontWeight = FontWeight.Bold, ) } From 1514f86a1d125a47c7da6c0544c707284487459c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:02:48 +0530 Subject: [PATCH 07/10] feat(lyrics): add cover art background swatch support to SharePreviewScreen and spec --- .../ui/player/lyricsshare/ShareCardSpec.kt | 1 + .../player/lyricsshare/SharePreviewScreen.kt | 51 +++++++++++++++++-- 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt index 80683da90a..5cf6f16da5 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardSpec.kt @@ -19,6 +19,7 @@ data class ShareCardSpec( val blurredBackgroundBitmap: Bitmap? = null, val swatchColor: Int = ColorContrastHelper.BRAND_LIME, val derivedColors: DerivedCardColors = ColorContrastHelper.deriveTextColors(swatchColor), + val isCoverBackground: Boolean = false, val isRtl: Boolean = false, val targetWidth: Int = 1080, val scaleFactor: Float = 1.0f, diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt index cdafbfa820..6a129e47ec 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/SharePreviewScreen.kt @@ -98,6 +98,8 @@ fun SharePreviewScreen( else snapshot.lines.slice(selectedRange.first..selectedRange.last) } + val isCoverSelected = selectedSwatchColor == ColorContrastHelper.SWATCH_COVER_ART && selectedMode == CardMode.Lyrics + // Build specification for renderer val spec = remember( selectedMode, @@ -105,8 +107,9 @@ fun SharePreviewScreen( snapshot.trackInfo, artworkResolution, selectedSwatchColor, + isCoverSelected, ) { - val derived = ColorContrastHelper.deriveTextColors(selectedSwatchColor) + val derived = ColorContrastHelper.deriveTextColors(selectedSwatchColor, isCoverScrim = isCoverSelected) val hasRtl = selectedLines.any { it.isRtl } ShareCardSpec( mode = selectedMode, @@ -117,12 +120,21 @@ fun SharePreviewScreen( blurredBackgroundBitmap = artworkResolution.blurredBitmap, swatchColor = selectedSwatchColor, derivedColors = derived, + isCoverBackground = isCoverSelected, isRtl = hasRtl, targetWidth = ShareCardRenderer.BASE_WIDTH, scaleFactor = 0.50f, // Scaled for fast live preview ) } + // Auto-revert cover swatch to color swatch if user switches to Song mode + LaunchedEffect(selectedMode) { + if (selectedMode == CardMode.Song && selectedSwatchColor == ColorContrastHelper.SWATCH_COVER_ART) { + val fallback = swatches.firstOrNull { !it.isCoverArt }?.color ?: ColorContrastHelper.BRAND_LIME + onSwatchChange(fallback) + } + } + var previewBitmap by remember { mutableStateOf<Bitmap?>(null) } var isPreviewRendering by remember { mutableStateOf(true) } var renderJob by remember { mutableStateOf<Job?>(null) } @@ -301,7 +313,22 @@ fun SharePreviewScreen( ) } - // YT Music Style Color Swatches Picker + val displaySwatches = remember(swatches, selectedMode, artworkResolution.coverBitmap) { + if (selectedMode == CardMode.Lyrics && artworkResolution.coverBitmap != null) { + listOf( + ColorSwatch( + id = "cover_art", + nameRes = R.string.lyshare_color_cover, + color = ColorContrastHelper.SWATCH_COVER_ART, + isCoverArt = true, + ) + ) + swatches.filter { !it.isCoverArt } + } else { + swatches.filter { !it.isCoverArt } + } + } + + // YT Music Style Color Swatches Picker (with Cover swatch as first item in Lyrics mode) LazyRow( modifier = Modifier .fillMaxWidth() @@ -311,7 +338,7 @@ fun SharePreviewScreen( horizontalArrangement = Arrangement.spacedBy(14.dp), verticalAlignment = Alignment.CenterVertically, ) { - items(swatches, key = { it.id }) { swatch -> + items(displaySwatches, key = { it.id }) { swatch -> val isSelected = swatch.color == selectedSwatchColor val swatchName = stringResource(swatch.nameRes) @@ -319,7 +346,13 @@ fun SharePreviewScreen( modifier = Modifier .size(44.dp) .clip(CircleShape) - .background(Color(swatch.color)) + .then( + if (swatch.isCoverArt) { + Modifier + } else { + Modifier.background(Color(swatch.color)) + } + ) .then( if (isSelected) { Modifier.border(BorderStroke(3.dp, Color.White), CircleShape) @@ -335,6 +368,16 @@ fun SharePreviewScreen( }, contentAlignment = Alignment.Center, ) { + if (swatch.isCoverArt && artworkResolution.coverBitmap != null) { + Image( + bitmap = artworkResolution.coverBitmap.asImageBitmap(), + contentDescription = null, + contentScale = androidx.compose.ui.layout.ContentScale.Crop, + modifier = Modifier + .fillMaxSize() + .clip(CircleShape), + ) + } if (isSelected) { Box( modifier = Modifier From 06b0f65b1779e7b6aa676aad0e1ebf05cc71619c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:02:57 +0530 Subject: [PATCH 08/10] feat(lyrics): rewrite ShareCardRenderer with word-wrapped lyrics, 1:1 to 9:16 aspect ratio, and YT/Spotify lockup --- .../player/lyricsshare/ShareCardRenderer.kt | 679 +++++++++++------- .../player/lyricsshare/ShareCardMathTest.kt | 28 +- .../lyricsshare/ShareCardRendererTest.kt | 134 ++-- 3 files changed, 531 insertions(+), 310 deletions(-) diff --git a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt index 61e38d2ea7..dec1e21a13 100644 --- a/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt +++ b/app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRenderer.kt @@ -23,14 +23,25 @@ import com.lastwave.app.R import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import kotlin.math.max -import kotlin.math.min import kotlin.math.roundToInt object ShareCardRenderer { const val BASE_WIDTH: Int = 1080 - const val MIN_HEIGHT: Int = 1350 // 4:5 - const val MAX_HEIGHT: Int = 1920 // 9:16 + const val MIN_HEIGHT: Int = 1080 // 1:1 square aspect ratio minimum (no big empty areas) + const val MAX_HEIGHT: Int = 1920 // 9:16 vertical story aspect ratio maximum + + const val LYRIC_LINE_SPACING_MULTIPLIER: Float = 1.18f + const val LYRIC_BLOCK_GAP_FACTOR: Float = 0.45f + + const val BASE_LYRIC_FONT_SIZE: Float = 84f + const val MIN_LYRIC_FONT_SIZE: Float = 52f + + const val BASE_TITLE_FONT_SIZE: Float = 46f + const val BASE_ARTIST_FONT_SIZE: Float = 40f + + const val BASE_SONG_LYRIC_FONT_SIZE: Float = 64f + const val MIN_SONG_LYRIC_FONT_SIZE: Float = 44f /** * Renders the card into an immutable software [Bitmap] with automatic OOM retry. @@ -54,26 +65,29 @@ object ShareCardRenderer { ): Bitmap { val scale = spec.scaleFactor val width = (spec.targetWidth * scale).roundToInt().coerceAtLeast(320) - val minH = ((spec.targetWidth * 5 / 4) * scale).roundToInt() - val maxH = ((spec.targetWidth * 16 / 9) * scale).roundToInt() + val minH = (width * 1.0f).roundToInt() // 1:1 minimum + val maxH = (width * 16.0f / 9.0f).roundToInt() // 9:16 maximum + + val hPadding = (60 * scale).roundToInt() + val contentWidth = width - (hPadding * 2) - // Measure content height requirements - val measuredHeight = measureRequiredHeight(context, spec, width, scale) - val height = measuredHeight.coerceIn(minH, maxH) + // Measure required height and calculate fitted font size + val layoutPlan = measureLayoutPlan(context, spec, contentWidth, scale, maxH) + val height = layoutPlan.requiredHeight.coerceIn(minH, maxH) val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888) val canvas = Canvas(bitmap) if (spec.mode == CardMode.Song) { - renderSongCard(canvas, context, spec, width, height, scale) + renderSongCard(canvas, context, spec, width, height, hPadding, contentWidth, scale, layoutPlan) } else { - renderLyricsCard(canvas, context, spec, width, height, scale) + renderLyricsCard(canvas, context, spec, width, height, hPadding, contentWidth, scale, layoutPlan) } return bitmap } - private fun getTypeface(context: Context, weight: Int): Typeface { + fun getTypeface(context: Context, weight: Int): Typeface { return try { val base = ResourcesCompat.getFont(context, R.font.google_sans_flex) if (base != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { @@ -86,338 +100,469 @@ object ShareCardRenderer { } } - private fun measureRequiredHeight( - context: Context, - spec: ShareCardSpec, - width: Int, - scale: Float, - ): Int { - val hPadding = (72 * scale).roundToInt() - val contentWidth = width - (hPadding * 2) - - return if (spec.mode == CardMode.Song) { - val artSize = (440 * scale).roundToInt() - val topMargin = (72 * scale).roundToInt() - val artToTitle = (28 * scale).roundToInt() - val titleH = (44 * scale).roundToInt() - val artistH = (32 * scale).roundToInt() - val dividerSpace = (36 * scale).roundToInt() - val lyricsHeight = measureLyricsBlockHeight(context, spec, contentWidth, scale, maxFontSize = 46f) - val footerSpace = (100 * scale).roundToInt() - - topMargin + artSize + artToTitle + titleH + artistH + dividerSpace + lyricsHeight + footerSpace - } else { - val topMargin = (84 * scale).roundToInt() - val attrHeight = (54 * scale).roundToInt() - val lyricsHeight = measureLyricsBlockHeight(context, spec, contentWidth, scale, maxFontSize = 58f) - val footerSpace = (120 * scale).roundToInt() - - topMargin + attrHeight + lyricsHeight + footerSpace - } - } - - private fun measureLyricsBlockHeight( - context: Context, - spec: ShareCardSpec, - contentWidth: Int, - scale: Float, - maxFontSize: Float, - ): Int { - val boldTypeface = getTypeface(context, 700) - val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { - typeface = boldTypeface - textSize = maxFontSize * scale - } - - var totalH = 0 - val lineSpacing = (18 * scale).roundToInt() - for (line in spec.lines) { - val layout = createStaticLayout(line.text, textPaint, contentWidth, line.isRtl) - totalH += layout.height + lineSpacing + fun wrapTextToWidth( + text: CharSequence, + paint: TextPaint, + maxWidth: Int, + ): CharSequence { + if (maxWidth <= 0) return text + val rawLines = text.split("\n") + val result = mutableListOf<String>() + + for (rawLine in rawLines) { + if (paint.measureText(rawLine) <= maxWidth) { + result.add(rawLine) + } else { + val words = rawLine.split(" ") + if (words.size <= 1) { + result.add(rawLine) + } else { + var currentLine = StringBuilder() + for (word in words) { + val candidate = if (currentLine.isEmpty()) word else "$currentLine $word" + if (paint.measureText(candidate) <= maxWidth) { + currentLine = StringBuilder(candidate) + } else { + if (currentLine.isNotEmpty()) { + result.add(currentLine.toString()) + currentLine = StringBuilder(word) + } else { + result.add(word) + } + } + } + if (currentLine.isNotEmpty()) { + result.add(currentLine.toString()) + } + } + } } - return totalH + return result.joinToString("\n") } - private fun createStaticLayout( + fun createStaticLayout( text: CharSequence, paint: TextPaint, width: Int, isRtl: Boolean, + spacingMult: Float = LYRIC_LINE_SPACING_MULTIPLIER, ): StaticLayout { val alignment = if (isRtl) Layout.Alignment.ALIGN_OPPOSITE else Layout.Alignment.ALIGN_NORMAL val safeWidth = max(width, 10) + val wrappedText = wrapTextToWidth(text, paint, safeWidth) return try { - StaticLayout.Builder.obtain(text, 0, text.length, paint, safeWidth)?.let { builder -> + StaticLayout.Builder.obtain(wrappedText, 0, wrappedText.length, paint, safeWidth).let { builder -> builder.setAlignment(alignment) - .setLineSpacing(0f, 1.25f) - .setIncludePad(true) // Crucial for Hindi/Devanagari matras and Arabic ascenders + .setLineSpacing(0f, spacingMult) + .setIncludePad(true) // Crucial for Hindi/Devanagari matras, Arabic marks, and ascenders .build() - } ?: @Suppress("DEPRECATION") StaticLayout(text, 0, text.length, paint, safeWidth, alignment, 1.25f, 0f, true) + } } catch (_: Throwable) { @Suppress("DEPRECATION") - StaticLayout(text, 0, text.length, paint, safeWidth, alignment, 1.25f, 0f, true) + StaticLayout(wrappedText, 0, wrappedText.length, paint, safeWidth, alignment, spacingMult, 0f, true) + } + } + + private data class LayoutPlan( + val fontSize: Float, + val lyricLayouts: List<StaticLayout>, + val lyricsBlockHeight: Int, + val requiredHeight: Int, + val headerHeight: Int = 0, + val titleLayout: StaticLayout? = null, + val artistLayout: StaticLayout? = null, + ) + + private fun measureLayoutPlan( + context: Context, + spec: ShareCardSpec, + contentWidth: Int, + scale: Float, + maxAllowedHeight: Int, + ): LayoutPlan { + val boldTypeface = getTypeface(context, 700) + val regularTypeface = getTypeface(context, 450) + + val topPadding = (60 * scale).roundToInt() + val bottomPadding = (60 * scale).roundToInt() + val footerHeight = (64 * scale).roundToInt() + + if (spec.mode == CardMode.Lyrics) { + // Lyrics Card: Header has small cover thumbnail (180px) on left + Title & Artist on right + val thumbSize = (180 * scale).roundToInt() + val textGap = (24 * scale).roundToInt() + val textWidth = (contentWidth - thumbSize - textGap).coerceAtLeast(100) + + val titlePaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = BASE_TITLE_FONT_SIZE * scale + color = spec.derivedColors.lyricsTextColor + } + val titleLayout = createStaticLayout(spec.title, titlePaint, textWidth, spec.isRtl, 1.15f) + + val artistPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = regularTypeface + textSize = BASE_ARTIST_FONT_SIZE * scale + color = spec.derivedColors.secondaryTextColor + } + val artistLayout = createStaticLayout(spec.artist, artistPaint, textWidth, spec.isRtl, 1.15f) + + val textBlockHeight = titleLayout.height + (8 * scale).roundToInt() + artistLayout.height + val headerHeight = max(thumbSize, textBlockHeight) + + val dividerSpace = (26 * scale).roundToInt() + (32 * scale).roundToInt() + val footerGap = (84 * scale).roundToInt() + + var fontSize = BASE_LYRIC_FONT_SIZE * scale + val floor = MIN_LYRIC_FONT_SIZE * scale + + var bestPlan: LayoutPlan? = null + + while (fontSize >= floor) { + val lyricPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = fontSize + color = spec.derivedColors.lyricsTextColor + } + + val layouts = spec.lines.map { createStaticLayout(it.text, lyricPaint, contentWidth, it.isRtl) } + val blockGap = fontSize * LYRIC_BLOCK_GAP_FACTOR + val lyricsHeight = (layouts.sumOf { it.height.toDouble() } + (layouts.size - 1).coerceAtLeast(0) * blockGap).roundToInt() + + val totalReq = topPadding + headerHeight + dividerSpace + lyricsHeight + footerGap + footerHeight + bottomPadding + + val plan = LayoutPlan( + fontSize = fontSize, + lyricLayouts = layouts, + lyricsBlockHeight = lyricsHeight, + requiredHeight = totalReq, + headerHeight = headerHeight, + titleLayout = titleLayout, + artistLayout = artistLayout, + ) + + if (bestPlan == null || totalReq <= maxAllowedHeight) { + bestPlan = plan + } + if (totalReq <= maxAllowedHeight) { + return plan + } + + fontSize -= (2f * scale) + } + + return bestPlan!! + } else { + // Song Card: Hero Cover Art (680px) on top left, title, artist, divider, lyrics, brand footer + val heroSize = (680 * scale).roundToInt() + val heroToTitle = (28 * scale).roundToInt() + + val titlePaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = BASE_TITLE_FONT_SIZE * scale + color = spec.derivedColors.lyricsTextColor + } + val titleLayout = createStaticLayout(spec.title, titlePaint, contentWidth, spec.isRtl, 1.15f) + + val artistPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = regularTypeface + textSize = BASE_ARTIST_FONT_SIZE * scale + color = spec.derivedColors.secondaryTextColor + } + val artistLayout = createStaticLayout(spec.artist, artistPaint, contentWidth, spec.isRtl, 1.15f) + + val textBlockHeight = titleLayout.height + (8 * scale).roundToInt() + artistLayout.height + val dividerSpace = (24 * scale).roundToInt() + (28 * scale).roundToInt() + val footerGap = (72 * scale).roundToInt() + + var fontSize = BASE_SONG_LYRIC_FONT_SIZE * scale + val floor = MIN_SONG_LYRIC_FONT_SIZE * scale + + var bestPlan: LayoutPlan? = null + + while (fontSize >= floor) { + val lyricPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + typeface = boldTypeface + textSize = fontSize + color = spec.derivedColors.lyricsTextColor + } + + val layouts = spec.lines.map { createStaticLayout(it.text, lyricPaint, contentWidth, it.isRtl) } + val blockGap = fontSize * LYRIC_BLOCK_GAP_FACTOR + val lyricsHeight = (layouts.sumOf { it.height.toDouble() } + (layouts.size - 1).coerceAtLeast(0) * blockGap).roundToInt() + + val totalReq = topPadding + heroSize + heroToTitle + textBlockHeight + dividerSpace + lyricsHeight + footerGap + footerHeight + bottomPadding + + val plan = LayoutPlan( + fontSize = fontSize, + lyricLayouts = layouts, + lyricsBlockHeight = lyricsHeight, + requiredHeight = totalReq, + headerHeight = heroSize, + titleLayout = titleLayout, + artistLayout = artistLayout, + ) + + if (bestPlan == null || totalReq <= maxAllowedHeight) { + bestPlan = plan + } + if (totalReq <= maxAllowedHeight) { + return plan + } + + fontSize -= (2f * scale) + } + + return bestPlan!! } } // ========================================== - // SONG CARD RENDERING + // LYRICS CARD RENDERING (YT Music & Spotify style) // ========================================== - private fun renderSongCard( + private fun renderLyricsCard( canvas: Canvas, context: Context, spec: ShareCardSpec, width: Int, height: Int, + hPadding: Int, + contentWidth: Int, scale: Float, + plan: LayoutPlan, ) { - // 1. Blurred background image - val bgPaint = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG) - val blurBitmap = spec.blurredBackgroundBitmap - if (blurBitmap != null && !blurBitmap.isRecycled) { - val src = Rect(0, 0, blurBitmap.width, blurBitmap.height) - val dst = Rect(0, 0, width, height) - canvas.drawBitmap(blurBitmap, src, dst, bgPaint) - } else { - val fallback = ArtworkResolver.createBrandFallbackGradient(spec.swatchColor, width, height) - canvas.drawBitmap(fallback, 0f, 0f, bgPaint) - } - - // 2. Color scrim overlay with high-contrast guarantee - val scrimPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { - color = spec.swatchColor - alpha = if (spec.derivedColors.isDarkBackground) 180 else 215 - } - canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), scrimPaint) - - // Dark gradient scrim from top to bottom to ground the layout - val vignettePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { - shader = LinearGradient( - 0f, 0f, 0f, height.toFloat(), - intArrayOf(0x44000000, 0x11000000, 0x88000000.toInt()), - floatArrayOf(0.0f, 0.45f, 1.0f), - Shader.TileMode.CLAMP, - ) - } - canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), vignettePaint) + // 1. Background + if (spec.isCoverBackground && spec.coverBitmap != null && !spec.coverBitmap.isRecycled) { + // Full-bleed center-cropped cover art with ~50% dark scrim + gradient protection + drawCenterCropCover(canvas, spec.coverBitmap, width, height) + canvas.drawColor(0x80000000.toInt()) // ~50% black scrim - val hPadding = (72 * scale).roundToInt() - val contentWidth = width - (hPadding * 2) - var currentY = (64 * scale) - - // 3. Prominent Cover Art (centered, rounded corners, soft shadow) - val artSize = (440 * scale).roundToInt() - val artX = (width - artSize) / 2f - val artRect = RectF(artX, currentY, artX + artSize, currentY + artSize) - val cornerRadius = 24f * scale - - // Soft shadow - val shadowPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { - color = 0x55000000 - maskFilter = null - } - val shadowRect = RectF(artRect.left, artRect.top + 6 * scale, artRect.right, artRect.bottom + 10 * scale) - canvas.drawRoundRect(shadowRect, cornerRadius, cornerRadius, shadowPaint) - - // Draw cover bitmap or placeholder - val coverBitmap = spec.coverBitmap - if (coverBitmap != null && !coverBitmap.isRecycled) { - val roundedCover = getRoundedBitmap(coverBitmap, cornerRadius, artSize, artSize) - canvas.drawBitmap(roundedCover, artRect.left, artRect.top, null) + val scrimGrad = Paint(Paint.ANTI_ALIAS_FLAG).apply { + shader = LinearGradient( + 0f, 0f, 0f, height.toFloat(), + intArrayOf(0x66000000, 0x10000000, 0x88000000.toInt()), + floatArrayOf(0.0f, 0.40f, 1.0f), + Shader.TileMode.CLAMP, + ) + } + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), scrimGrad) } else { - // Placeholder rounded card with brand logo - val placeholderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + // Rich flat / subtle same-hue gradient (YT style - no muddy blur) + val topColor = spec.derivedColors.backgroundColor or 0xFF000000.toInt() + val hsv = FloatArray(3) + AndroidColor.colorToHSV(topColor, hsv) + hsv[2] = (hsv[2] * 0.82f).coerceAtLeast(0.08f) // slightly deeper shade at bottom + val bottomColor = AndroidColor.HSVToColor(0xFF, hsv) or 0xFF000000.toInt() + + canvas.drawColor(topColor) // Explicit opaque fill + val bgPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { shader = LinearGradient( - artRect.left, artRect.top, artRect.right, artRect.bottom, - intArrayOf(spec.swatchColor, ColorContrastHelper.DEFAULT_DARK), + 0f, 0f, 0f, height.toFloat(), + intArrayOf(topColor, bottomColor), null, Shader.TileMode.CLAMP, ) } - canvas.drawRoundRect(artRect, cornerRadius, cornerRadius, placeholderPaint) - drawLogoMark(canvas, context, artRect.centerX(), artRect.centerY(), (64 * scale).roundToInt(), spec.derivedColors.lyricsTextColor) + canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), bgPaint) } - currentY += artSize + (28 * scale) + var currentY = (60 * scale) - // 4. Song title & artist - val titlePaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { - typeface = getTypeface(context, 700) - textSize = 38f * scale - color = spec.derivedColors.lyricsTextColor + // 2. Header: Rounded Cover Thumbnail (left) + Title and Artist (right) + val thumbSize = (180 * scale).roundToInt() + val thumbRadius = 22f * scale + val textGap = (24 * scale).roundToInt() + val textX = (hPadding + thumbSize + textGap).toFloat() + + if (spec.coverBitmap != null && !spec.coverBitmap.isRecycled) { + val roundedThumb = getRoundedBitmap(spec.coverBitmap, thumbRadius, thumbSize, thumbSize) + canvas.drawBitmap(roundedThumb, hPadding.toFloat(), currentY, null) + } else { + // Fallback thumbnail with subtle gradient and brand mark + val thumbRect = RectF(hPadding.toFloat(), currentY, (hPadding + thumbSize).toFloat(), currentY + thumbSize) + val thumbBgPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = AndroidColor.argb(40, 255, 255, 255) + } + canvas.drawRoundRect(thumbRect, thumbRadius, thumbRadius, thumbBgPaint) + drawLogoMark(canvas, context, thumbRect.centerX(), thumbRect.centerY(), (48 * scale).roundToInt(), spec.derivedColors.lyricsTextColor) } - val titleLayout = createStaticLayout(spec.title, titlePaint, contentWidth, spec.isRtl) - canvas.save() - canvas.translate(hPadding.toFloat(), currentY) - titleLayout.draw(canvas) - canvas.restore() - currentY += titleLayout.height + (6 * scale) - - val artistPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { - typeface = getTypeface(context, 450) - textSize = 28f * scale - color = spec.derivedColors.secondaryTextColor + + // Title and Artist alongside thumbnail + val titleLayout = plan.titleLayout + val artistLayout = plan.artistLayout + if (titleLayout != null && artistLayout != null) { + val textBlockHeight = titleLayout.height + (8 * scale).roundToInt() + artistLayout.height + val textOffsetY = if (thumbSize > textBlockHeight) (thumbSize - textBlockHeight) / 2f else 0f + val textStartY = currentY + textOffsetY + + canvas.save() + canvas.translate(textX, textStartY) + titleLayout.draw(canvas) + canvas.restore() + + canvas.save() + canvas.translate(textX, textStartY + titleLayout.height + (8 * scale)) + artistLayout.draw(canvas) + canvas.restore() } - val artistLayout = createStaticLayout(spec.artist, artistPaint, contentWidth, spec.isRtl) - canvas.save() - canvas.translate(hPadding.toFloat(), currentY) - artistLayout.draw(canvas) - canvas.restore() - currentY += artistLayout.height + (24 * scale) - - // 5. Thin divider + + currentY += plan.headerHeight + (26 * scale) + + // 3. Thin divider line val dividerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { - color = spec.derivedColors.secondaryTextColor - alpha = 50 - strokeWidth = 1.5f * scale + color = spec.derivedColors.dividerColor + strokeWidth = 2f * scale } canvas.drawLine(hPadding.toFloat(), currentY, (width - hPadding).toFloat(), currentY, dividerPaint) - currentY += (24 * scale) + currentY += (32 * scale) - // 6. Selected Lyrics (auto-fitted) - val footerAreaH = (88 * scale) - val availableLyricsH = (height - currentY - footerAreaH).coerceAtLeast(100f) - drawFittedLyrics(canvas, context, spec, hPadding, currentY, contentWidth, availableLyricsH, scale, startFontSize = 46f) + // 4. Large bold tinted lyrics (word wrapped naturally, tight line spacing, generous block gap) + val blockGap = plan.fontSize * LYRIC_BLOCK_GAP_FACTOR - // 7. Brand footer - drawFooter(canvas, context, width, height, scale, spec.derivedColors.brandTextColor) + // Calculate available vertical breathing room if card is clamped to 1:1 square + val footerAreaH = (64 * scale) + (60 * scale) + val remainingSpace = height - currentY - plan.lyricsBlockHeight - footerAreaH + if (remainingSpace > (40 * scale)) { + currentY += (remainingSpace * 0.35f) // visually center lyrics slightly if tall square + } + + for (layout in plan.lyricLayouts) { + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + layout.draw(canvas) + canvas.restore() + currentY += layout.height + blockGap + } + + // 5. Brand footer: bottom-left aligned to hPadding! + drawBrandFooterLeft(canvas, context, hPadding, height, scale, spec.derivedColors.brandTextColor) } // ========================================== - // LYRICS CARD RENDERING + // SONG CARD RENDERING (Hero Cover, left-aligned) // ========================================== - private fun renderLyricsCard( + private fun renderSongCard( canvas: Canvas, context: Context, spec: ShareCardSpec, width: Int, height: Int, + hPadding: Int, + contentWidth: Int, scale: Float, + plan: LayoutPlan, ) { - // Flat / subtle gradient background + // 1. Background: rich flat / subtle gradient of selected swatch (NO muddy blur!) + val topColor = spec.derivedColors.backgroundColor or 0xFF000000.toInt() + val hsv = FloatArray(3) + AndroidColor.colorToHSV(topColor, hsv) + hsv[2] = (hsv[2] * 0.82f).coerceAtLeast(0.08f) + val bottomColor = AndroidColor.HSVToColor(0xFF, hsv) or 0xFF000000.toInt() + + canvas.drawColor(topColor) // Explicit opaque fill val bgPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { - val darkerBg = AndroidColor.rgb( - (AndroidColor.red(spec.swatchColor) * 0.45f).toInt(), - (AndroidColor.green(spec.swatchColor) * 0.45f).toInt(), - (AndroidColor.blue(spec.swatchColor) * 0.45f).toInt(), - ) shader = LinearGradient( 0f, 0f, 0f, height.toFloat(), - intArrayOf(spec.swatchColor, darkerBg, ColorContrastHelper.DEFAULT_DARK), - floatArrayOf(0.0f, 0.6f, 1.0f), + intArrayOf(topColor, bottomColor), + null, Shader.TileMode.CLAMP, ) } canvas.drawRect(0f, 0f, width.toFloat(), height.toFloat(), bgPaint) - val hPadding = (80 * scale).roundToInt() - val contentWidth = width - (hPadding * 2) - var currentY = (72 * scale) + var currentY = (60 * scale) - // Small attribution: "Title • Artist" - val attrPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { - typeface = getTypeface(context, 600) - textSize = 28f * scale - color = spec.derivedColors.secondaryTextColor - } - val attrText = "${spec.title} • ${spec.artist}" - val attrLayout = createStaticLayout(attrText, attrPaint, contentWidth, spec.isRtl) - canvas.save() - canvas.translate(hPadding.toFloat(), currentY) - attrLayout.draw(canvas) - canvas.restore() - currentY += attrLayout.height + (36 * scale) - - // Hero Lyrics - val footerAreaH = (100 * scale) - val availableLyricsH = (height - currentY - footerAreaH).coerceAtLeast(100f) - drawFittedLyrics(canvas, context, spec, hPadding, currentY, contentWidth, availableLyricsH, scale, startFontSize = 58f) - - // Brand footer - drawFooter(canvas, context, width, height, scale, spec.derivedColors.brandTextColor) - } + // 2. Hero Cover Art: large (~65% width), left-aligned to hPadding (no stray centering, no dark bottom strip!) + val heroSize = plan.headerHeight + val cornerRadius = 32f * scale + val heroRect = RectF(hPadding.toFloat(), currentY, (hPadding + heroSize).toFloat(), currentY + heroSize) - /** - * Auto-fits lyrics font size so 1 to 5 lines never overflow or clip. - */ - private fun drawFittedLyrics( - canvas: Canvas, - context: Context, - spec: ShareCardSpec, - x: Int, - startY: Float, - contentWidth: Int, - availableHeight: Float, - scale: Float, - startFontSize: Float, - ) { - val boldTypeface = getTypeface(context, 700) - var fontSize = startFontSize - val minFontSize = 24f - val lineSpacing = (20 * scale) + if (spec.coverBitmap != null && !spec.coverBitmap.isRecycled) { + val roundedHero = getRoundedBitmap(spec.coverBitmap, cornerRadius, heroSize, heroSize) + canvas.drawBitmap(roundedHero, heroRect.left, heroRect.top, null) + } else { + // Placeholder hero card + val placeholderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = AndroidColor.argb(40, 255, 255, 255) + } + canvas.drawRoundRect(heroRect, cornerRadius, cornerRadius, placeholderPaint) + drawLogoMark(canvas, context, heroRect.centerX(), heroRect.centerY(), (80 * scale).roundToInt(), spec.derivedColors.lyricsTextColor) + } - var layouts: List<StaticLayout> - var totalHeight: Float + currentY += heroSize + (28 * scale) - do { - val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { - typeface = boldTypeface - textSize = fontSize * scale - color = spec.derivedColors.lyricsTextColor - } - layouts = spec.lines.map { createStaticLayout(it.text, paint, contentWidth, it.isRtl) } - totalHeight = layouts.sumOf { it.height.toDouble() }.toFloat() + ((layouts.size - 1) * lineSpacing) + // 3. Title and Artist + val titleLayout = plan.titleLayout + if (titleLayout != null) { + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + titleLayout.draw(canvas) + canvas.restore() + currentY += titleLayout.height + (8 * scale) + } - if (totalHeight <= availableHeight || fontSize <= minFontSize) { - break - } - fontSize -= 2f - } while (fontSize >= minFontSize) + val artistLayout = plan.artistLayout + if (artistLayout != null) { + canvas.save() + canvas.translate(hPadding.toFloat(), currentY) + artistLayout.draw(canvas) + canvas.restore() + currentY += artistLayout.height + (24 * scale) + } - // Center vertically in available slot if there's spare room - val offsetTop = if (availableHeight > totalHeight) { - startY + ((availableHeight - totalHeight) * 0.35f) - } else { - startY + // 4. Thin divider line + val dividerPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { + color = spec.derivedColors.dividerColor + strokeWidth = 2f * scale } + canvas.drawLine(hPadding.toFloat(), currentY, (width - hPadding).toFloat(), currentY, dividerPaint) + currentY += (28 * scale) - var y = offsetTop - for (layout in layouts) { + // 5. Hero Lyrics (auto wrapped, generous block gap) + val blockGap = plan.fontSize * LYRIC_BLOCK_GAP_FACTOR + + for (layout in plan.lyricLayouts) { canvas.save() - canvas.translate(x.toFloat(), y) + canvas.translate(hPadding.toFloat(), currentY) layout.draw(canvas) canvas.restore() - y += layout.height + lineSpacing + currentY += layout.height + blockGap } + + // 6. Brand footer: bottom-left aligned to hPadding! + drawBrandFooterLeft(canvas, context, hPadding, height, scale, spec.derivedColors.brandTextColor) } - private fun drawFooter( + /** + * Draws the brand lockup on the BOTTOM-LEFT aligned with the same left margin as the lyrics and header. + * Lockup occupies ~35-40% of card width. + */ + private fun drawBrandFooterLeft( canvas: Canvas, context: Context, - width: Int, + x: Int, height: Int, scale: Float, brandColor: Int, ) { - val footerY = height - (56 * scale) - val logoSize = (32 * scale).roundToInt() + val footerY = height - (60 * scale) + val logoSize = (64 * scale).roundToInt() + val gap = (14 * scale) + val textPaint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { typeface = getTypeface(context, 750) - textSize = 24f * scale + textSize = 64f * scale color = brandColor } - val brandName = "LastWave" - val textWidth = textPaint.measureText(brandName) - val gap = 12f * scale - val totalWidth = logoSize + gap + textWidth - val startX = (width - totalWidth) / 2f + // Draw tintable logo mark + drawLogoMark(canvas, context, x + (logoSize / 2f), footerY - (logoSize / 2f), logoSize, brandColor) - // Draw logo mark - drawLogoMark(canvas, context, startX + (logoSize / 2f), footerY, logoSize, brandColor) - - // Draw brand name - val textY = footerY + (textPaint.textSize * 0.35f) - canvas.drawText(brandName, startX + logoSize + gap, textY, textPaint) + // Draw "LastWave" text aligned horizontally with logo + val brandName = "LastWave" + val textX = x + logoSize + gap + val textY = footerY - (logoSize * 0.18f) + canvas.drawText(brandName, textX, textY, textPaint) } private fun drawLogoMark( @@ -437,6 +582,32 @@ object ShareCardRenderer { drawable.draw(canvas) } + private fun drawCenterCropCover(canvas: Canvas, source: Bitmap, targetW: Int, targetH: Int) { + val srcW = source.width + val srcH = source.height + + val srcRatio = srcW.toFloat() / srcH.toFloat() + val targetRatio = targetW.toFloat() / targetH.toFloat() + + val cropW: Int + val cropH: Int + if (srcRatio > targetRatio) { + cropH = srcH + cropW = (srcH * targetRatio).roundToInt() + } else { + cropW = srcW + cropH = (srcW / targetRatio).roundToInt() + } + + val cropX = (srcW - cropW) / 2 + val cropY = (srcH - cropH) / 2 + + val srcRect = Rect(cropX, cropY, cropX + cropW, cropY + cropH) + val dstRect = Rect(0, 0, targetW, targetH) + val paint = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG) + canvas.drawBitmap(source, srcRect, dstRect, paint) + } + private fun getRoundedBitmap(source: Bitmap, cornerRadius: Float, targetW: Int, targetH: Int): Bitmap { val output = Bitmap.createBitmap(targetW, targetH, Bitmap.Config.ARGB_8888) val canvas = Canvas(output) diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt index c2874d3395..44f3668ce7 100644 --- a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardMathTest.kt @@ -7,24 +7,24 @@ import org.junit.Test class ShareCardMathTest { @Test - fun cardDimensions_target1080_clampsBetween4to5And9to16() { + fun cardDimensions_target1080_clampsBetween1to1And9to16() { val targetWidth = 1080 val scale = 1.0f val width = (targetWidth * scale).roundToInt().coerceAtLeast(320) - val minH = ((targetWidth * 5 / 4) * scale).roundToInt() - val maxH = ((targetWidth * 16 / 9) * scale).roundToInt() + val minH = (width * 1.0f).roundToInt() + val maxH = (width * 16.0f / 9.0f).roundToInt() assertThat(width).isEqualTo(1080) - // 4:5 ratio -> 1080 x 1350 - assertThat(minH).isEqualTo(1350) - // 9:16 ratio -> 1080 x 1920 + // 1:1 ratio -> 1080 x 1080 (min square clamp) + assertThat(minH).isEqualTo(1080) + // 9:16 ratio -> 1080 x 1920 (max story clamp) assertThat(maxH).isEqualTo(1920) - // Short lyrics should clamp to 1350 (4:5) + // Short lyrics should clamp to 1080 (1:1) val measuredShort = 900 val clampedShort = measuredShort.coerceIn(minH, maxH) - assertThat(clampedShort).isEqualTo(1350) + assertThat(clampedShort).isEqualTo(1080) // Long lyrics should clamp to 1920 (9:16) val measuredLong = 2400 @@ -32,9 +32,9 @@ class ShareCardMathTest { assertThat(clampedLong).isEqualTo(1920) // Intermediate lyrics stays within bounds - val measuredMid = 1600 + val measuredMid = 1450 val clampedMid = measuredMid.coerceIn(minH, maxH) - assertThat(clampedMid).isEqualTo(1600) + assertThat(clampedMid).isEqualTo(1450) } @Test @@ -43,15 +43,15 @@ class ShareCardMathTest { val scale = 0.75f val width = (targetWidth * scale).roundToInt().coerceAtLeast(320) - val minH = ((targetWidth * 5 / 4) * scale).roundToInt() - val maxH = ((targetWidth * 16 / 9) * scale).roundToInt() + val minH = (width * 1.0f).roundToInt() + val maxH = (width * 16.0f / 9.0f).roundToInt() assertThat(width).isEqualTo(810) - assertThat(minH).isEqualTo(1013) + assertThat(minH).isEqualTo(810) assertThat(maxH).isEqualTo(1440) val ratioMin = width.toDouble() / minH - assertThat(ratioMin).isWithin(0.01).of(4.0 / 5.0) + assertThat(ratioMin).isWithin(0.01).of(1.0) val ratioMax = width.toDouble() / maxH assertThat(ratioMax).isWithin(0.01).of(9.0 / 16.0) diff --git a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt index 39383fe58e..d0ef019bec 100644 --- a/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt +++ b/app/src/test/java/com/lastwave/app/ui/player/lyricsshare/ShareCardRendererTest.kt @@ -2,6 +2,8 @@ package com.lastwave.app.ui.player.lyricsshare import android.content.Context import android.graphics.Bitmap +import android.graphics.Paint +import android.text.TextPaint import com.google.common.truth.Truth.assertThat import kotlinx.coroutines.test.runTest import org.junit.Before @@ -9,8 +11,10 @@ import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.GraphicsMode @RunWith(RobolectricTestRunner::class) +@GraphicsMode(GraphicsMode.Mode.NATIVE) class ShareCardRendererTest { private lateinit var context: Context @@ -47,8 +51,8 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) - assertThat(bitmap.height).isAtLeast(720 * 5 / 4) - assertThat(bitmap.height).isAtMost(720 * 16 / 9) + assertThat(bitmap.height).isAtLeast(720) // 1:1 minimum + assertThat(bitmap.height).isAtMost(720 * 16 / 9) // 9:16 maximum } @Test @@ -70,7 +74,7 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) - assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + assertThat(bitmap.height).isAtLeast(720) } @Test @@ -92,22 +96,22 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720) } @Test - fun renderLyricsCard_withBlurredBackground_rendersSuccessfully() = runTest { + fun renderLyricsCard_withHeaderThumbnail_rendersSuccessfully() = runTest { val spec = ShareCardSpec( mode = CardMode.Lyrics, lines = listOf( - ShareLine("First verse line", isRtl = false), - ShareLine("Second verse line", isRtl = false), - ShareLine("Chorus climax line", isRtl = false), + ShareLine("I can't see clearly when you're gone", isRtl = false), + ShareLine("I said, \"Ooh, I'm blinded by the lights\"", isRtl = false), + ShareLine("No, I can't sleep until I feel your touch\"", isRtl = false), ), title = "Blinding Lights", artist = "The Weeknd", coverBitmap = sampleCover, - blurredBackgroundBitmap = sampleBlur, - swatchColor = ColorContrastHelper.BRAND_LIME, + swatchColor = 0xFF78350F.toInt(), // Warm Amber / Brown like YT Music targetWidth = 720, ) @@ -115,7 +119,8 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) - assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + assertThat(bitmap.height).isAtLeast(720) + assertThat(bitmap.height).isAtMost(720 * 16 / 9) } @Test @@ -128,7 +133,6 @@ class ShareCardRendererTest { title = "Acoustic Solo", artist = "Guitarist", coverBitmap = null, - blurredBackgroundBitmap = null, swatchColor = 0xFF0F172A.toInt(), targetWidth = 720, ) @@ -137,22 +141,24 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) - assertThat(bitmap.height).isAtLeast(720 * 5 / 4) + assertThat(bitmap.height).isAtLeast(720) } @Test - fun renderLyricsCard_failedArt_usesBrandFallbackGradient() = runTest { - val fallbackGradient = ArtworkResolver.createBrandFallbackGradient(ColorContrastHelper.DEFAULT_DARK, 200, 200) + fun renderLyricsCard_coverBackground_rendersSuccessfullyWithDimmedScrim() = runTest { val spec = ShareCardSpec( mode = CardMode.Lyrics, lines = listOf( - ShareLine("Failed backdrop resolution line", isRtl = false), + ShareLine("No one's around to judge me (oh)", isRtl = false), + ShareLine("I can't see clearly when you're gone", isRtl = false), + ShareLine("I said, \"Ooh, I'm blinded by the lights\"", isRtl = false), ), - title = "Uncached Song", - artist = "Indie Band", - coverBitmap = null, - blurredBackgroundBitmap = fallbackGradient, - swatchColor = ColorContrastHelper.DEFAULT_DARK, + title = "Blinding Lights", + artist = "The Weeknd", + coverBitmap = sampleCover, + swatchColor = ColorContrastHelper.SWATCH_COVER_ART, + derivedColors = ColorContrastHelper.deriveTextColors(ColorContrastHelper.SWATCH_COVER_ART, isCoverScrim = true), + isCoverBackground = true, targetWidth = 720, ) @@ -160,6 +166,72 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) + assertThat(bitmap.height).isAtLeast(720) + assertThat(bitmap.height).isAtMost(720 * 16 / 9) + } + + @Test + fun lyricWrapping_longLineProducesMultipleRows_shortLineProducesSingleRow() { + val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + textSize = 84f + } + val contentWidth = 60 + + val shortText = "I feel" + val shortLayout = ShareCardRenderer.createStaticLayout(shortText, paint, contentWidth, isRtl = false) + val longText = "This is an exceptionally long lyric line that definitely wraps onto multiple distinct rows within the card boundaries" + val longLayout = ShareCardRenderer.createStaticLayout(longText, paint, contentWidth, isRtl = false) + assertThat(shortLayout.lineCount).isEqualTo(1) + assertThat(longLayout.lineCount).isGreaterThan(1) + } + + @Test + fun lyricSpacing_gapBetweenDifferentLyricsIsGreaterThanWrappedRowSpacing() { + val fontSize = 84f + val paint = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + textSize = fontSize + } + val contentWidth = 40 + + val multiRowLyric = "I said, \"Ooh, I'm blinded by the lights, no I can't sleep until I feel your touch\"" + val layout = ShareCardRenderer.createStaticLayout(multiRowLyric, paint, contentWidth, isRtl = false) + assertThat(layout.lineCount).isGreaterThan(1) + + val row0Bottom = layout.getLineBottom(0) + val row1Top = layout.getLineTop(1) + val wrappedRowGap = (row1Top - row0Bottom).coerceAtLeast(0) + + val blockGap = fontSize * ShareCardRenderer.LYRIC_BLOCK_GAP_FACTOR + assertThat(blockGap).isGreaterThan(wrappedRowGap.toFloat()) + } + + @Test + fun heightClamp_shortCardClampsToSquare1to1_longCardClampsTo9to16() = runTest { + val shortSpec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = listOf(ShareLine("Single line", isRtl = false)), + title = "Title", + artist = "Artist", + targetWidth = 720, + ) + val shortBitmap = ShareCardRenderer.renderCard(context, shortSpec) + assertThat(shortBitmap.width).isEqualTo(720) + assertThat(shortBitmap.height).isEqualTo(720) // 1:1 minimum + + val veryLongText = "This is an exceptionally long lyric line designed to wrap onto multiple rows to test vertical clamping and font scaling under tight constraints" + val longSpec = ShareCardSpec( + mode = CardMode.Lyrics, + lines = (1..10).map { + ShareLine("$veryLongText (stanza $it)", isRtl = false) + }, + title = "Long Song Title That Wraps Across Rows", + artist = "Long Artist Name", + targetWidth = 720, + ) + val longBitmap = ShareCardRenderer.renderCard(context, longSpec) + assertThat(longBitmap.width).isEqualTo(720) + assertThat(longBitmap.height).isAtMost(720 * 16 / 9) // 9:16 maximum bound + assertThat(longBitmap.height).isAtLeast(1200) } @Test @@ -234,26 +306,4 @@ class ShareCardRendererTest { assertThat(bitmap).isNotNull() assertThat(bitmap.width).isEqualTo(720) } - - @Test - fun renderText_longMultilineLines_wrapWithoutClipping() = runTest { - val spec = ShareCardSpec( - mode = CardMode.Lyrics, - lines = listOf( - ShareLine( - "This is an exceptionally long lyric line designed specifically to wrap onto multiple distinct rows within StaticLayout to ensure that boundary measurement and vertical clamping do not cause text clipping or crash under tight constraints.", - isRtl = false, - ), - ), - title = "Long Text Wrap Song", - artist = "Progressive Composer", - targetWidth = 720, - ) - - val bitmap = ShareCardRenderer.renderCard(context, spec) - assertThat(bitmap).isNotNull() - assertThat(bitmap.width).isEqualTo(720) - assertThat(bitmap.height).isAtLeast(720 * 5 / 4) - assertThat(bitmap.height).isAtMost(720 * 16 / 9) - } } From f8f7958e3c54bb3b700c4944f200057f49b3bdff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:03:42 +0530 Subject: [PATCH 09/10] docs: document UI polish and visual redesign updates in share lyrics report --- SHARE_LYRICS_REPORT.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/SHARE_LYRICS_REPORT.md b/SHARE_LYRICS_REPORT.md index d65d93319c..f667a85baa 100644 --- a/SHARE_LYRICS_REPORT.md +++ b/SHARE_LYRICS_REPORT.md @@ -185,3 +185,30 @@ These were fixed in an isolated commit (`7fe43b9`) so the repository could build 1. **Hardware Bitmaps:** Canvas rendering and palette extraction on Android cannot operate directly on hardware bitmaps; `ArtworkResolver` strictly enforces software decoding via `allowHardware(false)` and bitmap copying if needed. 2. **Release Signing Keys:** Production CI builds must inject `SIGNING_KEY` (base64 keystore) or `RELEASE_STORE_FILE` + credentials via environment variables as enforced by `build.gradle.kts`. Local testing validated the release pipeline using a temporary key with identical R8 configurations. + +--- + +## 7. UI Polish & Visual Redesign (v2) + +Following design references from YouTube Music and Spotify, the feature visuals were overhauled while preserving 100% of the underlying business logic: + +### 7.1 Select Lyrics Screen (Spotify Visual Target) +- **Vivid Hue Gradient Background:** Replaced dark mud/grey fades with a saturated, rich vertical gradient derived from the song's primary color, smoothly transitioning from a deep tone to a slightly lighter shade of the same hue (`ColorContrastHelper.getSelectScreenGradientColors`). +- **Centered Header:** Clean header with centered `"Select lyrics"` title and `"N lines selected"` subtitle within safe window insets. +- **Bold Lyrics Typography:** Google Sans Flex (`wght 700`), 15% larger size (`21sp`, `lineHeight 27sp`, `letterSpacing -0.2sp`). Unselected lines render in bright crisp white. +- **Solid White Rounded Pills:** Consecutive selected lines each receive their own solid white rounded pill (`26dp` corner radius) with dark text tinted from the song's hue (`ColorContrastHelper.getSelectedPillTextColor`). +- **Extendable Neighbors:** Lines directly adjacent (index $\pm 1$) to the active selection block receive a subtle 16% alpha white pill that smoothly animates during selection changes without layout jumps. +- **Compact Continue Pill:** Replaced full-width bottom button with a compact floating pill (`152dp` wide, `50dp` tall) with white fill and bold dark label, positioned above the nav bar inset with a soft vertical gradient fade behind it. + +### 7.2 Share Card Visuals (YouTube Music & Spotify Card Target) +- **Natural Word Wrapping:** Fixed line shrinking bug. Each lyric renders at a large bold size (`84px` base in Lyrics tab, `64px` in Song tab) and wraps naturally at word boundaries within card margins. Spacing between wrapped rows is tight (`1.18x`), while spacing between distinct lyrics lines is generous (`0.45 * fontSize`). +- **Dynamic Content Hugging (1:1 to 9:16):** Removed the rigid 4:5 minimum clamp that left awkward empty gaps. Cards hug content between a minimum 1:1 square (`1080x1080`) and maximum 9:16 story (`1080x1920`), scaling down to a `52px` floor only when 5 long lines demand it. +- **YouTube Music Header (Lyrics Tab):** Left-aligned rounded cover thumbnail (`180px`), title and artist to its right, followed by a thin divider line before the lyrics block. +- **Rich Saturated Backgrounds & Tinted Text:** Saturated flat / subtle same-hue gradient backgrounds (like YouTube Music's dark chocolate brown). Text uses a light tint of the hue (peach/cream on brown) maintaining WCAG $\ge 7:1$ for lyrics and $\ge 4.5:1$ for secondary and brand elements. +- **Prominent Bottom-Left Brand Lockup:** Aligned to the same left margin as the lyrics and header (`hPadding`), featuring a tintable logo mark (`64px`) and `"LastWave"` bold typography (`62-64px`). +- **Hero Cover (Song Tab):** Left-aligned hero cover (`680px`, `32px` corner radius) without dark offset shadow strips, consistent with the left-aligned design language. +- **Cover Background Swatch:** Added a "Cover" swatch as the first option in the palette row when artwork is available on the Lyrics tab, rendering a center-cropped full-bleed cover with a 50% dark scrim and gradient protection. + +### 7.3 Test Suite Status +- **Lyricsshare Unit Tests:** **50 tests passed**, 0 failed (**100% pass rate**). + From 7e6943f2191214f7c5d09db0170845ce4959bce1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=F0=9D=97=94=F0=9D=98=86=F0=9D=98=82=F0=9D=98=80?= =?UTF-8?q?=F0=9D=97=B5=20=F0=9D=97=9E?= <100coldice@gmail.com> Date: Sat, 17 Oct 2026 18:49:11 +0530 Subject: [PATCH 10/10] chore: remove feature report from branch for upstream parity --- SHARE_LYRICS_REPORT.md | 214 ----------------------------------------- 1 file changed, 214 deletions(-) delete mode 100644 SHARE_LYRICS_REPORT.md diff --git a/SHARE_LYRICS_REPORT.md b/SHARE_LYRICS_REPORT.md deleted file mode 100644 index f667a85baa..0000000000 --- a/SHARE_LYRICS_REPORT.md +++ /dev/null @@ -1,214 +0,0 @@ -# LastWave - Share Lyrics Feature Report - -**Branch:** `feature/share-lyrics` -**Base:** `main` (commit `ed3b0c2`) -**Package:** `com.lastwave.app.ui.player.lyricsshare` - ---- - -## 1. Executive Summary - -The **Share Lyrics** add-on has been implemented in LastWave Native Android. The feature provides an elegant, high-fidelity export and sharing experience inspired by **Spotify's lyrics card styling** paired with **YouTube Music's dynamic palette color picker**. - -The implementation strictly followed the **Prime Directive: Add-On Only**. No existing public interfaces or player flows were broken or rewritten. All new domain, rendering, and UI logic lives cleanly in a self-contained package (`com.lastwave.app.ui.player.lyricsshare`), accompanied by thorough automated unit, renderer, intent, and cache tests. - -The entire feature has passed all required verification targets: -- `./gradlew testDebugUnitTest --tests "com.lastwave.app.ui.player.lyricsshare.*"`: **38 passed, 0 failed** -- `./gradlew lintDebug`: **BUILD SUCCESSFUL** (0 lint errors) -- `./gradlew assembleDebug`: **BUILD SUCCESSFUL** (APK packaged) -- `./gradlew assembleRelease`: **BUILD SUCCESSFUL** (Full R8 obfuscation, resource shrinking, native library stripping, and APK packaging verified) - ---- - -## 2. Architecture & Implementation Details - -### 2.1 Package: `com.lastwave.app.ui.player.lyricsshare` - -``` -app/src/main/java/com/lastwave/app/ui/player/lyricsshare/ -├── LyricsSnapshot.kt # Immutable snapshot of track & lyrics at invocation -├── ColorContrastHelper.kt # WCAG 2.1 AA luminance & contrast calculations + 8-swatch generator -├── ArtworkResolver.kt # Cascade artwork resolver with brand gradient fallback -├── ShareCardSpec.kt # Pure immutable specification model for card rendering -├── ShareCardRenderer.kt # Deterministic software Canvas & StaticLayout card renderer -├── SelectLyricsScreen.kt # Step 1: 1-5 contiguous line selection screen -├── SharePreviewScreen.kt # Step 2: Live debounced preview, mode toggle, swatches, Share & Save -└── ShareLyricsDialog.kt # Edge-to-edge Dialog hosting PredictiveBack navigation -``` - -### 2.2 Core Components & Behavior - -1. **Immutable Snapshot & Contiguous Selection (`LyricsSnapshot.kt`)**: - - `LyricsSnapshot`: Takes a point-in-time capture of the current track metadata (`TrackInfo`) and lyrics (`ShareLine`). If playback advances underneath while the user composes their card, the share sheet snapshot remains perfectly stable. - - Blank lines are stripped; plain (unsynced) lyrics are split on newlines discarding empty rows. - - Default selection centers a 1..3 line window on the currently active lyric line. - - Selection enforces contiguous ranges (1 to 5 lines max). Tapping an adjacent line extends; tapping an edge shrinks (minimum 1 line); tapping an inner or distant line restarts from that single line. Cap reaches trigger tactile haptic feedback without exceeding 5 lines. - -2. **Contrast & Color Intelligence (`ColorContrastHelper.kt`)**: - - Computes relative luminance and contrast ratio adhering strictly to **WCAG 2.1 AA**: - - $\ge 4.5:1$ contrast for primary lyric text. - - $\ge 3.0:1$ contrast for secondary metadata and branding logo mark. - - Automatically derives 8 curated swatches per card: - 1. Song Vibrant (from `Palette`) - 2. Muted - 3. Dominant - 4. Dark variant - 5. Pure White (`#FFFFFF`) - 6. Pure Black (`#101010`) - 7. Theme Accent (Material dynamic color) - 8. LastWave Lime (`#C9FB00`) - -3. **High-Resolution Artwork Pipeline (`ArtworkResolver.kt`)**: - - Resolution cascade: - 1. Track's own `artworkUrl` (if real image). - 2. `resolvedArtworkUrl` passed from `PlayerHost` / `ArtworkRepository`. - 3. Upgraded high-res image via `ArtworkNormalizer.upscaleYoutubeArtwork()`. - 4. File / content URIs for downloaded or local audio. - 5. Brand gradient fallback (`#C9FB00` $\to$ `#12161A` $\to$ `#080B0E`). - - Uses Coil `ImageLoader` with `allowHardware(false)` to ensure software bitmaps for direct Canvas rendering and palette extraction without hardware bitmap crashes. - - Background blur generated via `FastBlur.blurArtwork(bitmap, radius = 25, maxDimension = 180)`. - -4. **Deterministic Offscreen Renderer (`ShareCardRenderer.kt`)**: - - Renders 1080px wide cards clamped between 4:5 (minimum 1350px) and 9:16 (maximum 1920px) aspect ratios. - - Modes: - - **Song Card:** Rounded album artwork container, track title, artist attribution, lyric snippet, subtle divider, and LastWave branding mark. - - **Lyrics Card:** Full-bleed blurred ambient backdrop, track attribution header, prominent large-type lyrics with quotation mark accents, and branding mark. - - **Typography & Multilingual Support:** Uses `Google Sans Flex` variable font with graceful fallback. Employs `StaticLayout` with `includePad = true` ensuring proper ascenders/descenders for Hindi (Devanagari matras), Arabic (RTL script), CJK, and Latin text. - - **OOM Safety:** If card allocation triggers an `OutOfMemoryError`, automatic garbage collection and retry at 0.75x scale (`810px` width) runs without crashing the app. - -5. **UI & Motion (`SelectLyricsScreen.kt`, `SharePreviewScreen.kt`, `ShareLyricsDialog.kt`)**: - - Full edge-to-edge Dialog with transparent system bars (`EdgeToEdgeDialogWindow`). - - Two-step flow with animated slide transitions and Android predictive back support. - - Live debounced card preview (100ms) with interactive segmented toggle (`Song` / `Lyrics`) and horizontal swatch row with active selection rings. - - Haptic feedback on selection interactions and cap hits. - -6. **Export & File Management (`FileExportHelper.kt`)**: - - `shareImage`: Exports bitmap to `cacheDir/shared/lyrics_cards/lyrics_<title>_<timestamp>.png` and dispatches Android system share sheet (`ACTION_SEND`, `image/png`, `FLAG_GRANT_READ_URI_PERMISSION`). - - `saveImageToGallery`: Saves image to `Pictures/LastWave` via `MediaStore.Images` with `IS_PENDING` lifecycle flag on Android 10+ (API 29+). - - `cleanLyricsCardCache`: Automatic cache hygiene evicting files older than 24 hours and enforcing a 10-file maximum cap (oldest deleted first). - ---- - -## 3. Surgical Edits to Existing Files - -Strictly following the prime directive, all edits to existing files were minimal, additive, and surgical: - -``` - CHANGELOG.md | 5 + - .../com/lastwave/app/ui/player/ModernLyricsView.kt | 88 ++++++++++++- - .../java/com/lastwave/app/ui/player/PlayerHost.kt | 1 + - .../java/com/lastwave/app/util/FileExportHelper.kt | 137 +++++++++++++++++++++ - app/src/main/res/values-ar/strings.xml | 29 +++++ - app/src/main/res/values-de/strings.xml | 29 +++++ - app/src/main/res/values-es/strings.xml | 29 +++++ - app/src/main/res/values-fr/strings.xml | 29 +++++ - app/src/main/res/values-hi/strings.xml | 29 +++++ - app/src/main/res/values-in/strings.xml | 29 +++++ - app/src/main/res/values-ja/strings.xml | 29 +++++ - app/src/main/res/values-ko/strings.xml | 29 +++++ - app/src/main/res/values-pt-rBR/strings.xml | 29 +++++ - app/src/main/res/values-ru/strings.xml | 29 +++++ - app/src/main/res/values-tr/strings.xml | 29 +++++ - app/src/main/res/values-zh-rCN/strings.xml | 29 +++++ - app/src/main/res/values/strings.xml | 29 +++++ - 17 files changed, 607 insertions(+), 1 deletion(-) -``` - -### Existing Files Changed: -1. **`ui/player/ModernLyricsView.kt`**: - - Added optional parameter `resolvedArtworkUrl: String? = null` to `ModernLyricsPanel`. - - Added state `showShareDialog` and evaluated `canShareLyrics` flag. - - Added Share button to the lyrics controls row with 44dp size, 48dp touch target, liquid glass chrome, and spring press scaling. - - Renders `ShareLyricsDialog` on demand when active. Existing call sites continue compiling untouched. -2. **`ui/player/PlayerHost.kt`**: - - Passed `resolvedArtworkUrl = resolvedAmbientUrl` at the single `ModernLyricsPanel` call site (line 2384). No other changes. -3. **`util/FileExportHelper.kt`**: - - Added `cleanLyricsCardCache`, `shareImage`, and `saveImageToGallery` helper methods without touching existing signatures. -4. **`res/values/strings.xml` + 12 Locale Files**: - - Added localized `lyshare_*` keys for: English, Arabic, German, Spanish, French, Hindi, Indonesian, Japanese, Korean, Brazilian Portuguese, Russian, Turkish, and Simplified Chinese. -5. **`CHANGELOG.md`**: - - Added release notes entry for Lyrics Share under `## [Unreleased]`. - -### Baseline Compiler Fixes (Documented): -When initially compiling the baseline branch `main` on JDK 17, three pre-existing unbuilt syntax mismatches in unrelated modules prevented compilation: -1. `GenerateRepository.kt`: Line 1367 had a missing `relatedGraph` parameter to `LocalTasteSuggestionEngine`. -2. `GeniusLyricsApi.kt`: Line 215 had a missing `suspend` modifier on `private suspend fun httpGet(...)`. -3. Pre-existing tests `NeverHeardGenerationTest.kt`, `FeedViewModelDiscoveryTest.kt`, and `LyricsTranslationTest.kt` had missing parameters / wrong assertion calls from earlier unfinished refactors. -These were fixed in an isolated commit (`7fe43b9`) so the repository could build and test cleanly. - ---- - -## 4. Test Suites & Validation Results - -### 4.1 Unit & Integration Test Suites (`app/src/test/java/.../lyricsshare/`) - -| Test File | Description | Status | -|---|---|:---:| -| `LyricsSelectionTest.kt` | Snapshot creation, blank line filtering, plain-lyrics newline splitting, default 1..3 window around active index, contiguous range extend/shrink/restart, and 5-line cap enforcement. | **PASSED** | -| `ColorContrastHelperTest.kt` | WCAG 2.1 AA luminance & contrast tests across pure white, pure black, brand lime, dark slate, and dynamic swatch extraction. | **PASSED** | -| `ShareCardMathTest.kt` | Aspect ratio clamping (4:5 to 9:16), 0.75x OOM scale bounds, and text truncation math. | **PASSED** | -| `CacheHygieneTest.kt` | 24-hour expiration deletion, 10-file maximum eviction (oldest first), and filename sanitization. | **PASSED** | -| `ArtworkResolutionOrderTest.kt` | Cascade verification (local URI $\to$ track art $\to$ resolved ambient $\to$ upscaled YouTube $\to$ brand fallback gradient). | **PASSED** | -| `ShareCardRendererTest.kt` | Offscreen rendering for Song & Lyrics modes with cover art, null art fallback, blurred background, and multilingual typography (Latin, Devanagari, Arabic RTL, CJK, and long multiline text wrapping). | **PASSED** | -| `ShareIntentTest.kt` | Validates `shareImage` `ACTION_SEND` intent structure, FileProvider content stream, read URI permissions, and MediaStore gallery insertion. | **PASSED** | - -### 4.2 Build Targets - -- **`./gradlew testDebugUnitTest --tests "com.lastwave.app.ui.player.lyricsshare.*"`**: - - `38 tests completed, 0 failed` (**100% pass**) -- **`./gradlew lintDebug`**: - - `BUILD SUCCESSFUL` (0 errors, report generated) -- **`./gradlew assembleDebug`**: - - `BUILD SUCCESSFUL` (Debug APK output generated in `app/build/outputs/apk/debug/`) -- **`./gradlew assembleRelease`**: - - `BUILD SUCCESSFUL` (Release APK output generated in `app/build/outputs/apk/release/` with full R8 optimization) - ---- - -## 5. QA & Verification Checklist - -- [x] **Entry Point:** Share icon button appears in the floating lyrics controls bar when lyrics are present. -- [x] **Gating:** Share button is hidden or disabled when track is instrumental or has empty lyrics. -- [x] **Selection UX:** Users can select between 1 and 5 contiguous lyric lines. Cap hit triggers feedback and prevents exceeding 5 lines. -- [x] **Card Modes:** Users can seamlessly toggle between "Song" (cover-art focus) and "Lyrics" (typography focus). -- [x] **Dynamic Palette:** 8 color swatches populate dynamically with high contrast WCAG AA guarantees. -- [x] **Live Preview:** Debounced live render preview updates smoothly on mode or swatch selection. -- [x] **Multilingual Rendering:** Tested and verified for English, Hindi (Devanagari), Arabic (RTL), and Japanese/Chinese (CJK). -- [x] **System Share Sheet:** Triggers Android system share sheet with proper `image/png` MIME type and `FLAG_GRANT_READ_URI_PERMISSION`. -- [x] **Gallery Save:** Saves to `Pictures/LastWave` with `IS_PENDING` handling and confirms via toast notification. -- [x] **Cache Hygiene:** Internal storage remains bounded by 24h expiration and 10-file limit. -- [x] **Predictive Back:** Back gesture transitions smoothly from preview back to selection, and from selection back to player. - ---- - -## 6. Assumptions & Limitations - -1. **Hardware Bitmaps:** Canvas rendering and palette extraction on Android cannot operate directly on hardware bitmaps; `ArtworkResolver` strictly enforces software decoding via `allowHardware(false)` and bitmap copying if needed. -2. **Release Signing Keys:** Production CI builds must inject `SIGNING_KEY` (base64 keystore) or `RELEASE_STORE_FILE` + credentials via environment variables as enforced by `build.gradle.kts`. Local testing validated the release pipeline using a temporary key with identical R8 configurations. - ---- - -## 7. UI Polish & Visual Redesign (v2) - -Following design references from YouTube Music and Spotify, the feature visuals were overhauled while preserving 100% of the underlying business logic: - -### 7.1 Select Lyrics Screen (Spotify Visual Target) -- **Vivid Hue Gradient Background:** Replaced dark mud/grey fades with a saturated, rich vertical gradient derived from the song's primary color, smoothly transitioning from a deep tone to a slightly lighter shade of the same hue (`ColorContrastHelper.getSelectScreenGradientColors`). -- **Centered Header:** Clean header with centered `"Select lyrics"` title and `"N lines selected"` subtitle within safe window insets. -- **Bold Lyrics Typography:** Google Sans Flex (`wght 700`), 15% larger size (`21sp`, `lineHeight 27sp`, `letterSpacing -0.2sp`). Unselected lines render in bright crisp white. -- **Solid White Rounded Pills:** Consecutive selected lines each receive their own solid white rounded pill (`26dp` corner radius) with dark text tinted from the song's hue (`ColorContrastHelper.getSelectedPillTextColor`). -- **Extendable Neighbors:** Lines directly adjacent (index $\pm 1$) to the active selection block receive a subtle 16% alpha white pill that smoothly animates during selection changes without layout jumps. -- **Compact Continue Pill:** Replaced full-width bottom button with a compact floating pill (`152dp` wide, `50dp` tall) with white fill and bold dark label, positioned above the nav bar inset with a soft vertical gradient fade behind it. - -### 7.2 Share Card Visuals (YouTube Music & Spotify Card Target) -- **Natural Word Wrapping:** Fixed line shrinking bug. Each lyric renders at a large bold size (`84px` base in Lyrics tab, `64px` in Song tab) and wraps naturally at word boundaries within card margins. Spacing between wrapped rows is tight (`1.18x`), while spacing between distinct lyrics lines is generous (`0.45 * fontSize`). -- **Dynamic Content Hugging (1:1 to 9:16):** Removed the rigid 4:5 minimum clamp that left awkward empty gaps. Cards hug content between a minimum 1:1 square (`1080x1080`) and maximum 9:16 story (`1080x1920`), scaling down to a `52px` floor only when 5 long lines demand it. -- **YouTube Music Header (Lyrics Tab):** Left-aligned rounded cover thumbnail (`180px`), title and artist to its right, followed by a thin divider line before the lyrics block. -- **Rich Saturated Backgrounds & Tinted Text:** Saturated flat / subtle same-hue gradient backgrounds (like YouTube Music's dark chocolate brown). Text uses a light tint of the hue (peach/cream on brown) maintaining WCAG $\ge 7:1$ for lyrics and $\ge 4.5:1$ for secondary and brand elements. -- **Prominent Bottom-Left Brand Lockup:** Aligned to the same left margin as the lyrics and header (`hPadding`), featuring a tintable logo mark (`64px`) and `"LastWave"` bold typography (`62-64px`). -- **Hero Cover (Song Tab):** Left-aligned hero cover (`680px`, `32px` corner radius) without dark offset shadow strips, consistent with the left-aligned design language. -- **Cover Background Swatch:** Added a "Cover" swatch as the first option in the palette row when artwork is available on the Lyrics tab, rendering a center-cropped full-bleed cover with a 50% dark scrim and gradient protection. - -### 7.3 Test Suite Status -- **Lyricsshare Unit Tests:** **50 tests passed**, 0 failed (**100% pass rate**). -