v2.0.5: Large playlist support + duration verification fix

- Add pagination for playlists (up to 1000 tracks)
- Add duration verification to prevent wrong track downloads
- When Tidal returns wrong version, fallback to Qobuz/Amazon

.github/workflows/release.yml

@@ -45,6 +45,20 @@ jobs:
     needs: get-version
     
     steps:
+      - name: Free disk space
+        run: |
+          # Remove large unused tools (~15GB total)
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /opt/hostedtoolcache/CodeQL
+          sudo rm -rf /usr/local/share/boost
+          sudo rm -rf /usr/share/swift
+          sudo rm -rf /usr/local/.ghcup
+          # Clean docker images
+          sudo docker image prune --all --force
+          # Show available space
+          df -h
+
       - name: Checkout repository
         uses: actions/checkout@v4
 

CHANGELOG.md

@@ -1,5 +1,63 @@
 # Changelog
 
+## [2.0.5] - 2026-01-05
+
+### Added
+- **Large Playlist Support**: Playlists with up to 1000 tracks are now fully fetched (was limited to 100)
+
+### Fixed
+- **Wrong Track Download**: Fixed issue where tracks with same ISRC but different versions (e.g., short/instrumental vs full version) would download the wrong track. Now verifies duration matches before downloading (30 second tolerance).
+
+## [2.0.4] - 2026-01-04
+
+### Fixed
+- **Android 11 Storage Permission**: Fixed "Permission denied" error on Android 11 (API 30) devices
+  - Added `MANAGE_EXTERNAL_STORAGE` permission for Android 11-12
+  - Shows explanation dialog before opening system settings
+
+## [2.0.3] - 2026-01-03
+
+### Added
+- **Custom Spotify API Credentials**: Set your own Spotify Client ID and Secret in Settings > Options to avoid rate limiting
+  - Toggle to enable/disable custom credentials without deleting them
+  - Material Expressive 3 bottom sheet UI for entering credentials
+- **Keyboard Dismiss on Scroll**: Keyboard now automatically dismisses when scrolling search results
+- **Rate Limit Error UI**: Shows friendly error card when API rate limit (429) is hit on Home, Artist, and Album screens
+
+### Changed
+- **Search on Enter Only**: Removed auto-search debounce, now only searches when pressing Enter key (saves API calls)
+
+### Fixed
+- **Download Cancel**: Fixed cancelled downloads still completing in background and appearing in history. Cancelled files are now properly deleted.
+- **Search Keyboard Dismiss**: Fixed keyboard randomly dismissing and navigating back when starting to search
+- **Back Button During Search**: Back button now properly dismisses keyboard first before clearing search
+- **Search Error Navigation**: Fixed pressing Enter during search (when loading or error) navigating back to home instead of staying on search screen
+- **Duplicate Search on Enter**: Enter key no longer triggers duplicate search if results already loaded
+
+## [2.0.2] - 2026-01-03
+
+### Added
+- **Actual Quality Display**: Shows real audio quality (bit depth/sample rate) after download
+  - Quality badge on download history items (e.g., "24-bit", "16-bit")
+  - Full quality info in Track Metadata screen (e.g., "24-bit/96kHz")
+  - Tertiary color highlight for Hi-Res (24-bit) downloads
+- **Quality Disclaimer**: Added note in quality picker explaining that actual quality depends on track availability
+- **Instant Lyrics Loading**: Lyrics now load from embedded file first (instant) before falling back to internet fetch
+
+### Fixed
+- **Fallback Service Display**: Fixed download history showing wrong service when fallback occurs (e.g., showing "TIDAL" when actually downloaded from "QOBUZ")
+- **Open in Spotify**: Fixed "Open in Spotify" button not opening Spotify app correctly
+
+### Removed
+- **Romaji Conversion**: Removed Japanese lyrics to romaji conversion feature (Kanji not supported, results were incomplete)
+
+### Technical
+- Go backend now returns `actual_bit_depth` and `actual_sample_rate` in download response
+- Go backend now returns `service` field indicating actual service used (important for fallback)
+- Tidal API v2 response provides exact quality info
+- Qobuz uses track metadata for quality info
+- Amazon now reads quality from downloaded FLAC file (previously returned unknown)
+
 ## [2.0.1] - 2026-01-03
 
 ### Added
@@ -9,12 +67,6 @@
   - Ripple effect follows rounded corners including drag handle
 
 ### Changed
-- **Update Dialog Redesign**: Material Expressive 3 style
-  - Icon header with container
-  - Version chips with "Current" and "New" labels
-  - Changelog in rounded card
-  - Download progress with percentage indicator
-  - Cleaner button layout
 - **Unified Progress Tracking System**: Deprecated legacy single-download progress
   - All downloads now use item-based progress tracking
   - Fixes duplicate notification bug when finalizing
@@ -23,6 +75,9 @@
 ### Fixed
 - **Duplicate Notification Bug**: Fixed issue where "Finalizing" and "Downloading" notifications appeared simultaneously
 - **Update Notification Stuck**: Fixed notification staying at 100% after download completes
+- **Quality Picker Consistency**: Unified quality picker UI across all screens (Home, Album, Playlist)
+  - Container with `primaryContainer` background for each option
+  - Distinct icons: music_note (Lossless), high_quality (Hi-Res), four_k (Max)
 
 ## [2.0.0] - 2026-01-03
 

README.md

@@ -18,10 +18,10 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
 ## Screenshots
 
 <p align="center">
-  <img src="assets/images/1.jpg" width="200" />
+  <img src="assets/images/1.jpg?v=2" width="200" />
-  <img src="assets/images/2.jpg" width="200" />
+  <img src="assets/images/2.jpg?v=2" width="200" />
-  <img src="assets/images/3.jpg" width="200" />
+  <img src="assets/images/3.jpg?v=2" width="200" />
-  <img src="assets/images/4.jpg" width="200" />
+  <img src="assets/images/4.jpg?v=2" width="200" />
 </p>
 
 ## Other project

android/app/src/main/AndroidManifest.xml

@@ -4,9 +4,11 @@
     <!-- Permissions -->
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" 
-        android:maxSdkVersion="28" />
+        android:maxSdkVersion="29" />
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" 
         android:maxSdkVersion="32" />
+    <!-- For Android 11+ (API 30-32) - full storage access -->
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />

android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt

@@ -157,8 +157,9 @@ class MainActivity: FlutterActivity() {
                             val spotifyId = call.argument<String>("spotify_id") ?: ""
                             val trackName = call.argument<String>("track_name") ?: ""
                             val artistName = call.argument<String>("artist_name") ?: ""
+                            val filePath = call.argument<String>("file_path") ?: ""
                             val response = withContext(Dispatchers.IO) {
-                                Gobackend.getLyricsLRC(spotifyId, trackName, artistName)
+                                Gobackend.getLyricsLRC(spotifyId, trackName, artistName, filePath)
                             }
                             result.success(response)
                         }
@@ -199,6 +200,14 @@ class MainActivity: FlutterActivity() {
                         "isDownloadServiceRunning" -> {
                             result.success(DownloadService.isServiceRunning())
                         }
+                        "setSpotifyCredentials" -> {
+                            val clientId = call.argument<String>("client_id") ?: ""
+                            val clientSecret = call.argument<String>("client_secret") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setSpotifyAPICredentials(clientId, clientSecret)
+                            }
+                            result.success(null)
+                        }
                         else -> result.notImplemented()
                     }
                 } catch (e: Exception) {

go_backend/amazon.go

@@ -254,38 +254,45 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 	return nil
 }
 
+// AmazonDownloadResult contains download result with quality info
+type AmazonDownloadResult struct {
+	FilePath   string
+	BitDepth   int
+	SampleRate int
+}
+
 // downloadFromAmazon downloads a track using the request parameters
 // Uses DoubleDouble service (same as PC version)
-func downloadFromAmazon(req DownloadRequest) (string, error) {
+func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	downloader := NewAmazonDownloader()
 
 	// Check for existing file first
 	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return "EXISTS:" + existingFile, nil
+		return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 
 	// Get Amazon URL from SongLink
 	songlink := NewSongLinkClient()
 	availability, err := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
 	if err != nil {
-		return "", fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
+		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
 	}
 
 	if !availability.Amazon || availability.AmazonURL == "" {
-		return "", fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
+		return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
 	}
 
 	// Create output directory if needed
 	if req.OutputDir != "." {
 		if err := os.MkdirAll(req.OutputDir, 0755); err != nil {
-			return "", fmt.Errorf("failed to create output directory: %w", err)
+			return AmazonDownloadResult{}, fmt.Errorf("failed to create output directory: %w", err)
 		}
 	}
 
 	// Download using DoubleDouble service (same as PC)
 	downloadURL, trackName, artistName, err := downloader.downloadFromDoubleDoubleService(availability.AmazonURL, req.OutputDir)
 	if err != nil {
-		return "", fmt.Errorf("failed to get download URL: %w", err)
+		return AmazonDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
 	// Build filename using Spotify metadata (more accurate)
@@ -302,12 +309,12 @@ func downloadFromAmazon(req DownloadRequest) (string, error) {
 
 	// Check if file already exists
 	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return "EXISTS:" + outputPath, nil
+		return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
 
 	// Download file with item ID for progress tracking
 	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
-		return "", fmt.Errorf("download failed: %w", err)
+		return AmazonDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
 	// Set progress to 100% and status to finalizing (before embedding)
@@ -363,17 +370,6 @@ func downloadFromAmazon(req DownloadRequest) (string, error) {
 			fmt.Println("[Amazon] No lyrics found for this track")
 		} else {
 			fmt.Printf("[Amazon] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-			
-			// Convert Japanese lyrics to romaji if enabled
-			if req.ConvertLyricsToRomaji {
-				for i := range lyrics.Lines {
-					if ContainsKana(lyrics.Lines[i].Words) {
-						lyrics.Lines[i].Words = ToRomaji(lyrics.Lines[i].Words)
-					}
-				}
-				fmt.Println("[Amazon] Converted Japanese lyrics to romaji")
-			}
-			
 			lrcContent := convertToLRC(lyrics)
 			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
 				fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
@@ -384,5 +380,24 @@ func downloadFromAmazon(req DownloadRequest) (string, error) {
 	}
 
 	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
-	return outputPath, nil
+	
+	// Read actual quality from the downloaded FLAC file
+	// Amazon API doesn't provide quality info, but we can read it from the file itself
+	quality, err := GetAudioQuality(outputPath)
+	if err != nil {
+		fmt.Printf("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+		// Return 0 to indicate unknown quality
+		return AmazonDownloadResult{
+			FilePath:   outputPath,
+			BitDepth:   0,
+			SampleRate: 0,
+		}, nil
+	}
+	
+	fmt.Printf("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+	return AmazonDownloadResult{
+		FilePath:   outputPath,
+		BitDepth:   quality.BitDepth,
+		SampleRate: quality.SampleRate,
+	}, nil
 }

go_backend/exports.go

@@ -30,6 +30,12 @@ func ParseSpotifyURL(url string) (string, error) {
 	return string(jsonBytes), nil
 }
 
+// SetSpotifyAPICredentials sets custom Spotify API credentials from Flutter
+// Pass empty strings to use default credentials
+func SetSpotifyAPICredentials(clientID, clientSecret string) {
+	SetSpotifyCredentials(clientID, clientSecret)
+}
+
 // GetSpotifyMetadata fetches metadata from Spotify URL
 // Returns JSON with track/album/playlist data
 func GetSpotifyMetadata(spotifyURL string) (string, error) {
@@ -122,12 +128,12 @@ type DownloadRequest struct {
 	Quality              string `json:"quality"` // LOSSLESS, HI_RES, HI_RES_LOSSLESS
 	EmbedLyrics          bool   `json:"embed_lyrics"`
 	EmbedMaxQualityCover bool   `json:"embed_max_quality_cover"`
-	ConvertLyricsToRomaji bool  `json:"convert_lyrics_to_romaji"`
 	TrackNumber          int    `json:"track_number"`
 	DiscNumber           int    `json:"disc_number"`
 	TotalTracks          int    `json:"total_tracks"`
 	ReleaseDate          string `json:"release_date"`
-	ItemID               string `json:"item_id"` // Unique ID for progress tracking
+	ItemID               string `json:"item_id"`    // Unique ID for progress tracking
+	DurationMS           int    `json:"duration_ms"` // Expected duration in milliseconds (for verification)
 }
 
 // DownloadResponse represents the result of a download
@@ -137,6 +143,17 @@ type DownloadResponse struct {
 	FilePath      string `json:"file_path,omitempty"`
 	Error         string `json:"error,omitempty"`
 	AlreadyExists bool   `json:"already_exists,omitempty"`
+	// Actual quality info from the source
+	ActualBitDepth   int    `json:"actual_bit_depth,omitempty"`
+	ActualSampleRate int    `json:"actual_sample_rate,omitempty"`
+	Service          string `json:"service,omitempty"` // Actual service used (for fallback)
+}
+
+// DownloadResult is a generic result type for all downloaders
+type DownloadResult struct {
+	FilePath   string
+	BitDepth   int
+	SampleRate int
 }
 
 // DownloadTrack downloads a track from the specified service
@@ -155,16 +172,40 @@ func DownloadTrack(requestJSON string) (string, error) {
 	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
 	
-	var filePath string
+	var result DownloadResult
 	var err error
 	
 	switch req.Service {
 	case "tidal":
-		filePath, err = downloadFromTidal(req)
+		tidalResult, tidalErr := downloadFromTidal(req)
+		if tidalErr == nil {
+			result = DownloadResult{
+				FilePath:   tidalResult.FilePath,
+				BitDepth:   tidalResult.BitDepth,
+				SampleRate: tidalResult.SampleRate,
+			}
+		}
+		err = tidalErr
 	case "qobuz":
-		filePath, err = downloadFromQobuz(req)
+		qobuzResult, qobuzErr := downloadFromQobuz(req)
+		if qobuzErr == nil {
+			result = DownloadResult{
+				FilePath:   qobuzResult.FilePath,
+				BitDepth:   qobuzResult.BitDepth,
+				SampleRate: qobuzResult.SampleRate,
+			}
+		}
+		err = qobuzErr
 	case "amazon":
-		filePath, err = downloadFromAmazon(req)
+		amazonResult, amazonErr := downloadFromAmazon(req)
+		if amazonErr == nil {
+			result = DownloadResult{
+				FilePath:   amazonResult.FilePath,
+				BitDepth:   amazonResult.BitDepth,
+				SampleRate: amazonResult.SampleRate,
+			}
+		}
+		err = amazonErr
 	default:
 		return errorResponse("Unknown service: " + req.Service)
 	}
@@ -174,21 +215,25 @@ func DownloadTrack(requestJSON string) (string, error) {
 	}
 	
 	// Check if file already exists
-	if len(filePath) > 7 && filePath[:7] == "EXISTS:" {
+	if len(result.FilePath) > 7 && result.FilePath[:7] == "EXISTS:" {
 		resp := DownloadResponse{
 			Success:       true,
 			Message:       "File already exists",
-			FilePath:      filePath[7:],
+			FilePath:      result.FilePath[7:],
 			AlreadyExists: true,
+			Service:       req.Service,
 		}
 		jsonBytes, _ := json.Marshal(resp)
 		return string(jsonBytes), nil
 	}
 	
 	resp := DownloadResponse{
-		Success:  true,
+		Success:          true,
-		Message:  "Download complete",
+		Message:          "Download complete",
-		FilePath: filePath,
+		FilePath:         result.FilePath,
+		ActualBitDepth:   result.BitDepth,
+		ActualSampleRate: result.SampleRate,
+		Service:          req.Service,
 	}
 	
 	jsonBytes, _ := json.Marshal(resp)
@@ -230,35 +275,63 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 	for _, service := range services {
 		req.Service = service
 		
-		var filePath string
+		var result DownloadResult
 		var err error
 		
 		switch service {
 		case "tidal":
-			filePath, err = downloadFromTidal(req)
+			tidalResult, tidalErr := downloadFromTidal(req)
+			if tidalErr == nil {
+				result = DownloadResult{
+					FilePath:   tidalResult.FilePath,
+					BitDepth:   tidalResult.BitDepth,
+					SampleRate: tidalResult.SampleRate,
+				}
+			}
+			err = tidalErr
 		case "qobuz":
-			filePath, err = downloadFromQobuz(req)
+			qobuzResult, qobuzErr := downloadFromQobuz(req)
+			if qobuzErr == nil {
+				result = DownloadResult{
+					FilePath:   qobuzResult.FilePath,
+					BitDepth:   qobuzResult.BitDepth,
+					SampleRate: qobuzResult.SampleRate,
+				}
+			}
+			err = qobuzErr
 		case "amazon":
-			filePath, err = downloadFromAmazon(req)
+			amazonResult, amazonErr := downloadFromAmazon(req)
+			if amazonErr == nil {
+				result = DownloadResult{
+					FilePath:   amazonResult.FilePath,
+					BitDepth:   amazonResult.BitDepth,
+					SampleRate: amazonResult.SampleRate,
+				}
+			}
+			err = amazonErr
 		}
 		
 		if err == nil {
 			// Check if file already exists
-			if len(filePath) > 7 && filePath[:7] == "EXISTS:" {
+			if len(result.FilePath) > 7 && result.FilePath[:7] == "EXISTS:" {
 				resp := DownloadResponse{
 					Success:       true,
 					Message:       "File already exists",
-					FilePath:      filePath[7:],
+					FilePath:      result.FilePath[7:],
 					AlreadyExists: true,
+					Service:       service,
 				}
 				jsonBytes, _ := json.Marshal(resp)
 				return string(jsonBytes), nil
 			}
 			
 			resp := DownloadResponse{
-				Success:  true,
+				Success:          true,
-				Message:  "Downloaded from " + service,
+				Message:          "Downloaded from " + service,
-				FilePath: filePath,
+				FilePath:         result.FilePath,
+				ActualBitDepth:   result.BitDepth,
+				ActualSampleRate: result.SampleRate,
+				Service:          service,
 			}
 			jsonBytes, _ := json.Marshal(resp)
 			return string(jsonBytes), nil
@@ -367,14 +440,24 @@ func FetchLyrics(spotifyID, trackName, artistName string) (string, error) {
 }
 
 // GetLyricsLRC fetches lyrics and converts to LRC format string
-func GetLyricsLRC(spotifyID, trackName, artistName string) (string, error) {
+// First tries to extract from file, then falls back to fetching from internet
+func GetLyricsLRC(spotifyID, trackName, artistName string, filePath string) (string, error) {
+	// Try to extract from file first (much faster)
+	if filePath != "" {
+		lyrics, err := ExtractLyrics(filePath)
+		if err == nil && lyrics != "" {
+			return lyrics, nil
+		}
+	}
+
+	// Fallback to fetching from internet
 	client := NewLyricsClient()
-	lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
+	lyricsData, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
 	if err != nil {
 		return "", err
 	}
 
-	lrcContent := convertToLRC(lyrics)
+	lrcContent := convertToLRC(lyricsData)
 	return lrcContent, nil
 }
 
@@ -394,12 +477,6 @@ func EmbedLyricsToFile(filePath, lyrics string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ConvertToRomaji converts Japanese kana (Hiragana/Katakana) to romaji
-// Kanji characters are preserved as-is
-func ConvertToRomaji(text string) string {
-	return ToRomaji(text)
-}
-
 func errorResponse(msg string) (string, error) {
 	resp := DownloadResponse{
 		Success: false,

go_backend/metadata.go

@@ -335,3 +335,92 @@ func EmbedLyrics(filePath string, lyrics string) error {
 
 	return f.Save(filePath)
 }
+
+// ExtractLyrics extracts embedded lyrics from a FLAC file
+func ExtractLyrics(filePath string) (string, error) {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	for _, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmt, err := flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				continue
+			}
+			
+			// Try LYRICS tag first
+			lyrics, err := cmt.Get("LYRICS")
+			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
+				return lyrics[0], nil
+			}
+			
+			// Fallback to UNSYNCEDLYRICS
+			lyrics, err = cmt.Get("UNSYNCEDLYRICS")
+			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
+				return lyrics[0], nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("no lyrics found in file")
+}
+
+// AudioQuality represents audio quality info from a FLAC file
+type AudioQuality struct {
+	BitDepth   int `json:"bit_depth"`
+	SampleRate int `json:"sample_rate"`
+}
+
+// GetAudioQuality reads bit depth and sample rate from a FLAC file's StreamInfo block
+// FLAC StreamInfo is always the first metadata block after the 4-byte "fLaC" marker
+func GetAudioQuality(filePath string) (AudioQuality, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	// Read FLAC marker (4 bytes: "fLaC")
+	marker := make([]byte, 4)
+	if _, err := file.Read(marker); err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read marker: %w", err)
+	}
+	if string(marker) != "fLaC" {
+		return AudioQuality{}, fmt.Errorf("not a FLAC file")
+	}
+
+	// Read metadata block header (4 bytes)
+	// Byte 0: bit 7 = last block flag, bits 0-6 = block type (0 = STREAMINFO)
+	// Bytes 1-3: block length (24-bit big-endian)
+	header := make([]byte, 4)
+	if _, err := file.Read(header); err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
+	}
+
+	blockType := header[0] & 0x7F
+	if blockType != 0 {
+		return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
+	}
+
+	// Read STREAMINFO block (34 bytes minimum)
+	// Bytes 10-13 contain sample rate (20 bits), channels (3 bits), bits per sample (5 bits)
+	streamInfo := make([]byte, 34)
+	if _, err := file.Read(streamInfo); err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
+	}
+
+	// Parse sample rate (20 bits starting at byte 10)
+	// Bytes 10-12: [SSSS SSSS] [SSSS SSSS] [SSSS CCCC] where S=sample rate, C=channels
+	sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
+
+	// Parse bits per sample (5 bits)
+	// Byte 12 bits 0-3 and byte 13 bit 7: [.... BBBB] [B...] where B=bits per sample - 1
+	bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
+
+	return AudioQuality{
+		BitDepth:   bitsPerSample,
+		SampleRate: sampleRate,
+	}, nil
+}

go_backend/qobuz.go

@@ -112,8 +112,96 @@ func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }
 
+// SearchTrackByISRCWithTitle searches for a track by ISRC with duration verification
+// expectedDurationSec is the expected duration in seconds (0 to skip verification)
+func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDurationSec int) (*QobuzTrack, error) {
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
+	searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(isrc), q.appID)
+
+	req, err := http.NewRequest("GET", searchURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := DoRequestWithUserAgent(q.client, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("search failed: HTTP %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Tracks struct {
+			Items []QobuzTrack `json:"items"`
+		} `json:"tracks"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Find ISRC matches
+	var isrcMatches []*QobuzTrack
+	for i := range result.Tracks.Items {
+		if result.Tracks.Items[i].ISRC == isrc {
+			isrcMatches = append(isrcMatches, &result.Tracks.Items[i])
+		}
+	}
+
+	if len(isrcMatches) > 0 {
+		// Verify duration if provided
+		if expectedDurationSec > 0 {
+			var durationVerifiedMatches []*QobuzTrack
+			for _, track := range isrcMatches {
+				durationDiff := track.Duration - expectedDurationSec
+				if durationDiff < 0 {
+					durationDiff = -durationDiff
+				}
+				// Allow 30 seconds tolerance
+				if durationDiff <= 30 {
+					durationVerifiedMatches = append(durationVerifiedMatches, track)
+				}
+			}
+			
+			if len(durationVerifiedMatches) > 0 {
+				fmt.Printf("[Qobuz] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n", 
+					durationVerifiedMatches[0].Title, expectedDurationSec, durationVerifiedMatches[0].Duration)
+				return durationVerifiedMatches[0], nil
+			}
+			
+			// ISRC matches but duration doesn't
+			fmt.Printf("[Qobuz] WARNING: ISRC %s found but duration mismatch. Expected=%ds, Found=%ds. Rejecting.\n", 
+				isrc, expectedDurationSec, isrcMatches[0].Duration)
+			return nil, fmt.Errorf("ISRC found but duration mismatch: expected %ds, found %ds (likely different version)", 
+				expectedDurationSec, isrcMatches[0].Duration)
+		}
+		
+		// No duration to verify, return first match
+		fmt.Printf("[Qobuz] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
+		return isrcMatches[0], nil
+	}
+
+	if len(result.Tracks.Items) == 0 {
+		return nil, fmt.Errorf("no tracks found for ISRC: %s", isrc)
+	}
+
+	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
+}
+
+// SearchTrackByISRCWithTitle is deprecated, use SearchTrackByISRCWithDuration instead
+func (q *QobuzDownloader) SearchTrackByISRCWithTitle(isrc, expectedTitle string) (*QobuzTrack, error) {
+	return q.SearchTrackByISRCWithDuration(isrc, 0)
+}
+
 // SearchTrackByMetadata searches for a track using artist name and track name
 func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*QobuzTrack, error) {
+	return q.SearchTrackByMetadataWithDuration(trackName, artistName, 0)
+}
+
+// SearchTrackByMetadataWithDuration searches for a track with duration verification
+func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistName string, expectedDurationSec int) (*QobuzTrack, error) {
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
 
 	// Try multiple search strategies
@@ -129,6 +217,8 @@ func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 		queries = append(queries, trackName)
 	}
 
+	var allTracks []QobuzTrack
+
 	for _, query := range queries {
 		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(query), q.appID)
 
@@ -159,19 +249,50 @@ func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 		resp.Body.Close()
 
 		if len(result.Tracks.Items) > 0 {
-			// Return first result with best quality
+			allTracks = append(allTracks, result.Tracks.Items...)
-			for i := range result.Tracks.Items {
+		}
-				track := &result.Tracks.Items[i]
+	}
+
+	if len(allTracks) == 0 {
+		return nil, fmt.Errorf("no tracks found for: %s - %s", artistName, trackName)
+	}
+
+	// If duration verification is requested
+	if expectedDurationSec > 0 {
+		var durationMatches []*QobuzTrack
+		for i := range allTracks {
+			track := &allTracks[i]
+			durationDiff := track.Duration - expectedDurationSec
+			if durationDiff < 0 {
+				durationDiff = -durationDiff
+			}
+			if durationDiff <= 30 {
+				durationMatches = append(durationMatches, track)
+			}
+		}
+
+		if len(durationMatches) > 0 {
+			// Return best quality among duration matches
+			for _, track := range durationMatches {
 				if track.MaximumBitDepth >= 24 {
 					return track, nil
 				}
 			}
-			// Return first result if no hi-res found
+			return durationMatches[0], nil
-			return &result.Tracks.Items[0], nil
 		}
+
+		// No duration match found
+		return nil, fmt.Errorf("no tracks found with matching duration (expected %ds)", expectedDurationSec)
 	}
 
-	return nil, fmt.Errorf("no tracks found for: %s - %s", artistName, trackName)
+	// No duration verification, return best quality
+	for i := range allTracks {
+		track := &allTracks[i]
+		if track.MaximumBitDepth >= 24 {
+			return track, nil
+		}
+	}
+	return &allTracks[0], nil
 }
 
 // getQobuzDownloadURLSequential requests download URL from APIs sequentially
@@ -305,26 +426,36 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	return err
 }
 
+// QobuzDownloadResult contains download result with quality info
+type QobuzDownloadResult struct {
+	FilePath   string
+	BitDepth   int
+	SampleRate int
+}
+
 // downloadFromQobuz downloads a track using the request parameters
-func downloadFromQobuz(req DownloadRequest) (string, error) {
+func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	downloader := NewQobuzDownloader()
 
 	// Check for existing file first
 	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return "EXISTS:" + existingFile, nil
+		return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 
+	// Convert expected duration from ms to seconds
+	expectedDurationSec := req.DurationMS / 1000
+
 	var track *QobuzTrack
 	var err error
 
-	// Strategy 1: Search by ISRC
+	// Strategy 1: Search by ISRC with duration verification
 	if req.ISRC != "" {
-		track, err = downloader.SearchTrackByISRC(req.ISRC)
+		track, err = downloader.SearchTrackByISRCWithDuration(req.ISRC, expectedDurationSec)
 	}
 
-	// Strategy 2: Search by metadata
+	// Strategy 2: Search by metadata with duration verification
 	if track == nil {
-		track, err = downloader.SearchTrackByMetadata(req.TrackName, req.ArtistName)
+		track, err = downloader.SearchTrackByMetadataWithDuration(req.TrackName, req.ArtistName, expectedDurationSec)
 	}
 
 	if track == nil {
@@ -332,7 +463,21 @@ func downloadFromQobuz(req DownloadRequest) (string, error) {
 		if err != nil {
 			errMsg = err.Error()
 		}
-		return "", fmt.Errorf("qobuz search failed: %s", errMsg)
+		return QobuzDownloadResult{}, fmt.Errorf("qobuz search failed: %s", errMsg)
+	}
+
+	// Final duration verification
+	if expectedDurationSec > 0 {
+		durationDiff := track.Duration - expectedDurationSec
+		if durationDiff < 0 {
+			durationDiff = -durationDiff
+		}
+		if durationDiff > 30 {
+			return QobuzDownloadResult{}, fmt.Errorf("duration mismatch: expected %ds, found %ds (diff: %ds). Track may be wrong version", 
+				expectedDurationSec, track.Duration, durationDiff)
+		}
+		fmt.Printf("[Qobuz] Duration verified: expected %ds, found %ds (diff: %ds)\n", 
+			expectedDurationSec, track.Duration, durationDiff)
 	}
 
 	// Build filename
@@ -349,7 +494,7 @@ func downloadFromQobuz(req DownloadRequest) (string, error) {
 
 	// Check if file already exists
 	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return "EXISTS:" + outputPath, nil
+		return QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
 
 	// Map quality from Tidal format to Qobuz format
@@ -366,15 +511,20 @@ func downloadFromQobuz(req DownloadRequest) (string, error) {
 	}
 	fmt.Printf("[Qobuz] Using quality: %s (mapped from %s)\n", qobuzQuality, req.Quality)
 
+	// Get actual quality from track metadata
+	actualBitDepth := track.MaximumBitDepth
+	actualSampleRate := int(track.MaximumSamplingRate * 1000) // Convert kHz to Hz
+	fmt.Printf("[Qobuz] Actual quality: %d-bit/%.1fkHz\n", actualBitDepth, track.MaximumSamplingRate)
+
 	// Get download URL using parallel API requests
 	downloadURL, err := downloader.GetDownloadURL(track.ID, qobuzQuality)
 	if err != nil {
-		return "", fmt.Errorf("failed to get download URL: %w", err)
+		return QobuzDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
 	// Download file with item ID for progress tracking
 	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
-		return "", fmt.Errorf("download failed: %w", err)
+		return QobuzDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
 	// Set progress to 100% and status to finalizing (before embedding)
@@ -425,17 +575,6 @@ func downloadFromQobuz(req DownloadRequest) (string, error) {
 			fmt.Println("[Qobuz] No lyrics found for this track")
 		} else {
 			fmt.Printf("[Qobuz] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-			
-			// Convert Japanese lyrics to romaji if enabled
-			if req.ConvertLyricsToRomaji {
-				for i := range lyrics.Lines {
-					if ContainsKana(lyrics.Lines[i].Words) {
-						lyrics.Lines[i].Words = ToRomaji(lyrics.Lines[i].Words)
-					}
-				}
-				fmt.Println("[Qobuz] Converted Japanese lyrics to romaji")
-			}
-			
 			lrcContent := convertToLRC(lyrics)
 			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
 				fmt.Printf("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
@@ -445,5 +584,9 @@ func downloadFromQobuz(req DownloadRequest) (string, error) {
 		}
 	}
 
-	return outputPath, nil
+	return QobuzDownloadResult{
+		FilePath:   outputPath,
+		BitDepth:   actualBitDepth,
+		SampleRate: actualSampleRate,
+	}, nil
 }

go_backend/romaji.go

@@ -1,276 +0,0 @@
-package gobackend
-
-import (
-	"strings"
-	"unicode"
-)
-
-// Japanese character ranges
-const (
-	hiraganaStart = 0x3040
-	hiraganaEnd   = 0x309F
-	katakanaStart = 0x30A0
-	katakanaEnd   = 0x30FF
-	kanjiStart    = 0x4E00
-	kanjiEnd      = 0x9FFF
-)
-
-// hiraganaToRomaji maps hiragana characters to romaji
-var hiraganaToRomaji = map[rune]string{
-	// Basic vowels
-	'あ': "a", 'い': "i", 'う': "u", 'え': "e", 'お': "o",
-	// K-row
-	'か': "ka", 'き': "ki", 'く': "ku", 'け': "ke", 'こ': "ko",
-	// S-row
-	'さ': "sa", 'し': "shi", 'す': "su", 'せ': "se", 'そ': "so",
-	// T-row
-	'た': "ta", 'ち': "chi", 'つ': "tsu", 'て': "te", 'と': "to",
-	// N-row
-	'な': "na", 'に': "ni", 'ぬ': "nu", 'ね': "ne", 'の': "no",
-	// H-row
-	'は': "ha", 'ひ': "hi", 'ふ': "fu", 'へ': "he", 'ほ': "ho",
-	// M-row
-	'ま': "ma", 'み': "mi", 'む': "mu", 'め': "me", 'も': "mo",
-	// Y-row
-	'や': "ya", 'ゆ': "yu", 'よ': "yo",
-	// R-row
-	'ら': "ra", 'り': "ri", 'る': "ru", 'れ': "re", 'ろ': "ro",
-	// W-row
-	'わ': "wa", 'を': "wo",
-	// N
-	'ん': "n",
-	// Voiced (dakuten) - G-row
-	'が': "ga", 'ぎ': "gi", 'ぐ': "gu", 'げ': "ge", 'ご': "go",
-	// Z-row
-	'ざ': "za", 'じ': "ji", 'ず': "zu", 'ぜ': "ze", 'ぞ': "zo",
-	// D-row
-	'だ': "da", 'ぢ': "ji", 'づ': "zu", 'で': "de", 'ど': "do",
-	// B-row
-	'ば': "ba", 'び': "bi", 'ぶ': "bu", 'べ': "be", 'ぼ': "bo",
-	// P-row (handakuten)
-	'ぱ': "pa", 'ぴ': "pi", 'ぷ': "pu", 'ぺ': "pe", 'ぽ': "po",
-	// Small characters
-	'ゃ': "ya", 'ゅ': "yu", 'ょ': "yo",
-	'ぁ': "a", 'ぃ': "i", 'ぅ': "u", 'ぇ': "e", 'ぉ': "o",
-	'っ': "", // Small tsu - handled specially
-	// Long vowel mark
-	'ー': "",
-}
-
-// katakanaToRomaji maps katakana characters to romaji
-var katakanaToRomaji = map[rune]string{
-	// Basic vowels
-	'ア': "a", 'イ': "i", 'ウ': "u", 'エ': "e", 'オ': "o",
-	// K-row
-	'カ': "ka", 'キ': "ki", 'ク': "ku", 'ケ': "ke", 'コ': "ko",
-	// S-row
-	'サ': "sa", 'シ': "shi", 'ス': "su", 'セ': "se", 'ソ': "so",
-	// T-row
-	'タ': "ta", 'チ': "chi", 'ツ': "tsu", 'テ': "te", 'ト': "to",
-	// N-row
-	'ナ': "na", 'ニ': "ni", 'ヌ': "nu", 'ネ': "ne", 'ノ': "no",
-	// H-row
-	'ハ': "ha", 'ヒ': "hi", 'フ': "fu", 'ヘ': "he", 'ホ': "ho",
-	// M-row
-	'マ': "ma", 'ミ': "mi", 'ム': "mu", 'メ': "me", 'モ': "mo",
-	// Y-row
-	'ヤ': "ya", 'ユ': "yu", 'ヨ': "yo",
-	// R-row
-	'ラ': "ra", 'リ': "ri", 'ル': "ru", 'レ': "re", 'ロ': "ro",
-	// W-row
-	'ワ': "wa", 'ヲ': "wo",
-	// N
-	'ン': "n",
-	// Voiced (dakuten) - G-row
-	'ガ': "ga", 'ギ': "gi", 'グ': "gu", 'ゲ': "ge", 'ゴ': "go",
-	// Z-row
-	'ザ': "za", 'ジ': "ji", 'ズ': "zu", 'ゼ': "ze", 'ゾ': "zo",
-	// D-row
-	'ダ': "da", 'ヂ': "ji", 'ヅ': "zu", 'デ': "de", 'ド': "do",
-	// B-row
-	'バ': "ba", 'ビ': "bi", 'ブ': "bu", 'ベ': "be", 'ボ': "bo",
-	// P-row (handakuten)
-	'パ': "pa", 'ピ': "pi", 'プ': "pu", 'ペ': "pe", 'ポ': "po",
-	// Small characters
-	'ャ': "ya", 'ュ': "yu", 'ョ': "yo",
-	'ァ': "a", 'ィ': "i", 'ゥ': "u", 'ェ': "e", 'ォ': "o",
-	'ッ': "", // Small tsu - handled specially
-	// Extended katakana
-	'ヴ': "vu",
-	// Long vowel mark
-	'ー': "",
-}
-
-// Extended katakana combinations (multi-character)
-var katakanaExtended = map[string]string{
-	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
-}
-
-// Combination mappings for small ya/yu/yo
-var hiraganaCombo = map[string]string{
-	"きゃ": "kya", "きゅ": "kyu", "きょ": "kyo",
-	"しゃ": "sha", "しゅ": "shu", "しょ": "sho",
-	"ちゃ": "cha", "ちゅ": "chu", "ちょ": "cho",
-	"にゃ": "nya", "にゅ": "nyu", "にょ": "nyo",
-	"ひゃ": "hya", "ひゅ": "hyu", "ひょ": "hyo",
-	"みゃ": "mya", "みゅ": "myu", "みょ": "myo",
-	"りゃ": "rya", "りゅ": "ryu", "りょ": "ryo",
-	"ぎゃ": "gya", "ぎゅ": "gyu", "ぎょ": "gyo",
-	"じゃ": "ja", "じゅ": "ju", "じょ": "jo",
-	"びゃ": "bya", "びゅ": "byu", "びょ": "byo",
-	"ぴゃ": "pya", "ぴゅ": "pyu", "ぴょ": "pyo",
-}
-
-var katakanaCombo = map[string]string{
-	"キャ": "kya", "キュ": "kyu", "キョ": "kyo",
-	"シャ": "sha", "シュ": "shu", "ショ": "sho",
-	"チャ": "cha", "チュ": "chu", "チョ": "cho",
-	"ニャ": "nya", "ニュ": "nyu", "ニョ": "nyo",
-	"ヒャ": "hya", "ヒュ": "hyu", "ヒョ": "hyo",
-	"ミャ": "mya", "ミュ": "myu", "ミョ": "myo",
-	"リャ": "rya", "リュ": "ryu", "リョ": "ryo",
-	"ギャ": "gya", "ギュ": "gyu", "ギョ": "gyo",
-	"ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
-	"ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
-	"ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
-	// Extended katakana combinations
-	"ティ": "ti", "ディ": "di",
-	"トゥ": "tu", "ドゥ": "du",
-	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
-	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
-	"ヴァ": "va", "ヴィ": "vi", "ヴェ": "ve", "ヴォ": "vo",
-}
-
-// ContainsJapanese checks if a string contains Japanese characters (Hiragana, Katakana, or Kanji)
-func ContainsJapanese(s string) bool {
-	for _, r := range s {
-		if isHiragana(r) || isKatakana(r) || isKanji(r) {
-			return true
-		}
-	}
-	return false
-}
-
-// ContainsKana checks if a string contains Hiragana or Katakana (convertible to romaji)
-func ContainsKana(s string) bool {
-	for _, r := range s {
-		if isHiragana(r) || isKatakana(r) {
-			return true
-		}
-	}
-	return false
-}
-
-func isHiragana(r rune) bool {
-	return r >= hiraganaStart && r <= hiraganaEnd
-}
-
-func isKatakana(r rune) bool {
-	return r >= katakanaStart && r <= katakanaEnd
-}
-
-func isKanji(r rune) bool {
-	return r >= kanjiStart && r <= kanjiEnd
-}
-
-// ToRomaji converts Japanese kana (Hiragana/Katakana) to romaji
-// Kanji characters are preserved as-is since they require dictionary lookup
-func ToRomaji(s string) string {
-	if !ContainsKana(s) {
-		return s
-	}
-
-	runes := []rune(s)
-	var result strings.Builder
-	result.Grow(len(s) * 2) // Romaji is typically longer
-
-	i := 0
-	for i < len(runes) {
-		r := runes[i]
-
-		// Check for two-character combinations first
-		if i+1 < len(runes) {
-			combo := string(runes[i : i+2])
-			if romaji, ok := hiraganaCombo[combo]; ok {
-				result.WriteString(romaji)
-				i += 2
-				continue
-			}
-			if romaji, ok := katakanaCombo[combo]; ok {
-				result.WriteString(romaji)
-				i += 2
-				continue
-			}
-		}
-
-		// Handle small tsu (っ/ッ) - doubles the next consonant
-		if r == 'っ' || r == 'ッ' {
-			if i+1 < len(runes) {
-				nextRune := runes[i+1]
-				var nextRomaji string
-				if romaji, ok := hiraganaToRomaji[nextRune]; ok {
-					nextRomaji = romaji
-				} else if romaji, ok := katakanaToRomaji[nextRune]; ok {
-					nextRomaji = romaji
-				}
-				if len(nextRomaji) > 0 {
-					result.WriteByte(nextRomaji[0]) // Double the consonant
-				}
-			}
-			i++
-			continue
-		}
-
-		// Handle long vowel mark (ー)
-		if r == 'ー' {
-			// Extend the previous vowel
-			resultStr := result.String()
-			if len(resultStr) > 0 {
-				lastChar := resultStr[len(resultStr)-1]
-				if lastChar == 'a' || lastChar == 'i' || lastChar == 'u' || lastChar == 'e' || lastChar == 'o' {
-					result.WriteByte(lastChar)
-				}
-			}
-			i++
-			continue
-		}
-
-		// Single character conversion
-		if romaji, ok := hiraganaToRomaji[r]; ok {
-			result.WriteString(romaji)
-			i++
-			continue
-		}
-
-		if romaji, ok := katakanaToRomaji[r]; ok {
-			result.WriteString(romaji)
-			i++
-			continue
-		}
-
-		// Keep non-Japanese characters as-is
-		if unicode.IsSpace(r) {
-			result.WriteRune(' ')
-		} else {
-			result.WriteRune(r)
-		}
-		i++
-	}
-
-	return result.String()
-}
-
-// GetRomajiVariants returns search variants for Japanese text
-// Returns the original string plus romaji version if applicable
-func GetRomajiVariants(s string) []string {
-	variants := []string{s}
-
-	if ContainsKana(s) {
-		romaji := ToRomaji(s)
-		if romaji != s && strings.TrimSpace(romaji) != "" {
-			variants = append(variants, romaji)
-		}
-	}
-
-	return variants
-}

go_backend/spotify.go

@@ -62,11 +62,32 @@ type SpotifyMetadataClient struct {
 	cacheMu     sync.RWMutex
 }
 
-// NewSpotifyMetadataClient creates a new Spotify client
+// Custom credentials storage (set from Flutter)
-func NewSpotifyMetadataClient() *SpotifyMetadataClient {
+var (
-	src := rand.NewSource(time.Now().UnixNano())
+	customClientID     string
+	customClientSecret string
+	credentialsMu      sync.RWMutex
+)
 
-	// Prefer environment variables for credentials (more secure), fall back to built-in
+// SetSpotifyCredentials sets custom Spotify API credentials
+// Pass empty strings to use default credentials
+func SetSpotifyCredentials(clientID, clientSecret string) {
+	credentialsMu.Lock()
+	defer credentialsMu.Unlock()
+	customClientID = clientID
+	customClientSecret = clientSecret
+}
+
+// getCredentials returns the current credentials (custom or default)
+func getCredentials() (string, string) {
+	credentialsMu.RLock()
+	defer credentialsMu.RUnlock()
+	
+	if customClientID != "" && customClientSecret != "" {
+		return customClientID, customClientSecret
+	}
+	
+	// Fall back to default credentials
 	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
 	if clientID == "" {
 		if decoded, err := base64.StdEncoding.DecodeString("NWY1NzNjOTYyMDQ5NGJhZTg3ODkwYzBmMDhhNjAyOTM="); err == nil {
@@ -80,6 +101,16 @@ func NewSpotifyMetadataClient() *SpotifyMetadataClient {
 			clientSecret = string(decoded)
 		}
 	}
+	
+	return clientID, clientSecret
+}
+
+// NewSpotifyMetadataClient creates a new Spotify client
+func NewSpotifyMetadataClient() *SpotifyMetadataClient {
+	src := rand.NewSource(time.Now().UnixNano())
+
+	// Get credentials (custom or default)
+	clientID, clientSecret := getCredentials()
 
 	c := &SpotifyMetadataClient{
 		httpClient:   NewHTTPClientWithTimeout(15 * time.Second), // Use shared transport for connection pooling
@@ -536,6 +567,7 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 }
 
 func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, token string) (*PlaylistResponsePayload, error) {
+	// First request to get playlist info and first batch of tracks
 	var data struct {
 		Name   string  `json:"name"`
 		Images []image `json:"images"`
@@ -546,7 +578,8 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 			Items []struct {
 				Track *trackFull `json:"track"`
 			} `json:"items"`
-			Total int `json:"total"`
+			Total int    `json:"total"`
+			Next  string `json:"next"`
 		} `json:"tracks"`
 	}
 
@@ -560,7 +593,10 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 	info.Owner.Name = data.Name
 	info.Owner.Images = firstImageURL(data.Images)
 
-	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
+	// Pre-allocate with expected capacity
+	tracks := make([]AlbumTrackMetadata, 0, data.Tracks.Total)
+	
+	// Add first batch of tracks
 	for _, item := range data.Tracks.Items {
 		if item.Track == nil {
 			continue
@@ -584,6 +620,55 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		})
 	}
 
+	// Fetch remaining tracks using pagination (up to 1000 tracks max)
+	nextURL := data.Tracks.Next
+	maxTracks := 1000
+	
+	for nextURL != "" && len(tracks) < maxTracks {
+		var pageData struct {
+			Items []struct {
+				Track *trackFull `json:"track"`
+			} `json:"items"`
+			Next string `json:"next"`
+		}
+
+		if err := c.getJSON(ctx, nextURL, token, &pageData); err != nil {
+			// Log error but return what we have so far
+			fmt.Printf("[Spotify] Warning: failed to fetch page, returning %d tracks: %v\n", len(tracks), err)
+			break
+		}
+
+		for _, item := range pageData.Items {
+			if item.Track == nil {
+				continue
+			}
+			if len(tracks) >= maxTracks {
+				break
+			}
+			tracks = append(tracks, AlbumTrackMetadata{
+				SpotifyID:   item.Track.ID,
+				Artists:     joinArtists(item.Track.Artists),
+				Name:        item.Track.Name,
+				AlbumName:   item.Track.Album.Name,
+				AlbumArtist: joinArtists(item.Track.Album.Artists),
+				DurationMS:  item.Track.DurationMS,
+				Images:      firstImageURL(item.Track.Album.Images),
+				ReleaseDate: item.Track.Album.ReleaseDate,
+				TrackNumber: item.Track.TrackNumber,
+				TotalTracks: item.Track.Album.TotalTracks,
+				DiscNumber:  item.Track.DiscNumber,
+				ExternalURL: item.Track.ExternalURL.Spotify,
+				ISRC:        item.Track.ExternalID.ISRC,
+				AlbumID:     item.Track.Album.ID,
+				AlbumURL:    item.Track.Album.ExternalURL.Spotify,
+			})
+		}
+
+		nextURL = pageData.Next
+	}
+
+	fmt.Printf("[Spotify] Fetched %d tracks from playlist (total: %d)\n", len(tracks), data.Tracks.Total)
+
 	return &PlaylistResponsePayload{
 		PlaylistInfo: info,
 		TrackList:    tracks,

go_backend/tidal.go

@@ -315,6 +315,28 @@ func (t *TidalDownloader) SearchTrackByISRC(isrc string) (*TidalTrack, error) {
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }
 
+// normalizeTitle normalizes a track title for comparison (kept for potential future use)
+func normalizeTitle(title string) string {
+	normalized := strings.ToLower(strings.TrimSpace(title))
+	
+	// Remove common suffixes in parentheses or brackets
+	suffixPatterns := []string{
+		" (remaster)", " (remastered)", " (deluxe)", " (deluxe edition)",
+		" (bonus track)", " (single)", " (album version)", " (radio edit)",
+		" [remaster]", " [remastered]", " [deluxe]", " [bonus track]",
+	}
+	for _, suffix := range suffixPatterns {
+		normalized = strings.TrimSuffix(normalized, suffix)
+	}
+	
+	// Remove multiple spaces
+	for strings.Contains(normalized, "  ") {
+		normalized = strings.ReplaceAll(normalized, "  ", " ")
+	}
+	
+	return normalized
+}
+
 // SearchTrackByMetadataWithISRC searches for a track with ISRC matching priority
 func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, spotifyISRC string, expectedDuration int) (*TidalTrack, error) {
 	token, err := t.GetAccessToken()
@@ -335,33 +357,7 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		queries = append(queries, trackName)
 	}
 
-	// Strategy 3: Romaji versions if Japanese detected
+	// Strategy 3: Artist only as last resort
-	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
-		// Try romaji version of track name
-		if ContainsKana(trackName) {
-			romajiTrack := ToRomaji(trackName)
-			if romajiTrack != trackName {
-				if artistName != "" {
-					queries = append(queries, artistName+" "+romajiTrack)
-				}
-				queries = append(queries, romajiTrack)
-			}
-		}
-		// Try romaji version of artist name
-		if ContainsKana(artistName) {
-			romajiArtist := ToRomaji(artistName)
-			if romajiArtist != artistName {
-				queries = append(queries, romajiArtist+" "+trackName)
-				// Try both romaji
-				if ContainsKana(trackName) {
-					romajiTrack := ToRomaji(trackName)
-					queries = append(queries, romajiArtist+" "+romajiTrack)
-				}
-			}
-		}
-	}
-
-	// Strategy 4: Artist only as last resort
 	if artistName != "" {
 		queries = append(queries, artistName)
 	}
@@ -416,14 +412,50 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		return nil, fmt.Errorf("no tracks found for any search query")
 	}
 
-	// Priority 1: Match by ISRC (exact match)
+	// Priority 1: Match by ISRC (exact match) WITH title verification
 	if spotifyISRC != "" {
+		var isrcMatches []*TidalTrack
 		for i := range allTracks {
 			track := &allTracks[i]
 			if track.ISRC == spotifyISRC {
-				return track, nil
+				isrcMatches = append(isrcMatches, track)
 			}
 		}
+		
+		if len(isrcMatches) > 0 {
+			// Verify duration first (most important check)
+			if expectedDuration > 0 {
+				var durationVerifiedMatches []*TidalTrack
+				for _, track := range isrcMatches {
+					durationDiff := track.Duration - expectedDuration
+					if durationDiff < 0 {
+						durationDiff = -durationDiff
+					}
+					// Allow 30 seconds tolerance for duration
+					if durationDiff <= 30 {
+						durationVerifiedMatches = append(durationVerifiedMatches, track)
+					}
+				}
+				
+				if len(durationVerifiedMatches) > 0 {
+					// Return first duration-verified match
+					fmt.Printf("[Tidal] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n", 
+						durationVerifiedMatches[0].Title, expectedDuration, durationVerifiedMatches[0].Duration)
+					return durationVerifiedMatches[0], nil
+				}
+				
+				// ISRC matches but duration doesn't - this is likely wrong version
+				fmt.Printf("[Tidal] WARNING: ISRC %s found but duration mismatch. Expected=%ds, Found=%ds. Rejecting.\n", 
+					spotifyISRC, expectedDuration, isrcMatches[0].Duration)
+				return nil, fmt.Errorf("ISRC found but duration mismatch: expected %ds, found %ds (likely different version/edit)", 
+					expectedDuration, isrcMatches[0].Duration)
+			}
+			
+			// No duration to verify, just return first ISRC match
+			fmt.Printf("[Tidal] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
+			return isrcMatches[0], nil
+		}
+		
 		// If ISRC was provided but no match found, return error
 		return nil, fmt.Errorf("ISRC mismatch: no track found with ISRC %s on Tidal", spotifyISRC)
 	}
@@ -483,11 +515,18 @@ func (t *TidalDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 }
 
 
+// TidalDownloadInfo contains download URL and quality info
+type TidalDownloadInfo struct {
+	URL        string
+	BitDepth   int
+	SampleRate int
+}
+
 // getDownloadURLSequential requests download URL from APIs sequentially
 // Returns the first successful result (supports both v1 and v2 API formats)
-func getDownloadURLSequential(apis []string, trackID int64, quality string) (string, string, error) {
+func getDownloadURLSequential(apis []string, trackID int64, quality string) (string, TidalDownloadInfo, error) {
 	if len(apis) == 0 {
-		return "", "", fmt.Errorf("no APIs available")
+		return "", TidalDownloadInfo{}, fmt.Errorf("no APIs available")
 	}
 
 	client := NewHTTPClientWithTimeout(DefaultTimeout)
@@ -519,7 +558,12 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 		// Try v2 format first (object with manifest)
 		var v2Response TidalAPIResponseV2
 		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
-			return apiURL, "MANIFEST:" + v2Response.Data.Manifest, nil
+			info := TidalDownloadInfo{
+				URL:        "MANIFEST:" + v2Response.Data.Manifest,
+				BitDepth:   v2Response.Data.BitDepth,
+				SampleRate: v2Response.Data.SampleRate,
+			}
+			return apiURL, info, nil
 		}
 
 		// Fallback to v1 format (array with OriginalTrackUrl)
@@ -529,7 +573,13 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 		if err := json.Unmarshal(body, &v1Responses); err == nil {
 			for _, item := range v1Responses {
 				if item.OriginalTrackURL != "" {
-					return apiURL, item.OriginalTrackURL, nil
+					// v1 format doesn't have quality info, assume 16-bit/44.1kHz
+					info := TidalDownloadInfo{
+						URL:        item.OriginalTrackURL,
+						BitDepth:   16,
+						SampleRate: 44100,
+					}
+					return apiURL, info, nil
 				}
 			}
 		}
@@ -537,22 +587,22 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 		errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "no download URL or manifest in response"))
 	}
 
-	return "", "", fmt.Errorf("all %d Tidal APIs failed. Errors: %v", len(apis), errors)
+	return "", TidalDownloadInfo{}, fmt.Errorf("all %d Tidal APIs failed. Errors: %v", len(apis), errors)
 }
 
 // GetDownloadURL gets download URL for a track - tries APIs sequentially
-func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
+func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (TidalDownloadInfo, error) {
 	apis := t.GetAvailableAPIs()
 	if len(apis) == 0 {
-		return "", fmt.Errorf("no API URL configured")
+		return TidalDownloadInfo{}, fmt.Errorf("no API URL configured")
 	}
 
-	_, downloadURL, err := getDownloadURLSequential(apis, trackID, quality)
+	_, info, err := getDownloadURLSequential(apis, trackID, quality)
 	if err != nil {
-		return "", fmt.Errorf("failed to get download URL: %w", err)
+		return TidalDownloadInfo{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
-	return downloadURL, nil
+	return info, nil
 }
 
 // parseManifest parses Tidal manifest (supports both BTS and DASH formats)
@@ -812,15 +862,25 @@ func (t *TidalDownloader) downloadFromManifest(manifestB64, outputPath, itemID s
 	return nil
 }
 
+// TidalDownloadResult contains download result with quality info
+type TidalDownloadResult struct {
+	FilePath   string
+	BitDepth   int
+	SampleRate int
+}
+
 // downloadFromTidal downloads a track using the request parameters
-func downloadFromTidal(req DownloadRequest) (string, error) {
+func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	downloader := NewTidalDownloader()
 
 	// Check for existing file first
 	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return "EXISTS:" + existingFile, nil
+		return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 
+	// Convert expected duration from ms to seconds
+	expectedDurationSec := req.DurationMS / 1000
+
 	var track *TidalTrack
 	var err error
 
@@ -832,18 +892,31 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 			trackID, idErr := downloader.GetTrackIDFromURL(tidalURL)
 			if idErr == nil {
 				track, err = downloader.GetTrackInfoByID(trackID)
+				// Verify duration if we have expected duration
+				if track != nil && expectedDurationSec > 0 {
+					durationDiff := track.Duration - expectedDurationSec
+					if durationDiff < 0 {
+						durationDiff = -durationDiff
+					}
+					// Allow 30 seconds tolerance
+					if durationDiff > 30 {
+						fmt.Printf("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n", 
+							expectedDurationSec, track.Duration)
+						track = nil // Reject this match
+					}
+				}
 			}
 		}
 	}
 
-	// Strategy 2: Search by ISRC with multi-strategy fallback
+	// Strategy 2: Search by ISRC with duration verification
 	if track == nil && req.ISRC != "" {
-		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, 0)
+		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, expectedDurationSec)
 	}
 
 	// Strategy 3: Search by metadata only (no ISRC requirement)
 	if track == nil {
-		track, err = downloader.SearchTrackByMetadata(req.TrackName, req.ArtistName)
+		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, "", expectedDurationSec)
 	}
 
 	if track == nil {
@@ -851,7 +924,21 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 		if err != nil {
 			errMsg = err.Error()
 		}
-		return "", fmt.Errorf("tidal search failed: %s", errMsg)
+		return TidalDownloadResult{}, fmt.Errorf("tidal search failed: %s", errMsg)
+	}
+
+	// Final duration verification
+	if expectedDurationSec > 0 {
+		durationDiff := track.Duration - expectedDurationSec
+		if durationDiff < 0 {
+			durationDiff = -durationDiff
+		}
+		if durationDiff > 30 {
+			return TidalDownloadResult{}, fmt.Errorf("duration mismatch: expected %ds, found %ds (diff: %ds). Track may be wrong version", 
+				expectedDurationSec, track.Duration, durationDiff)
+		}
+		fmt.Printf("[Tidal] Duration verified: expected %ds, found %ds (diff: %ds)\n", 
+			expectedDurationSec, track.Duration, durationDiff)
 	}
 
 	// Build filename
@@ -868,7 +955,7 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 
 	// Check if file already exists
 	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return "EXISTS:" + outputPath, nil
+		return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
 
 	// Determine quality to use (default to LOSSLESS if not specified)
@@ -879,14 +966,17 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 	fmt.Printf("[Tidal] Using quality: %s\n", quality)
 
 	// Get download URL using parallel API requests
-	downloadURL, err := downloader.GetDownloadURL(track.ID, quality)
+	downloadInfo, err := downloader.GetDownloadURL(track.ID, quality)
 	if err != nil {
-		return "", fmt.Errorf("failed to get download URL: %w", err)
+		return TidalDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
+	// Log actual quality received
+	fmt.Printf("[Tidal] Actual quality: %d-bit/%dHz\n", downloadInfo.BitDepth, downloadInfo.SampleRate)
+
 	// Download file with item ID for progress tracking
-	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.ItemID); err != nil {
-		return "", fmt.Errorf("download failed: %w", err)
+		return TidalDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
 	// Set progress to 100% and status to finalizing (before embedding)
@@ -906,7 +996,7 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 		fmt.Printf("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
 	} else if _, err := os.Stat(outputPath); err != nil {
 		// Neither FLAC nor M4A exists
-		return "", fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+		return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
 	}
 
 	// Embed metadata
@@ -952,17 +1042,6 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 				fmt.Println("[Tidal] No lyrics found for this track")
 			} else {
 				fmt.Printf("[Tidal] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
-				
-				// Convert Japanese lyrics to romaji if enabled
-				if req.ConvertLyricsToRomaji {
-					for i := range lyrics.Lines {
-						if ContainsKana(lyrics.Lines[i].Words) {
-							lyrics.Lines[i].Words = ToRomaji(lyrics.Lines[i].Words)
-						}
-					}
-					fmt.Println("[Tidal] Converted Japanese lyrics to romaji")
-				}
-				
 				lrcContent := convertToLRC(lyrics)
 				if embedErr := EmbedLyrics(actualOutputPath, lrcContent); embedErr != nil {
 					fmt.Printf("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
@@ -975,5 +1054,9 @@ func downloadFromTidal(req DownloadRequest) (string, error) {
 		fmt.Printf("[Tidal] Skipping metadata embed for M4A file (will be handled after conversion): %s\n", actualOutputPath)
 	}
 
-	return actualOutputPath, nil
+	return TidalDownloadResult{
+		FilePath:   actualOutputPath,
+		BitDepth:   downloadInfo.BitDepth,
+		SampleRate: downloadInfo.SampleRate,
+	}, nil
 }

ios/Runner/AppDelegate.swift

@@ -164,7 +164,8 @@ import Gobackend  // Import Go framework
             let spotifyId = args["spotify_id"] as! String
             let trackName = args["track_name"] as! String
             let artistName = args["artist_name"] as! String
-            let response = GobackendGetLyricsLRC(spotifyId, trackName, artistName, &error)
+            let filePath = args["file_path"] as? String ?? ""
+            let response = GobackendGetLyricsLRC(spotifyId, trackName, artistName, filePath, &error)
             if let error = error { throw error }
             return response
             

lib/constants/app_info.dart

@@ -1,8 +1,8 @@
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '2.0.1';
+  static const String version = '2.0.5';
-  static const String buildNumber = '31';
+  static const String buildNumber = '35';
   static const String fullVersion = '$version+$buildNumber';
   
   

lib/models/settings.dart

@@ -16,9 +16,11 @@ class AppSettings {
   final bool checkForUpdates; // Check for updates on app start
   final bool hasSearchedBefore; // Hide helper text after first search
   final String folderOrganization; // none, artist, album, artist_album
-  final bool convertLyricsToRomaji; // Convert Japanese lyrics to romaji
   final String historyViewMode; // list, grid
   final bool askQualityBeforeDownload; // Show quality picker before each download
+  final String spotifyClientId; // Custom Spotify client ID (empty = use default)
+  final String spotifyClientSecret; // Custom Spotify client secret (empty = use default)
+  final bool useCustomSpotifyCredentials; // Whether to use custom credentials (if set)
 
   const AppSettings({
     this.defaultService = 'tidal',
@@ -33,9 +35,11 @@ class AppSettings {
     this.checkForUpdates = true, // Default: enabled
     this.hasSearchedBefore = false, // Default: show helper text
     this.folderOrganization = 'none', // Default: no folder organization
-    this.convertLyricsToRomaji = false, // Default: keep original Japanese
     this.historyViewMode = 'grid', // Default: grid view
     this.askQualityBeforeDownload = true, // Default: ask quality before download
+    this.spotifyClientId = '', // Default: use built-in credentials
+    this.spotifyClientSecret = '', // Default: use built-in credentials
+    this.useCustomSpotifyCredentials = true, // Default: use custom if set
   });
 
   AppSettings copyWith({
@@ -51,9 +55,11 @@ class AppSettings {
     bool? checkForUpdates,
     bool? hasSearchedBefore,
     String? folderOrganization,
-    bool? convertLyricsToRomaji,
     String? historyViewMode,
     bool? askQualityBeforeDownload,
+    String? spotifyClientId,
+    String? spotifyClientSecret,
+    bool? useCustomSpotifyCredentials,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -68,9 +74,11 @@ class AppSettings {
       checkForUpdates: checkForUpdates ?? this.checkForUpdates,
       hasSearchedBefore: hasSearchedBefore ?? this.hasSearchedBefore,
       folderOrganization: folderOrganization ?? this.folderOrganization,
-      convertLyricsToRomaji: convertLyricsToRomaji ?? this.convertLyricsToRomaji,
       historyViewMode: historyViewMode ?? this.historyViewMode,
       askQualityBeforeDownload: askQualityBeforeDownload ?? this.askQualityBeforeDownload,
+      spotifyClientId: spotifyClientId ?? this.spotifyClientId,
+      spotifyClientSecret: spotifyClientSecret ?? this.spotifyClientSecret,
+      useCustomSpotifyCredentials: useCustomSpotifyCredentials ?? this.useCustomSpotifyCredentials,
     );
   }
 

lib/models/settings.g.dart

@@ -19,9 +19,12 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   checkForUpdates: json['checkForUpdates'] as bool? ?? true,
   hasSearchedBefore: json['hasSearchedBefore'] as bool? ?? false,
   folderOrganization: json['folderOrganization'] as String? ?? 'none',
-  convertLyricsToRomaji: json['convertLyricsToRomaji'] as bool? ?? false,
   historyViewMode: json['historyViewMode'] as String? ?? 'grid',
   askQualityBeforeDownload: json['askQualityBeforeDownload'] as bool? ?? true,
+  spotifyClientId: json['spotifyClientId'] as String? ?? '',
+  spotifyClientSecret: json['spotifyClientSecret'] as String? ?? '',
+  useCustomSpotifyCredentials:
+      json['useCustomSpotifyCredentials'] as bool? ?? true,
 );
 
 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -38,7 +41,9 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'checkForUpdates': instance.checkForUpdates,
       'hasSearchedBefore': instance.hasSearchedBefore,
       'folderOrganization': instance.folderOrganization,
-      'convertLyricsToRomaji': instance.convertLyricsToRomaji,
       'historyViewMode': instance.historyViewMode,
       'askQualityBeforeDownload': instance.askQualityBeforeDownload,
+      'spotifyClientId': instance.spotifyClientId,
+      'spotifyClientSecret': instance.spotifyClientSecret,
+      'useCustomSpotifyCredentials': instance.useCustomSpotifyCredentials,
     };

lib/providers/download_queue_provider.dart

@@ -1007,7 +1007,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           releaseDate: item.track.releaseDate,
           preferredService: item.service,
           itemId: item.id, // Pass item ID for progress tracking
-          convertLyricsToRomaji: settings.convertLyricsToRomaji,
+          durationMs: item.track.duration, // Duration in ms for verification
         );
       } else {
         result = await PlatformBridge.downloadTrack(
@@ -1026,16 +1026,50 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           discNumber: item.track.discNumber ?? 1,
           releaseDate: item.track.releaseDate,
           itemId: item.id, // Pass item ID for progress tracking
-          convertLyricsToRomaji: settings.convertLyricsToRomaji,
+          durationMs: item.track.duration, // Duration in ms for verification
         );
       }
       
       _log.d('Result: $result');
       
+      // Check if item was cancelled while downloading
+      final currentItem = state.items.firstWhere((i) => i.id == item.id, orElse: () => item);
+      if (currentItem.status == DownloadStatus.skipped) {
+        _log.i('Download was cancelled, skipping result processing');
+        // Delete the downloaded file if it exists
+        final filePath = result['file_path'] as String?;
+        if (filePath != null && result['success'] == true) {
+          try {
+            final file = File(filePath);
+            if (await file.exists()) {
+              await file.delete();
+              _log.d('Deleted cancelled download file: $filePath');
+            }
+          } catch (e) {
+            _log.w('Failed to delete cancelled file: $e');
+          }
+        }
+        return;
+      }
+      
       if (result['success'] == true) {
         var filePath = result['file_path'] as String?;
         _log.i('Download success, file: $filePath');
         
+        // Get actual quality from response (if available)
+        final actualBitDepth = result['actual_bit_depth'] as int?;
+        final actualSampleRate = result['actual_sample_rate'] as int?;
+        String actualQuality = quality; // Default to requested quality
+        
+        if (actualBitDepth != null && actualBitDepth > 0) {
+          // Format: "24-bit/96kHz" or "16-bit/44.1kHz"
+          final sampleRateKHz = actualSampleRate != null && actualSampleRate > 0 
+              ? (actualSampleRate / 1000).toStringAsFixed(actualSampleRate % 1000 == 0 ? 0 : 1)
+              : '?';
+          actualQuality = '$actualBitDepth-bit/${sampleRateKHz}kHz';
+          _log.i('Actual quality: $actualQuality');
+        }
+        
         // Check if file is M4A (DASH stream from Tidal) and needs remuxing to FLAC
         if (filePath != null && filePath.endsWith('.m4a')) {
           _log.d('Converting M4A to FLAC...');
@@ -1059,6 +1093,25 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           }
         }
         
+        // Check again if cancelled before updating status and adding to history
+        final itemAfterDownload = state.items.firstWhere((i) => i.id == item.id, orElse: () => item);
+        if (itemAfterDownload.status == DownloadStatus.skipped) {
+          _log.i('Download was cancelled during finalization, cleaning up');
+          // Delete the downloaded file
+          if (filePath != null) {
+            try {
+              final file = File(filePath);
+              if (await file.exists()) {
+                await file.delete();
+                _log.d('Deleted cancelled download file: $filePath');
+              }
+            } catch (e) {
+              _log.w('Failed to delete cancelled file: $e');
+            }
+          }
+          return;
+        }
+        
         updateItemStatus(
           item.id,
           DownloadStatus.completed,
@@ -1096,7 +1149,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
               discNumber: item.track.discNumber,
               duration: item.track.duration,
               releaseDate: item.track.releaseDate,
-              quality: quality,
+              quality: actualQuality,
             ),
           );
           

lib/providers/settings_provider.dart

@@ -2,6 +2,7 @@ import 'dart:convert';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/models/settings.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
 
 const _settingsKey = 'app_settings';
 
@@ -17,6 +18,8 @@ class SettingsNotifier extends Notifier<AppSettings> {
     final json = prefs.getString(_settingsKey);
     if (json != null) {
       state = AppSettings.fromJson(jsonDecode(json));
+      // Apply Spotify credentials to Go backend on load
+      _applySpotifyCredentials();
     }
   }
 
@@ -25,6 +28,22 @@ class SettingsNotifier extends Notifier<AppSettings> {
     await prefs.setString(_settingsKey, jsonEncode(state.toJson()));
   }
 
+  /// Apply current Spotify credentials to Go backend
+  Future<void> _applySpotifyCredentials() async {
+    // Only apply custom credentials if enabled and both fields are set
+    if (state.useCustomSpotifyCredentials && 
+        state.spotifyClientId.isNotEmpty && 
+        state.spotifyClientSecret.isNotEmpty) {
+      await PlatformBridge.setSpotifyCredentials(
+        state.spotifyClientId,
+        state.spotifyClientSecret,
+      );
+    } else {
+      // Clear to use default
+      await PlatformBridge.setSpotifyCredentials('', '');
+    }
+  }
+
   void setDefaultService(String service) {
     state = state.copyWith(defaultService: service);
     _saveSettings();
@@ -89,11 +108,6 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
-  void setConvertLyricsToRomaji(bool enabled) {
-    state = state.copyWith(convertLyricsToRomaji: enabled);
-    _saveSettings();
-  }
-
   void setHistoryViewMode(String mode) {
     state = state.copyWith(historyViewMode: mode);
     _saveSettings();
@@ -103,6 +117,40 @@ class SettingsNotifier extends Notifier<AppSettings> {
     state = state.copyWith(askQualityBeforeDownload: enabled);
     _saveSettings();
   }
+
+  void setSpotifyClientId(String clientId) {
+    state = state.copyWith(spotifyClientId: clientId);
+    _saveSettings();
+  }
+
+  void setSpotifyClientSecret(String clientSecret) {
+    state = state.copyWith(spotifyClientSecret: clientSecret);
+    _saveSettings();
+  }
+
+  void setSpotifyCredentials(String clientId, String clientSecret) {
+    state = state.copyWith(
+      spotifyClientId: clientId,
+      spotifyClientSecret: clientSecret,
+    );
+    _saveSettings();
+    _applySpotifyCredentials();
+  }
+
+  void clearSpotifyCredentials() {
+    state = state.copyWith(
+      spotifyClientId: '',
+      spotifyClientSecret: '',
+    );
+    _saveSettings();
+    _applySpotifyCredentials();
+  }
+
+  void setUseCustomSpotifyCredentials(bool enabled) {
+    state = state.copyWith(useCustomSpotifyCredentials: enabled);
+    _saveSettings();
+    _applySpotifyCredentials();
+  }
 }
 
 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(

lib/providers/track_provider.dart

@@ -118,7 +118,8 @@ class TrackNotifier extends Notifier<TrackState> {
     // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
-    state = const TrackState(isLoading: true);
+    // Preserve hasSearchText during fetch
+    state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
       final parsed = await PlatformBridge.parseSpotifyUrl(url);
@@ -174,7 +175,8 @@ class TrackNotifier extends Notifier<TrackState> {
       }
     } catch (e) {
       if (!_isRequestValid(requestId)) return; // Request cancelled
-      state = TrackState(isLoading: false, error: e.toString());
+      // Preserve hasSearchText on error so user stays on search screen
+      state = TrackState(isLoading: false, error: e.toString(), hasSearchText: state.hasSearchText);
     }
   }
 
@@ -182,7 +184,8 @@ class TrackNotifier extends Notifier<TrackState> {
     // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
-    state = const TrackState(isLoading: true);
+    // Preserve hasSearchText during search
+    state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
       final results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
@@ -198,10 +201,12 @@ class TrackNotifier extends Notifier<TrackState> {
         tracks: tracks,
         searchArtists: artists,
         isLoading: false,
+        hasSearchText: state.hasSearchText,
       );
     } catch (e) {
       if (!_isRequestValid(requestId)) return; // Request cancelled
-      state = TrackState(isLoading: false, error: e.toString());
+      // Preserve hasSearchText on error so user stays on search screen
+      state = TrackState(isLoading: false, error: e.toString(), hasSearchText: state.hasSearchText);
     }
   }
 

lib/screens/album_screen.dart

@@ -126,10 +126,10 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
               padding: EdgeInsets.all(32),
               child: Center(child: CircularProgressIndicator()),
             )),
-          if (_error != null)
+            if (_error != null)
             SliverToBoxAdapter(child: Padding(
               padding: const EdgeInsets.all(16),
-              child: Text(_error!, style: TextStyle(color: colorScheme.error)),
+              child: _buildErrorWidget(_error!, colorScheme),
             )),
           if (!_isLoading && _error == null && tracks.isNotEmpty) ...[
             _buildTrackListHeader(context, colorScheme),
@@ -349,6 +349,17 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
               padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
               child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
             ),
+            // Disclaimer
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+              child: Text(
+                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontStyle: FontStyle.italic,
+                ),
+              ),
+            ),
             _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS'); }),
             _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES'); }),
             _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS'); }),
@@ -358,6 +369,69 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
       ),
     );
   }
+
+  /// Build error widget with special handling for rate limit (429)
+  Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
+    final isRateLimit = error.contains('429') || 
+                        error.toLowerCase().contains('rate limit') ||
+                        error.toLowerCase().contains('too many requests');
+    
+    if (isRateLimit) {
+      return Card(
+        elevation: 0,
+        color: colorScheme.errorContainer,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Row(
+            children: [
+              Icon(Icons.timer_off, color: colorScheme.onErrorContainer),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      'Rate Limited',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      'Too many requests. Please wait a moment and try again.',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontSize: 12,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+      );
+    }
+    
+    // Default error display
+    return Card(
+      elevation: 0,
+      color: colorScheme.errorContainer.withValues(alpha: 0.5),
+      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            Icon(Icons.error_outline, color: colorScheme.error),
+            const SizedBox(width: 12),
+            Expanded(child: Text(error, style: TextStyle(color: colorScheme.error))),
+          ],
+        ),
+      ),
+    );
+  }
 }
 
 class _QualityOption extends StatelessWidget {

lib/screens/artist_screen.dart

@@ -128,7 +128,7 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
               if (_error != null)
                 SliverToBoxAdapter(child: Padding(
                   padding: const EdgeInsets.all(16),
-                  child: Text(_error!, style: TextStyle(color: colorScheme.error)),
+                  child: _buildErrorWidget(_error!, colorScheme),
                 )),
               if (!_isLoadingDiscography && _error == null) ...[
                 if (albumsOnly.isNotEmpty) SliverToBoxAdapter(child: _buildAlbumSection('Albums', albumsOnly, colorScheme)),
@@ -318,4 +318,67 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
       ),
     ));
   }
+
+  /// Build error widget with special handling for rate limit (429)
+  Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
+    final isRateLimit = error.contains('429') || 
+                        error.toLowerCase().contains('rate limit') ||
+                        error.toLowerCase().contains('too many requests');
+    
+    if (isRateLimit) {
+      return Card(
+        elevation: 0,
+        color: colorScheme.errorContainer,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Row(
+            children: [
+              Icon(Icons.timer_off, color: colorScheme.onErrorContainer),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      'Rate Limited',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      'Too many requests. Please wait a moment and try again.',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontSize: 12,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+      );
+    }
+    
+    // Default error display
+    return Card(
+      elevation: 0,
+      color: colorScheme.errorContainer.withValues(alpha: 0.5),
+      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            Icon(Icons.error_outline, color: colorScheme.error),
+            const SizedBox(width: 12),
+            Expanded(child: Text(error, style: TextStyle(color: colorScheme.error))),
+          ],
+        ),
+      ),
+    );
+  }
 }

lib/screens/home_tab.dart

@@ -22,7 +22,6 @@ class HomeTab extends ConsumerStatefulWidget {
 
 class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClientMixin, SingleTickerProviderStateMixin {
   final _urlController = TextEditingController();
-  Timer? _debounce;
   bool _isTyping = false;
   final FocusNode _searchFocusNode = FocusNode();
   String? _lastSearchQuery; // Track last searched query to avoid duplicate searches
@@ -38,7 +37,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
   
   @override
   void dispose() {
-    _debounce?.cancel();
     _urlController.removeListener(_onSearchChanged);
     _urlController.dispose();
     _searchFocusNode.dispose();
@@ -48,17 +46,18 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
   /// Called when trackState changes - used to sync search bar with state
   void _onTrackStateChanged(TrackState? previous, TrackState next) {
     // If state was cleared (no content, no search text, not loading), clear the search bar
+    // BUT only if search field is not focused (to prevent clearing while user is typing)
     if (previous != null && 
         !next.hasContent && 
         !next.hasSearchText && 
         !next.isLoading &&
-        _urlController.text.isNotEmpty) {
+        _urlController.text.isNotEmpty &&
+        !_searchFocusNode.hasFocus) {
       _urlController.clear();
       setState(() => _isTyping = false);
     }
   }  void _onSearchChanged() {
     final text = _urlController.text.trim();
-    final wasFocused = _searchFocusNode.hasFocus;
     
     // Update search text state for MainShell back button handling
     ref.read(trackProvider.notifier).setSearchText(text.isNotEmpty);
@@ -68,30 +67,13 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       setState(() => _isTyping = true);
     } else if (text.isEmpty && _isTyping) {
       setState(() => _isTyping = false);
-      ref.read(trackProvider.notifier).clear();
+      // Don't clear provider here - it causes focus issues
+      // Provider will be cleared when user explicitly clears or navigates away
       return;
     }
     
-    // Re-request focus after rebuild if it was focused
+    // No auto-search - user must press Enter to search
-    if (wasFocused) {
+    // This saves API calls and avoids rate limiting
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        if (mounted) {
-          _searchFocusNode.requestFocus();
-        }
-      });
-    }
-    
-    // Debounce all requests (URLs and searches)
-    _debounce?.cancel();
-    _debounce = Timer(const Duration(milliseconds: 400), () {
-      if (text.isEmpty) return;
-      
-      if (text.startsWith('http') || text.startsWith('spotify:')) {
-        _fetchMetadata();
-      } else if (text.length >= 2) {
-        _performSearch(text);
-      }
-    });
   }
 
   Future<void> _performSearch(String query) async {
@@ -116,7 +98,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
   }
 
   Future<void> _clearAndRefresh() async {
-    _debounce?.cancel();
     _urlController.clear();
     _searchFocusNode.unfocus();
     _lastSearchQuery = null; // Reset last query
@@ -222,6 +203,17 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
               padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
               child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
             ),
+            // Disclaimer
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+              child: Text(
+                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontStyle: FontStyle.italic,
+                ),
+              ),
+            ),
             _QualityPickerOption(
               title: 'FLAC Lossless',
               subtitle: '16-bit / 44.1kHz',
@@ -274,6 +266,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
 
     return Scaffold(
       body: CustomScrollView(
+        keyboardDismissBehavior: ScrollViewKeyboardDismissBehavior.onDrag,
         slivers: [
           // App Bar - always present
           SliverAppBar(
@@ -468,6 +461,69 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     ));
   }
 
+  /// Build error widget with special handling for rate limit (429)
+  Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
+    final isRateLimit = error.contains('429') || 
+                        error.toLowerCase().contains('rate limit') ||
+                        error.toLowerCase().contains('too many requests');
+    
+    if (isRateLimit) {
+      return Card(
+        elevation: 0,
+        color: colorScheme.errorContainer,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Row(
+            children: [
+              Icon(Icons.timer_off, color: colorScheme.onErrorContainer),
+              const SizedBox(width: 12),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      'Rate Limited',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      'Too many requests. Please wait a moment before searching again.',
+                      style: TextStyle(
+                        color: colorScheme.onErrorContainer,
+                        fontSize: 12,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+      );
+    }
+    
+    // Default error display
+    return Card(
+      elevation: 0,
+      color: colorScheme.errorContainer.withValues(alpha: 0.5),
+      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            Icon(Icons.error_outline, color: colorScheme.error),
+            const SizedBox(width: 12),
+            Expanded(child: Text(error, style: TextStyle(color: colorScheme.error))),
+          ],
+        ),
+      ),
+    );
+  }
+
   // Search results slivers - only shows search results (track list)
   List<Widget> _buildSearchResults({
     required List<Track> tracks,
@@ -482,11 +538,11 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     }
     
     return [
-      // Error message
+      // Error message - with special handling for rate limit (429)
       if (error != null)
         SliverToBoxAdapter(child: Padding(
           padding: const EdgeInsets.symmetric(horizontal: 16),
-          child: Text(error, style: TextStyle(color: colorScheme.error)),
+          child: _buildErrorWidget(error, colorScheme),
         )),
 
       // Loading indicator
@@ -663,10 +719,29 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
         ),
         contentPadding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
       ),
-      onSubmitted: (_) => _fetchMetadata(),
+      onSubmitted: (_) => _onSearchSubmitted(),
     );
   }
 
+  /// Handle Enter key press - search or fetch URL
+  void _onSearchSubmitted() {
+    final text = _urlController.text.trim();
+    if (text.isEmpty) return;
+    
+    // If it's a URL, fetch metadata
+    if (text.startsWith('http') || text.startsWith('spotify:')) {
+      _fetchMetadata();
+      _searchFocusNode.unfocus();
+      return;
+    }
+    
+    // For search queries, always search (minimum 2 chars)
+    if (text.length >= 2) {
+      _performSearch(text);
+    }
+    _searchFocusNode.unfocus();
+  }
+
 }
 
 class _QualityPickerOption extends StatelessWidget {

lib/screens/main_shell.dart

@@ -125,6 +125,13 @@ class _MainShellState extends ConsumerState<MainShell> {
   void _handleBackPress() {
     final trackState = ref.read(trackProvider);
     
+    // Check if keyboard is visible - if so, just dismiss keyboard, don't clear search
+    final isKeyboardVisible = MediaQuery.of(context).viewInsets.bottom > 0;
+    if (isKeyboardVisible) {
+      FocusScope.of(context).unfocus();
+      return;
+    }
+    
     // If on Home tab and has text in search bar or has content (but not loading), clear it
     if (_currentIndex == 0 && !trackState.isLoading && (trackState.hasSearchText || trackState.hasContent)) {
       ref.read(trackProvider.notifier).clear();
@@ -163,12 +170,17 @@ class _MainShellState extends ConsumerState<MainShell> {
     final queueState = ref.watch(downloadQueueProvider.select((s) => s.queuedCount));
     final trackState = ref.watch(trackProvider);
     
+    // Check if keyboard is visible (bottom inset > 0 means keyboard is showing)
+    final isKeyboardVisible = MediaQuery.of(context).viewInsets.bottom > 0;
+    
     // Determine if we can pop (for predictive back animation)
     // canPop is true when we're at root with no content - enables predictive back gesture
+    // IMPORTANT: Never allow pop when keyboard is visible to prevent accidental navigation
     final canPop = _currentIndex == 0 && 
                    !trackState.hasSearchText && 
                    !trackState.hasContent && 
-                   !trackState.isLoading;
+                   !trackState.isLoading &&
+                   !isKeyboardVisible;
 
     return PopScope(
       canPop: canPop,

lib/screens/playlist_screen.dart

@@ -211,6 +211,17 @@ class PlaylistScreen extends ConsumerWidget {
               Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
             ],
             Padding(padding: const EdgeInsets.fromLTRB(24, 16, 24, 8), child: Text('Select Quality', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold))),
+            // Disclaimer
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
+              child: Text(
+                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontStyle: FontStyle.italic,
+                ),
+              ),
+            ),
             _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS'); }),
             _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES'); }),
             _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS'); }),

lib/screens/queue_tab.dart

@@ -558,6 +558,31 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                         ),
                 ),
               ),
+              // Quality badge (top-left)
+              if (item.quality != null && item.quality!.contains('bit'))
+                Positioned(
+                  left: 4,
+                  top: 4,
+                  child: Container(
+                    padding: const EdgeInsets.symmetric(horizontal: 4, vertical: 2),
+                    decoration: BoxDecoration(
+                      color: item.quality!.startsWith('24') 
+                          ? colorScheme.tertiary 
+                          : colorScheme.surfaceContainerHighest,
+                      borderRadius: BorderRadius.circular(4),
+                    ),
+                    child: Text(
+                      item.quality!.split('/').first, // Just show "24-bit" or "16-bit"
+                      style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                        color: item.quality!.startsWith('24') 
+                            ? colorScheme.onTertiary 
+                            : colorScheme.onSurfaceVariant,
+                        fontSize: 9,
+                        fontWeight: FontWeight.w600,
+                      ),
+                    ),
+                  ),
+                ),
               // Play button overlay
               if (fileExists)
                 Positioned(
@@ -677,11 +702,38 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                       ),
                     ),
                     const SizedBox(height: 2),
-                    Text(
+                    Row(
-                      dateStr,
+                      children: [
-                      style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                        Text(
-                        color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+                          dateStr,
-                      ),
+                          style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                            color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+                          ),
+                        ),
+                        // Quality badge
+                        if (item.quality != null && item.quality!.contains('bit')) ...[
+                          const SizedBox(width: 8),
+                          Container(
+                            padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+                            decoration: BoxDecoration(
+                              color: item.quality!.startsWith('24') 
+                                  ? colorScheme.tertiaryContainer 
+                                  : colorScheme.surfaceContainerHighest,
+                              borderRadius: BorderRadius.circular(4),
+                            ),
+                            child: Text(
+                              item.quality!,
+                              style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                                color: item.quality!.startsWith('24') 
+                                    ? colorScheme.onTertiaryContainer 
+                                    : colorScheme.onSurfaceVariant,
+                                fontSize: 10,
+                                fontWeight: FontWeight.w500,
+                              ),
+                            ),
+                          ),
+                        ],
+                      ],
                     ),
                   ],
                 ),

lib/screens/settings/options_settings_page.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/models/settings.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/widgets/settings_group.dart';
@@ -99,23 +100,6 @@ class OptionsSettingsPage extends ConsumerWidget {
             ),
           ),
 
-          // Lyrics section
-          const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Lyrics')),
-          SliverToBoxAdapter(
-            child: SettingsGroup(
-              children: [
-                SettingsSwitchItem(
-                  icon: Icons.translate,
-                  title: 'Convert Japanese to Romaji',
-                  subtitle: 'Auto-convert Hiragana/Katakana lyrics',
-                  value: settings.convertLyricsToRomaji,
-                  onChanged: (v) => ref.read(settingsProvider.notifier).setConvertLyricsToRomaji(v),
-                  showDivider: false,
-                ),
-              ],
-            ),
-          ),
-
           // App section
           const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'App')),
           SliverToBoxAdapter(
@@ -133,6 +117,38 @@ class OptionsSettingsPage extends ConsumerWidget {
             ),
           ),
 
+          // Spotify API section
+          const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Spotify API')),
+          SliverToBoxAdapter(
+            child: SettingsGroup(
+              children: [
+                SettingsItem(
+                  icon: Icons.key,
+                  title: 'Custom Credentials',
+                  subtitle: settings.spotifyClientId.isNotEmpty 
+                      ? 'Client ID: ${settings.spotifyClientId.length > 8 ? '${settings.spotifyClientId.substring(0, 8)}...' : settings.spotifyClientId}' 
+                      : 'Not configured',
+                  onTap: () => _showSpotifyCredentialsDialog(context, ref, settings),
+                  trailing: settings.spotifyClientId.isNotEmpty
+                      ? Icon(Icons.edit, color: Theme.of(context).colorScheme.onSurfaceVariant, size: 20)
+                      : Icon(Icons.add, color: Theme.of(context).colorScheme.primary, size: 20),
+                  showDivider: settings.spotifyClientId.isNotEmpty,
+                ),
+                if (settings.spotifyClientId.isNotEmpty)
+                  SettingsSwitchItem(
+                    icon: Icons.toggle_on,
+                    title: 'Use Custom Credentials',
+                    subtitle: settings.useCustomSpotifyCredentials 
+                        ? 'Using your credentials' 
+                        : 'Using default credentials',
+                    value: settings.useCustomSpotifyCredentials,
+                    onChanged: (v) => ref.read(settingsProvider.notifier).setUseCustomSpotifyCredentials(v),
+                    showDivider: false,
+                  ),
+              ],
+            ),
+          ),
+
           // Data section
           const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Data')),
           SliverToBoxAdapter(
@@ -180,6 +196,132 @@ class OptionsSettingsPage extends ConsumerWidget {
       ),
     );
   }
+
+  void _showSpotifyCredentialsDialog(BuildContext context, WidgetRef ref, AppSettings settings) {
+    final clientIdController = TextEditingController(text: settings.spotifyClientId);
+    final clientSecretController = TextEditingController(text: settings.spotifyClientSecret);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    showModalBottomSheet(
+      context: context,
+      isScrollControlled: true,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      builder: (context) => Padding(
+        padding: EdgeInsets.only(bottom: MediaQuery.of(context).viewInsets.bottom),
+        child: SingleChildScrollView(
+          child: SafeArea(
+            child: Column(
+              mainAxisSize: MainAxisSize.min,
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                const SizedBox(height: 8),
+                Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 20, 24, 8),
+                  child: Text('Spotify API Credentials', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
+                ),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+                  child: Text(
+                    'Use your own credentials to avoid rate limiting.',
+                    style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+                  ),
+                ),
+                Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 24),
+                  child: TextField(
+                    controller: clientIdController,
+                    decoration: InputDecoration(
+                      labelText: 'Client ID',
+                      hintText: 'Enter Spotify Client ID',
+                      filled: true,
+                      fillColor: colorScheme.surfaceContainerLow,
+                      border: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.outline.withValues(alpha: 0.3))),
+                      enabledBorder: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.outline.withValues(alpha: 0.3))),
+                      focusedBorder: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.primary, width: 2)),
+                    ),
+                  ),
+                ),
+                const SizedBox(height: 12),
+                Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 24),
+                  child: TextField(
+                    controller: clientSecretController,
+                    obscureText: true,
+                    decoration: InputDecoration(
+                      labelText: 'Client Secret',
+                      hintText: 'Enter Spotify Client Secret',
+                      filled: true,
+                      fillColor: colorScheme.surfaceContainerLow,
+                      border: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.outline.withValues(alpha: 0.3))),
+                      enabledBorder: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.outline.withValues(alpha: 0.3))),
+                      focusedBorder: OutlineInputBorder(borderRadius: BorderRadius.circular(16), borderSide: BorderSide(color: colorScheme.primary, width: 2)),
+                    ),
+                  ),
+                ),
+                const SizedBox(height: 24),
+                Padding(
+                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+                  child: Row(
+                    children: [
+                      if (settings.spotifyClientId.isNotEmpty)
+                        Expanded(
+                          child: OutlinedButton(
+                            onPressed: () {
+                              ref.read(settingsProvider.notifier).clearSpotifyCredentials();
+                              Navigator.pop(context);
+                              ScaffoldMessenger.of(context).showSnackBar(
+                                const SnackBar(content: Text('Credentials cleared')),
+                              );
+                            },
+                            style: OutlinedButton.styleFrom(
+                              foregroundColor: colorScheme.error,
+                              side: BorderSide(color: colorScheme.error),
+                              shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+                              minimumSize: const Size.fromHeight(52),
+                            ),
+                            child: const Text('Clear'),
+                          ),
+                        ),
+                      if (settings.spotifyClientId.isNotEmpty) const SizedBox(width: 12),
+                      Expanded(
+                        child: FilledButton(
+                          onPressed: () {
+                            final clientId = clientIdController.text.trim();
+                            final clientSecret = clientSecretController.text.trim();
+                            
+                            if (clientId.isNotEmpty && clientSecret.isNotEmpty) {
+                              ref.read(settingsProvider.notifier).setSpotifyCredentials(clientId, clientSecret);
+                              Navigator.pop(context);
+                              ScaffoldMessenger.of(context).showSnackBar(
+                                const SnackBar(content: Text('Credentials saved')),
+                              );
+                            } else if (clientId.isEmpty && clientSecret.isEmpty) {
+                              Navigator.pop(context);
+                            } else {
+                              ScaffoldMessenger.of(context).showSnackBar(
+                                const SnackBar(content: Text('Please fill both Client ID and Secret')),
+                              );
+                            }
+                          },
+                          style: FilledButton.styleFrom(
+                            shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+                            minimumSize: const Size.fromHeight(52),
+                          ),
+                          child: const Text('Save'),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
 }
 
 class _ConcurrentDownloadsItem extends StatelessWidget {

lib/screens/settings_screen.dart

@@ -392,7 +392,19 @@ class SettingsScreen extends ConsumerWidget {
         title: const Text('Select Quality'),
         content: Column(
           mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
           children: [
+            // Disclaimer
+            Padding(
+              padding: const EdgeInsets.only(bottom: 12),
+              child: Text(
+                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontStyle: FontStyle.italic,
+                ),
+              ),
+            ),
             _buildQualityOption(context, ref, 'LOSSLESS', 'FLAC (Lossless)', '16-bit / 44.1kHz', current, colorScheme),
             _buildQualityOption(context, ref, 'HI_RES', 'Hi-Res FLAC', '24-bit / up to 192kHz', current, colorScheme),
           ],

lib/screens/settings_tab.dart

@@ -389,7 +389,19 @@ class _SettingsTabState extends ConsumerState<SettingsTab> with AutomaticKeepAli
         title: const Text('Select Quality'),
         content: Column(
           mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
           children: [
+            // Disclaimer
+            Padding(
+              padding: const EdgeInsets.only(bottom: 12),
+              child: Text(
+                'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                  fontStyle: FontStyle.italic,
+                ),
+              ),
+            ),
             _buildQualityOption(context, ref, 'LOSSLESS', 'FLAC (Lossless)', '16-bit / 44.1kHz', current, colorScheme),
             _buildQualityOption(context, ref, 'HI_RES', 'Hi-Res FLAC', '24-bit / up to 96kHz', current, colorScheme),
             _buildQualityOption(context, ref, 'HI_RES_LOSSLESS', 'Hi-Res FLAC Max', '24-bit / up to 192kHz', current, colorScheme),

lib/screens/setup_screen.dart

@@ -87,10 +87,43 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
         PermissionStatus status;
         
         if (_androidSdkVersion >= 33) {
+          // Android 13+: Use audio permission
           status = await Permission.audio.request();
         } else if (_androidSdkVersion >= 30) {
-          status = await Permission.manageExternalStorage.request();
+          // Android 11-12: Need MANAGE_EXTERNAL_STORAGE
+          // This opens system settings, not a dialog
+          status = await Permission.manageExternalStorage.status;
+          if (!status.isGranted) {
+            // Show explanation dialog first
+            if (mounted) {
+              final shouldOpen = await showDialog<bool>(
+                context: context,
+                builder: (context) => AlertDialog(
+                  title: const Text('Storage Access Required'),
+                  content: const Text(
+                    'Android 11+ requires "All files access" permission to save music files.\n\n'
+                    'Please enable "Allow access to manage all files" in the next screen.',
+                  ),
+                  actions: [
+                    TextButton(
+                      onPressed: () => Navigator.pop(context, false),
+                      child: const Text('Cancel'),
+                    ),
+                    FilledButton(
+                      onPressed: () => Navigator.pop(context, true),
+                      child: const Text('Open Settings'),
+                    ),
+                  ],
+                ),
+              );
+              
+              if (shouldOpen == true) {
+                status = await Permission.manageExternalStorage.request();
+              }
+            }
+          }
         } else {
+          // Android 10 and below: Use legacy storage permission
           status = await Permission.storage.request();
         }
         

lib/screens/track_metadata_screen.dart

@@ -47,6 +47,11 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
         _fileExists = exists;
         _fileSize = size;
       });
+      
+      // Auto-load lyrics if file exists (embedded lyrics are instant)
+      if (exists) {
+        _fetchLyrics();
+      }
     }
   }
 
@@ -359,22 +364,38 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   Future<void> _openSpotifyUrl(BuildContext context) async {
     if (item.spotifyId == null) return;
     
-    final url = 'https://open.spotify.com/track/${item.spotifyId}';
+    final webUrl = 'https://open.spotify.com/track/${item.spotifyId}';
+    final spotifyUri = Uri.parse('spotify:track:${item.spotifyId}');
+    
     try {
-      // Try to open in Spotify app first, fallback to browser
+      // Try to open in Spotify app first using URI scheme
-      final uri = Uri.parse('spotify:track:${item.spotifyId}');
+      final launched = await launchUrl(
-      // ignore: deprecated_member_use
+        spotifyUri,
-      if (await canLaunchUrl(uri)) {
+        mode: LaunchMode.externalApplication,
-        await launchUrl(uri);
+      );
-      } else {
+      
-        await launchUrl(Uri.parse(url), mode: LaunchMode.externalApplication);
+      if (!launched) {
+        // Fallback to web URL which will redirect to app if installed
+        await launchUrl(
+          Uri.parse(webUrl),
+          mode: LaunchMode.externalApplication,
+        );
       }
     } catch (e) {
-      if (context.mounted) {
+      // If URI scheme fails, try web URL
-        _copyToClipboard(context, url);
+      try {
-        ScaffoldMessenger.of(context).showSnackBar(
+        await launchUrl(
-          const SnackBar(content: Text('Spotify URL copied to clipboard')),
+          Uri.parse(webUrl),
+          mode: LaunchMode.externalApplication,
         );
+      } catch (_) {
+        // Last resort: copy to clipboard
+        if (context.mounted) {
+          _copyToClipboard(context, webUrl);
+          ScaffoldMessenger.of(context).showSnackBar(
+            const SnackBar(content: Text('Spotify URL copied to clipboard')),
+          );
+        }
       }
     }
   }
@@ -392,6 +413,8 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
         _MetadataItem('Disc number', item.discNumber.toString()),
       if (item.duration != null)
         _MetadataItem('Duration', _formatDuration(item.duration!)),
+      if (item.quality != null && item.quality!.contains('bit'))
+        _MetadataItem('Audio quality', item.quality!),
       if (item.releaseDate != null && item.releaseDate!.isNotEmpty)
         _MetadataItem('Release date', item.releaseDate!),
       if (item.isrc != null && item.isrc!.isNotEmpty)
@@ -740,6 +763,7 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
         item.spotifyId ?? '',
         item.trackName,
         item.artistName,
+        filePath: _fileExists ? item.filePath : null, // Try embedded lyrics first
       );
       
       if (mounted) {

lib/services/platform_bridge.dart

@@ -60,12 +60,12 @@ class PlatformBridge {
     String quality = 'LOSSLESS',
     bool embedLyrics = true,
     bool embedMaxQualityCover = true,
-    bool convertLyricsToRomaji = false,
     int trackNumber = 1,
     int discNumber = 1,
     int totalTracks = 1,
     String? releaseDate,
     String? itemId,
+    int durationMs = 0,
   }) async {
     final request = jsonEncode({
       'isrc': isrc,
@@ -81,12 +81,12 @@ class PlatformBridge {
       'quality': quality,
       'embed_lyrics': embedLyrics,
       'embed_max_quality_cover': embedMaxQualityCover,
-      'convert_lyrics_to_romaji': convertLyricsToRomaji,
       'track_number': trackNumber,
       'disc_number': discNumber,
       'total_tracks': totalTracks,
       'release_date': releaseDate ?? '',
       'item_id': itemId ?? '',
+      'duration_ms': durationMs,
     });
     
     final result = await _channel.invokeMethod('downloadTrack', request);
@@ -107,13 +107,13 @@ class PlatformBridge {
     String quality = 'LOSSLESS',
     bool embedLyrics = true,
     bool embedMaxQualityCover = true,
-    bool convertLyricsToRomaji = false,
     int trackNumber = 1,
     int discNumber = 1,
     int totalTracks = 1,
     String? releaseDate,
     String preferredService = 'tidal',
     String? itemId,
+    int durationMs = 0,
   }) async {
     final request = jsonEncode({
       'isrc': isrc,
@@ -129,12 +129,12 @@ class PlatformBridge {
       'quality': quality,
       'embed_lyrics': embedLyrics,
       'embed_max_quality_cover': embedMaxQualityCover,
-      'convert_lyrics_to_romaji': convertLyricsToRomaji,
       'track_number': trackNumber,
       'disc_number': discNumber,
       'total_tracks': totalTracks,
       'release_date': releaseDate ?? '',
       'item_id': itemId ?? '',
+      'duration_ms': durationMs,
     });
     
     final result = await _channel.invokeMethod('downloadWithFallback', request);
@@ -214,15 +214,18 @@ class PlatformBridge {
   }
 
   /// Get lyrics in LRC format
+  /// First tries to extract from embedded file, then falls back to internet
   static Future<String> getLyricsLRC(
     String spotifyId,
     String trackName,
-    String artistName,
+    String artistName, {
-  ) async {
+    String? filePath,
+  }) async {
     final result = await _channel.invokeMethod('getLyricsLRC', {
       'spotify_id': spotifyId,
       'track_name': trackName,
       'artist_name': artistName,
+      'file_path': filePath ?? '',
     });
     return result as String;
   }
@@ -285,4 +288,13 @@ class PlatformBridge {
     final result = await _channel.invokeMethod('isDownloadServiceRunning');
     return result as bool;
   }
+
+  /// Set custom Spotify API credentials
+  /// Pass empty strings to use default credentials
+  static Future<void> setSpotifyCredentials(String clientId, String clientSecret) async {
+    await _channel.invokeMethod('setSpotifyCredentials', {
+      'client_id': clientId,
+      'client_secret': clientSecret,
+    });
+  }
 }

pubspec.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: 'none'
-version: 2.0.1+31
+version: 2.0.5+35
 
 environment:
   sdk: ^3.10.0