chore: bump version to 3.5.0-beta.1

- Cache home feed to SharedPreferences for instant restore on app launch
- Resolve SAF tree URIs to human-readable paths (e.g. /storage/emulated/0/Music)
- Add Android 13+ per-app language support (locale_config.xml)
- Bump version to 3.5.0+73

CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## [3.5.0-beta.1] - 2026-02-06
+
+### Highlights
+- **SAF Storage (Android 10+)**: Proper Storage Access Framework support for download destination (content URIs)
+  - Select download folder via SAF tree picker
+  - Downloads now write to SAF file descriptors (`/proc/self/fd/*`) instead of raw filesystem paths
+  - Works around Android 10+ scoped storage permission errors
+
+### Added
+
+- Home feed disk caching via SharedPreferences for instant restore on app startup
+- SAF display path resolver in native Android layer (converts tree URIs to readable paths)
+- New settings fields for storage mode + SAF tree URI
+- SAF platform bridge methods: pick tree, stat/exists/delete, open content URI, copy to temp, write back to SAF
+- SAF library scan mode (DocumentFile traversal + metadata read)
+- Library UI toggle to show SAF-repaired history items
+- Scan cancelled banner + retry action for library scans
+- Android DocumentFile dependency for SAF operations
+- Post-processing API v2 (SAF-aware, ready to replace v1)
+
+### Changed
+
+- Download pipeline supports `output_path` + `output_ext` for Go backend
+- Tidal/Qobuz/Amazon/Extension downloads use SAF-aware output when enabled
+- Post-processing hooks run for SAF content URIs (via temp file bridge)
+- File operations in Library/Queue/Track screens now SAF-aware (`open`, `exists`, `delete`, `stat`)
+- Android build tooling upgraded to Gradle 9.3.1 (wrapper)
+- Android build path validated with Java 25 (Gradle/Kotlin/assemble debug)
+- SAF tree picker flow in `MainActivity` migrated to Activity Result API (`registerForActivityResult`)
+- `MainActivity` host migrated to `FlutterFragmentActivity` for SAF picker compatibility
+- Legacy `startActivityForResult` / `onActivityResult` SAF picker path removed
+
+### Fixed
+
+- Android 10+ `permission denied` when writing to `/storage/emulated/0` (now handled via SAF)
+- SAF history repair: auto-resolve missing content URIs using tree + filename
+- SAF download fallback: retry in app-private storage when SAF write fails
+- Tidal DASH manifest writing when output path is a file descriptor (no invalid `.m4a` path)
+- External LRC output in SAF mode
+- Restored old-device renderer fallback while using `FlutterFragmentActivity` by injecting shell args from a custom `FlutterFragment` (`--enable-impeller=false` on problematic devices)
+- Preserved Flutter fragment creation behavior (cached engine, engine group, new engine) while adding Impeller fallback support
+- SAF tree picker result now consistently returns `tree_uri` payload with persisted URI permission handling
+
+---
+
+## [3.4.2] - 2026-02-04
+
+### Improved
+
+- **Mobile Network Reliability**: All providers (Qobuz, Tidal, Amazon, Deezer) now have retry logic with exponential backoff
+  - Increased API timeouts: 15s → 25s (Deezer, Qobuz, Tidal), 30s (Amazon)
+  - Up to 3 retry attempts per API call (500ms → 1s → 2s backoff)
+  - Retryable: timeout, connection reset/refused, EOF, HTTP 5xx, HTTP 429
+- **SongLink ID Extraction**: Extract QobuzID/TidalID directly from SongLink URLs
+  - New fields in `TrackAvailability`: `QobuzID`, `TidalID`
+  - Qobuz/Tidal now use direct Track ID from SongLink instead of re-parsing URLs
+- **Qobuz Download Flow**: New Strategy 3 - get QobuzID from SongLink before ISRC search
+  - Cache hit now uses `GetTrackByID()` directly instead of searching again
+  - Pre-warm cache tries SongLink first before direct ISRC search
+- **Tidal Download Flow**: Use `availability.TidalID` directly from SongLink struct
+
+---
+
+## [3.4.1] - 2026-02-04
+
+### Fixed
+
+- Metadata Priority order now persists after app restart
+- Download Provider Priority order now persists after app restart
+
+---
+
 ## [3.4.0] - 2026-02-03
 
 ### Highlights
@@ -495,4 +567,4 @@ SpotiFLAC 3.0 introduces a powerful extension system that allows third-party int
 
 ---
 
-*For older versions, see [GitHub Releases*](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
+*For older versions, see [GitHub Releases*](https://github.com/zarzet/SpotiFLAC-Mobile/releases)

android/app/build.gradle.kts

@@ -103,4 +103,6 @@ dependencies {
     
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
+    implementation("androidx.documentfile:documentfile:1.0.1")
+    implementation("androidx.activity:activity-ktx:1.9.0")
 }

android/app/src/main/AndroidManifest.xml

@@ -21,7 +21,8 @@
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher"
         android:usesCleartextTraffic="false"
-        android:enableOnBackInvokedCallback="true">
+        android:enableOnBackInvokedCallback="true"
+        android:localeConfig="@xml/locale_config">
 
         <activity
             android:name=".MainActivity"

android/app/src/main/res/xml/locale_config.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
+    <locale android:name="en" />
+    <locale android:name="ru" />
+    <locale android:name="es-ES" />
+    <locale android:name="id" />
+    <locale android:name="pt-PT" />
+    <locale android:name="ja" />
+    <locale android:name="tr" />
+    <locale android:name="de" />
+    <locale android:name="fr" />
+    <locale android:name="hi" />
+    <locale android:name="ko" />
+    <locale android:name="nl" />
+    <locale android:name="zh" />
+</locale-config>

android/gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-all.zip

go_backend/amazon.go

@@ -17,6 +17,13 @@ import (
 	"time"
 )
 
+// Amazon API timeout and retry configuration for mobile networks
+const (
+	amazonAPITimeoutMobile = 30 * time.Second // Longer timeout for unstable mobile networks
+	amazonMaxRetries       = 2                // Number of retry attempts
+	amazonRetryDelay       = 500 * time.Millisecond
+)
+
 type AmazonDownloader struct {
 	client *http.Client
 }
@@ -36,15 +43,6 @@ type AfkarXYZResponse struct {
 	} `json:"data"`
 }
 
-func amazonIsASCIIString(s string) bool {
-	for _, r := range s {
-		if r > 127 {
-			return false
-		}
-	}
-	return true
-}
-
 func NewAmazonDownloader() *AmazonDownloader {
 	amazonDownloaderOnce.Do(func() {
 		globalAmazonDownloader = &AmazonDownloader{
@@ -54,12 +52,50 @@ func NewAmazonDownloader() *AmazonDownloader {
 	return globalAmazonDownloader
 }
 
-func (a *AmazonDownloader) downloadFromAfkarXYZ(amazonURL string) (string, string, error) {
+// fetchAmazonURLWithRetry fetches from AfkarXYZ API with retry logic for mobile networks
+func (a *AmazonDownloader) fetchAmazonURLWithRetry(amazonURL string) (string, string, error) {
 	apiURL := "https://amazon.afkarxyz.fun/convert?url=" + url.QueryEscape(amazonURL)
 
-	GoLog("[Amazon] Fetching from AfkarXYZ API...\n")
+	var lastErr error
+	for attempt := 0; attempt <= amazonMaxRetries; attempt++ {
+		if attempt > 0 {
+			delay := amazonRetryDelay * time.Duration(1<<(attempt-1)) // Exponential backoff
+			GoLog("[Amazon] Retry %d/%d after %v...\n", attempt, amazonMaxRetries, delay)
+			time.Sleep(delay)
+		}
 
-	req, err := http.NewRequest("GET", apiURL, nil)
+		downloadURL, fileName, err := a.doAfkarXYZRequest(apiURL)
+		if err == nil {
+			return downloadURL, fileName, nil
+		}
+
+		lastErr = err
+		errStr := err.Error()
+
+		// Check if error is retryable
+		isRetryable := strings.Contains(errStr, "timeout") ||
+			strings.Contains(errStr, "connection reset") ||
+			strings.Contains(errStr, "connection refused") ||
+			strings.Contains(errStr, "EOF") ||
+			strings.Contains(errStr, "status 5") ||
+			strings.Contains(errStr, "status 429")
+
+		if !isRetryable {
+			return "", "", err
+		}
+
+		GoLog("[Amazon] Attempt %d failed (retryable): %v\n", attempt+1, err)
+	}
+
+	return "", "", fmt.Errorf("all %d attempts failed: %w", amazonMaxRetries+1, lastErr)
+}
+
+// doAfkarXYZRequest performs a single request to AfkarXYZ API
+func (a *AmazonDownloader) doAfkarXYZRequest(apiURL string) (string, string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), amazonAPITimeoutMobile)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
 	if err != nil {
 		return "", "", fmt.Errorf("failed to create request: %w", err)
 	}
@@ -98,12 +134,22 @@ func (a *AmazonDownloader) downloadFromAfkarXYZ(amazonURL string) (string, strin
 	reg := regexp.MustCompile(`[<>:"/\\|?*]`)
 	fileName = reg.ReplaceAllString(fileName, "")
 
-	GoLog("[Amazon] AfkarXYZ returned: %s (%.2f MB)\n", fileName, float64(apiResp.Data.FileSize)/(1024*1024))
-
 	return apiResp.Data.DirectLink, fileName, nil
 }
 
-func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (a *AmazonDownloader) downloadFromAfkarXYZ(amazonURL string) (string, string, error) {
+	GoLog("[Amazon] Fetching from AfkarXYZ API...\n")
+
+	downloadURL, fileName, err := a.fetchAmazonURLWithRetry(amazonURL)
+	if err != nil {
+		return "", "", err
+	}
+
+	GoLog("[Amazon] AfkarXYZ returned: %s\n", fileName)
+	return downloadURL, fileName, nil
+}
+
+func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()
 
 	if itemID != "" {
@@ -142,7 +188,7 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		SetItemBytesTotal(itemID, expectedSize)
 	}
 
-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -161,23 +207,23 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 	closeErr := out.Close()
 
 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}
 
 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}
 
@@ -197,44 +243,63 @@ type AmazonDownloadResult struct {
 	TrackNumber int
 	DiscNumber  int
 	ISRC        string
+	LyricsLRC   string
 }
 
 func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	downloader := NewAmazonDownloader()
 
-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
+	}
+
+	amazonURL := ""
+	if req.ISRC != "" {
+		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.AmazonURL != "" {
+			amazonURL = cached.AmazonURL
+			GoLog("[Amazon] Cache hit! Using cached Amazon URL for ISRC %s\n", req.ISRC)
+		}
 	}
 
 	songlink := NewSongLinkClient()
 	var availability *TrackAvailability
 	var err error
 
-	if deezerID, found := strings.CutPrefix(req.SpotifyID, "deezer:"); found {
-		GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
-		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
-	} else if req.SpotifyID != "" {
-		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
-	} else {
-		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+	if amazonURL == "" {
+		if deezerID, found := strings.CutPrefix(req.SpotifyID, "deezer:"); found {
+			GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
+			availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
+		} else if req.SpotifyID != "" {
+			availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+		} else {
+			return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+		}
+
+		if err != nil {
+			return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
+		}
+
+		if !availability.Amazon || availability.AmazonURL == "" {
+			return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
+		}
+
+		amazonURL = availability.AmazonURL
+		if req.ISRC != "" {
+			GetTrackIDCache().SetAmazonURL(req.ISRC, amazonURL)
+		}
 	}
 
-	if err != nil {
-		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
-	}
-
-	if !availability.Amazon || availability.AmazonURL == "" {
-		return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
-	}
-
-	if req.OutputDir != "." {
+	if !isSafOutput && req.OutputDir != "." {
 		if err := os.MkdirAll(req.OutputDir, 0755); err != nil {
 			return AmazonDownloadResult{}, fmt.Errorf("failed to create output directory: %w", err)
 		}
 	}
 
 	// Download using AfkarXYZ API
-	downloadURL, _, err := downloader.downloadFromAfkarXYZ(availability.AmazonURL)
+	downloadURL, _, err := downloader.downloadFromAfkarXYZ(amazonURL)
 	if err != nil {
 		return AmazonDownloadResult{}, fmt.Errorf("failed to get download URL from AfkarXYZ: %w", err)
 	}
@@ -249,11 +314,18 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		"year":   extractYear(req.ReleaseDate),
 		"disc":   req.DiscNumber,
 	})
-	filename = sanitizeFilename(filename) + ".flac"
-	outputPath := filepath.Join(req.OutputDir, filename)
-
-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+	var outputPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+	} else {
+		filename = sanitizeFilename(filename) + ".flac"
+		outputPath = filepath.Join(req.OutputDir, filename)
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
 	}
 
 	// START PARALLEL: Fetch cover and lyrics while downloading audio
@@ -273,7 +345,7 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	}()
 
 	// Download audio file with item ID for progress tracking
-	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadURL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return AmazonDownloadResult{}, ErrDownloadCancelled
 		}
@@ -346,59 +418,70 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		}
 	}
 
-	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
-		GoLog("[Amazon] Warning: failed to embed metadata: %v\n", err)
-	}
-
-	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		lyricsMode := req.LyricsMode
-		if lyricsMode == "" {
-			lyricsMode = "embed"
+	if isSafOutput {
+		GoLog("[Amazon] SAF output detected - skipping in-backend metadata/lyrics embedding (handled in Flutter)\n")
+	} else {
+		if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+			GoLog("[Amazon] Warning: failed to embed metadata: %v\n", err)
 		}
 
-		if lyricsMode == "external" || lyricsMode == "both" {
-			GoLog("[Amazon] Saving external LRC file...\n")
-			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
-				GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
-			} else {
-				GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
+		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+			lyricsMode := req.LyricsMode
+			if lyricsMode == "" {
+				lyricsMode = "embed"
 			}
-		}
 
-		if lyricsMode == "embed" || lyricsMode == "both" {
-			GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-				GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				GoLog("[Amazon] Lyrics embedded successfully\n")
+			if lyricsMode == "external" || lyricsMode == "both" {
+				GoLog("[Amazon] Saving external LRC file...\n")
+				if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+					GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
+				} else {
+					GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
+				}
 			}
+
+			if lyricsMode == "embed" || lyricsMode == "both" {
+				GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+				if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+					GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					GoLog("[Amazon] Lyrics embedded successfully\n")
+				}
+			}
+		} else if req.EmbedLyrics {
+			GoLog("[Amazon] No lyrics available from parallel fetch\n")
 		}
-	} else if req.EmbedLyrics {
-		GoLog("[Amazon] No lyrics available from parallel fetch\n")
 	}
 
 	GoLog("[Amazon] Downloaded successfully from Amazon Music\n")
 
-	quality, err := GetAudioQuality(outputPath)
-	if err != nil {
-		GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+	quality := AudioQuality{}
+	if isSafOutput {
+		GoLog("[Amazon] SAF output detected - skipping post-write file inspection in backend\n")
 	} else {
-		GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
-	}
+		quality, err = GetAudioQuality(outputPath)
+		if err != nil {
+			GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+		} else {
+			GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+		}
 
-	finalMeta, metaReadErr := ReadMetadata(outputPath)
-	if metaReadErr == nil && finalMeta != nil {
-		GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
-			finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
-		actualTrackNum = finalMeta.TrackNumber
-		actualDiscNum = finalMeta.DiscNumber
-		if finalMeta.Date != "" {
-			req.ReleaseDate = finalMeta.Date
+		finalMeta, metaReadErr := ReadMetadata(outputPath)
+		if metaReadErr == nil && finalMeta != nil {
+			GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
+				finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
+			actualTrackNum = finalMeta.TrackNumber
+			actualDiscNum = finalMeta.DiscNumber
+			if finalMeta.Date != "" {
+				req.ReleaseDate = finalMeta.Date
+			}
 		}
 	}
 
 	// Add to ISRC index for fast duplicate checking
-	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	}
 
 	bitDepth := 0
 	sampleRate := 0
@@ -407,6 +490,11 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		sampleRate = quality.SampleRate
 	}
 
+	lyricsLRC := ""
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		lyricsLRC = parallelResult.LyricsLRC
+	}
+
 	return AmazonDownloadResult{
 		FilePath:    outputPath,
 		BitDepth:    bitDepth,
@@ -418,5 +506,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		TrackNumber: actualTrackNum,
 		DiscNumber:  actualDiscNum,
 		ISRC:        req.ISRC,
+		LyricsLRC:   lyricsLRC,
 	}, nil
 }

go_backend/deezer.go

@@ -23,6 +23,11 @@ const (
 	deezerCacheTTL = 10 * time.Minute
 
 	deezerMaxParallelISRC = 10
+
+	// Deezer API timeout and retry configuration for mobile networks
+	deezerAPITimeoutMobile = 25 * time.Second
+	deezerMaxRetries       = 2
+	deezerRetryDelay       = 500 * time.Millisecond
 )
 
 type DeezerClient struct {
@@ -42,7 +47,7 @@ var (
 func GetDeezerClient() *DeezerClient {
 	deezerClientOnce.Do(func() {
 		deezerClient = &DeezerClient{
-			httpClient:  NewHTTPClientWithTimeout(15 * time.Second),
+			httpClient:  NewHTTPClientWithTimeout(deezerAPITimeoutMobile),
 			searchCache: make(map[string]*cacheEntry),
 			albumCache:  make(map[string]*cacheEntry),
 			artistCache: make(map[string]*cacheEntry),
@@ -992,6 +997,42 @@ func (c *DeezerClient) GetExtendedMetadataByISRC(ctx context.Context, isrc strin
 }
 
 func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interface{}) error {
+	var lastErr error
+
+	for attempt := 0; attempt <= deezerMaxRetries; attempt++ {
+		if attempt > 0 {
+			delay := deezerRetryDelay * time.Duration(1<<(attempt-1)) // Exponential backoff
+			GoLog("[Deezer] Retry %d/%d after %v...\n", attempt, deezerMaxRetries, delay)
+			time.Sleep(delay)
+		}
+
+		err := c.doGetJSON(ctx, endpoint, dst)
+		if err == nil {
+			return nil
+		}
+
+		lastErr = err
+		errStr := err.Error()
+
+		// Check if error is retryable
+		isRetryable := strings.Contains(errStr, "timeout") ||
+			strings.Contains(errStr, "connection reset") ||
+			strings.Contains(errStr, "connection refused") ||
+			strings.Contains(errStr, "EOF") ||
+			strings.Contains(errStr, "status 5") ||
+			strings.Contains(errStr, "status 429")
+
+		if !isRetryable {
+			return err
+		}
+
+		GoLog("[Deezer] Attempt %d failed (retryable): %v\n", attempt+1, err)
+	}
+
+	return fmt.Errorf("all %d attempts failed: %w", deezerMaxRetries+1, lastErr)
+}
+
+func (c *DeezerClient) doGetJSON(ctx context.Context, endpoint string, dst interface{}) error {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return err

go_backend/exports.go

@@ -128,6 +128,9 @@ type DownloadRequest struct {
 	AlbumArtist          string `json:"album_artist"`
 	CoverURL             string `json:"cover_url"`
 	OutputDir            string `json:"output_dir"`
+	OutputPath           string `json:"output_path,omitempty"`
+	OutputFD             int    `json:"output_fd,omitempty"`
+	OutputExt            string `json:"output_ext,omitempty"`
 	FilenameFormat       string `json:"filename_format"`
 	Quality              string `json:"quality"`
 	EmbedLyrics          bool   `json:"embed_lyrics"`
@@ -199,8 +202,10 @@ func DownloadTrack(requestJSON string) (string, error) {
 	req.AlbumName = strings.TrimSpace(req.AlbumName)
 	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
+	req.OutputPath = strings.TrimSpace(req.OutputPath)
+	req.OutputExt = strings.TrimSpace(req.OutputExt)
 
-	if req.OutputDir != "" {
+	if req.OutputPath == "" && req.OutputFD <= 0 && req.OutputDir != "" {
 		AddAllowedDownloadDir(req.OutputDir)
 	}
 
@@ -240,6 +245,7 @@ func DownloadTrack(requestJSON string) (string, error) {
 				TrackNumber: qobuzResult.TrackNumber,
 				DiscNumber:  qobuzResult.DiscNumber,
 				ISRC:        qobuzResult.ISRC,
+				LyricsLRC:   qobuzResult.LyricsLRC,
 			}
 		}
 		err = qobuzErr
@@ -257,6 +263,7 @@ func DownloadTrack(requestJSON string) (string, error) {
 				TrackNumber: amazonResult.TrackNumber,
 				DiscNumber:  amazonResult.DiscNumber,
 				ISRC:        amazonResult.ISRC,
+				LyricsLRC:   amazonResult.LyricsLRC,
 			}
 		}
 		err = amazonErr
@@ -336,8 +343,10 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 	req.AlbumName = strings.TrimSpace(req.AlbumName)
 	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
+	req.OutputPath = strings.TrimSpace(req.OutputPath)
+	req.OutputExt = strings.TrimSpace(req.OutputExt)
 
-	if req.OutputDir != "" {
+	if req.OutputPath == "" && req.OutputFD <= 0 && req.OutputDir != "" {
 		AddAllowedDownloadDir(req.OutputDir)
 	}
 
@@ -402,6 +411,7 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 					TrackNumber: qobuzResult.TrackNumber,
 					DiscNumber:  qobuzResult.DiscNumber,
 					ISRC:        qobuzResult.ISRC,
+					LyricsLRC:   qobuzResult.LyricsLRC,
 				}
 			} else if !errors.Is(qobuzErr, ErrDownloadCancelled) {
 				GoLog("[DownloadWithFallback] Qobuz error: %v\n", qobuzErr)
@@ -421,6 +431,7 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 					TrackNumber: amazonResult.TrackNumber,
 					DiscNumber:  amazonResult.DiscNumber,
 					ISRC:        amazonResult.ISRC,
+					LyricsLRC:   amazonResult.LyricsLRC,
 				}
 			} else if !errors.Is(amazonErr, ErrDownloadCancelled) {
 				GoLog("[DownloadWithFallback] Amazon error: %v\n", amazonErr)
@@ -569,6 +580,14 @@ func SetDownloadDirectory(path string) error {
 	return setDownloadDir(path)
 }
 
+// AllowDownloadDir adds a directory to the extension file sandbox allowlist.
+func AllowDownloadDir(path string) {
+	if strings.TrimSpace(path) == "" {
+		return
+	}
+	AddAllowedDownloadDir(path)
+}
+
 func CheckDuplicate(outputDir, isrc string) (string, error) {
 	existingFile, exists := CheckISRCExists(outputDir, isrc)
 
@@ -1260,6 +1279,17 @@ func DownloadWithExtensionsJSON(requestJSON string) (string, error) {
 		return "", fmt.Errorf("invalid request: %w", err)
 	}
 
+	req.TrackName = strings.TrimSpace(req.TrackName)
+	req.ArtistName = strings.TrimSpace(req.ArtistName)
+	req.AlbumName = strings.TrimSpace(req.AlbumName)
+	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
+	req.OutputDir = strings.TrimSpace(req.OutputDir)
+	req.OutputPath = strings.TrimSpace(req.OutputPath)
+	req.OutputExt = strings.TrimSpace(req.OutputExt)
+	if req.OutputPath == "" && req.OutputFD <= 0 && req.OutputDir != "" {
+		AddAllowedDownloadDir(req.OutputDir)
+	}
+
 	result, err := DownloadWithExtensionFallback(req)
 	if err != nil {
 		return "", err
@@ -1958,6 +1988,35 @@ func RunPostProcessingJSON(filePath, metadataJSON string) (string, error) {
 	return string(jsonBytes), nil
 }
 
+func RunPostProcessingV2JSON(inputJSON, metadataJSON string) (string, error) {
+	var metadata map[string]interface{}
+	if metadataJSON != "" {
+		if err := json.Unmarshal([]byte(metadataJSON), &metadata); err != nil {
+			metadata = make(map[string]interface{})
+		}
+	}
+
+	var input PostProcessInput
+	if inputJSON != "" {
+		if err := json.Unmarshal([]byte(inputJSON), &input); err != nil {
+			input = PostProcessInput{}
+		}
+	}
+
+	manager := GetExtensionManager()
+	result, err := manager.RunPostProcessingV2(input, metadata)
+	if err != nil {
+		return "", err
+	}
+
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+
+	return string(jsonBytes), nil
+}
+
 func GetPostProcessingProvidersJSON() (string, error) {
 	manager := GetExtensionManager()
 	providers := manager.GetPostProcessingProviders()

go_backend/extension_providers.go

@@ -1123,6 +1123,10 @@ func tryBuiltInProvider(providerID string, req DownloadRequest) (*DownloadRespon
 }
 
 func buildOutputPath(req DownloadRequest) string {
+	if strings.TrimSpace(req.OutputPath) != "" {
+		return strings.TrimSpace(req.OutputPath)
+	}
+
 	metadata := map[string]interface{}{
 		"title":        req.TrackName,
 		"artist":       req.ArtistName,
@@ -1138,7 +1142,14 @@ func buildOutputPath(req DownloadRequest) string {
 		filename = sanitizeFilename(fmt.Sprintf("%s - %s", req.ArtistName, req.TrackName))
 	}
 
-	return fmt.Sprintf("%s/%s.flac", req.OutputDir, filename)
+	ext := strings.TrimSpace(req.OutputExt)
+	if ext == "" {
+		ext = ".flac"
+	} else if !strings.HasPrefix(ext, ".") {
+		ext = "." + ext
+	}
+
+	return fmt.Sprintf("%s/%s%s", req.OutputDir, filename, ext)
 }
 
 func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string]interface{}) ([]ExtTrackMetadata, error) {
@@ -1340,11 +1351,21 @@ func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}
 type PostProcessResult struct {
 	Success     bool   `json:"success"`
 	NewFilePath string `json:"new_file_path,omitempty"`
+	NewFileURI  string `json:"new_file_uri,omitempty"`
 	Error       string `json:"error,omitempty"`
 	BitDepth    int    `json:"bit_depth,omitempty"`
 	SampleRate  int    `json:"sample_rate,omitempty"`
 }
 
+type PostProcessInput struct {
+	Path    string `json:"path,omitempty"`
+	URI     string `json:"uri,omitempty"`
+	Name    string `json:"name,omitempty"`
+	MimeType string `json:"mime_type,omitempty"`
+	Size    int64  `json:"size,omitempty"`
+	IsSAF   bool   `json:"is_saf,omitempty"`
+}
+
 const PostProcessTimeout = 2 * time.Minute
 
 func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[string]interface{}, hookID string) (*PostProcessResult, error) {
@@ -1409,6 +1430,75 @@ func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[str
 	return &postResult, nil
 }
 
+func (p *ExtensionProviderWrapper) PostProcessV2(input PostProcessInput, metadata map[string]interface{}, hookID string) (*PostProcessResult, error) {
+	if !p.extension.Manifest.HasPostProcessing() {
+		return nil, fmt.Errorf("extension '%s' does not support post-processing", p.extension.ID)
+	}
+
+	if !p.extension.Enabled {
+		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
+	}
+
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
+	metadataJSON, _ := json.Marshal(metadata)
+	inputJSON, _ := json.Marshal(input)
+	filePath := input.Path
+
+	script := fmt.Sprintf(`
+		(function() {
+			if (typeof extension !== 'undefined') {
+				if (typeof extension.postProcessV2 === 'function') {
+					return extension.postProcessV2(%s, %s, %q);
+				}
+				if (typeof extension.postProcess === 'function') {
+					return extension.postProcess(%q, %s, %q);
+				}
+			}
+			return null;
+		})()
+	`, string(inputJSON), string(metadataJSON), hookID, filePath, string(metadataJSON), hookID)
+
+	result, err := RunWithTimeoutAndRecover(p.vm, script, PostProcessTimeout)
+	if err != nil {
+		errMsg := err.Error()
+		if IsTimeoutError(err) {
+			errMsg = "postProcess timeout: extension took too long to complete"
+		}
+		return &PostProcessResult{
+			Success: false,
+			Error:   errMsg,
+		}, nil
+	}
+
+	if result == nil || goja.IsUndefined(result) || goja.IsNull(result) {
+		return &PostProcessResult{
+			Success: false,
+			Error:   "postProcess returned null",
+		}, nil
+	}
+
+	exported := result.Export()
+	jsonBytes, err := json.Marshal(exported)
+	if err != nil {
+		return &PostProcessResult{
+			Success: false,
+			Error:   fmt.Sprintf("failed to marshal result: %v", err),
+		}, nil
+	}
+
+	var postResult PostProcessResult
+	if err := json.Unmarshal(jsonBytes, &postResult); err != nil {
+		return &PostProcessResult{
+			Success: false,
+			Error:   fmt.Sprintf("failed to parse result: %v", err),
+		}, nil
+	}
+
+	return &postResult, nil
+}
+
 func (m *ExtensionManager) GetSearchProviders() []*ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -1531,3 +1621,58 @@ func (m *ExtensionManager) RunPostProcessing(filePath string, metadata map[strin
 
 	return &PostProcessResult{Success: true, NewFilePath: currentPath}, nil
 }
+
+// RunPostProcessingV2 runs all enabled post-processing hooks on a file input.
+func (m *ExtensionManager) RunPostProcessingV2(input PostProcessInput, metadata map[string]interface{}) (*PostProcessResult, error) {
+	providers := m.GetPostProcessingProviders()
+	if len(providers) == 0 {
+		return &PostProcessResult{Success: true, NewFilePath: input.Path, NewFileURI: input.URI}, nil
+	}
+
+	currentInput := input
+	for _, provider := range providers {
+		hooks := provider.extension.Manifest.GetPostProcessingHooks()
+		for _, hook := range hooks {
+			if !hook.DefaultEnabled {
+				continue
+			}
+
+			ext := strings.ToLower(filepath.Ext(currentInput.Path))
+			if ext == "" && currentInput.Name != "" {
+				ext = strings.ToLower(filepath.Ext(currentInput.Name))
+			}
+			if len(hook.SupportedFormats) > 0 && ext != "" {
+				supported := false
+				for _, format := range hook.SupportedFormats {
+					if "."+format == ext || format == ext[1:] {
+						supported = true
+						break
+					}
+				}
+				if !supported {
+					continue
+				}
+			}
+
+			GoLog("[PostProcessV2] Running hook %s from %s on %s\n", hook.ID, provider.extension.ID, currentInput.Path)
+
+			result, err := provider.PostProcessV2(currentInput, metadata, hook.ID)
+			if err != nil {
+				GoLog("[PostProcessV2] Hook %s failed: %v\n", hook.ID, err)
+				continue
+			}
+
+			if result.Success && result.NewFilePath != "" {
+				currentInput.Path = result.NewFilePath
+				if currentInput.Name == "" {
+					currentInput.Name = filepath.Base(result.NewFilePath)
+				}
+			}
+			if result.Success && result.NewFileURI != "" {
+				currentInput.URI = result.NewFileURI
+			}
+		}
+	}
+
+	return &PostProcessResult{Success: true, NewFilePath: currentInput.Path, NewFileURI: currentInput.URI}, nil
+}

go_backend/output_fd.go

@@ -0,0 +1,31 @@
+package gobackend
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func isFDOutput(outputFD int) bool {
+	return outputFD > 0
+}
+
+func openOutputForWrite(outputPath string, outputFD int) (*os.File, error) {
+	if isFDOutput(outputFD) {
+		return os.NewFile(uintptr(outputFD), fmt.Sprintf("saf_fd_%d", outputFD)), nil
+	}
+	return os.Create(outputPath)
+}
+
+func cleanupOutputOnError(outputPath string, outputFD int) {
+	if isFDOutput(outputFD) {
+		return
+	}
+
+	path := strings.TrimSpace(outputPath)
+	if path == "" || strings.HasPrefix(path, "/proc/self/fd/") {
+		return
+	}
+
+	_ = os.Remove(path)
+}

go_backend/parallel.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"encoding/json"
 	"fmt"
 	"sync"
 	"time"
@@ -9,7 +10,7 @@ import (
 type TrackIDCacheEntry struct {
 	TidalTrackID  int64
 	QobuzTrackID  int64
-	AmazonTrackID string
+	AmazonURL     string
 	ExpiresAt     time.Time
 }
 
@@ -106,7 +107,7 @@ func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
 	}
 }
 
-func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
+func (c *TrackIDCache) SetAmazonURL(isrc string, amazonURL string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
@@ -115,7 +116,7 @@ func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
 		entry = &TrackIDCacheEntry{}
 		c.cache[isrc] = entry
 	}
-	entry.AmazonTrackID = trackID
+	entry.AmazonURL = amazonURL
 	now := time.Now()
 	entry.ExpiresAt = now.Add(c.ttl)
 
@@ -156,17 +157,20 @@ func FetchCoverAndLyricsParallel(
 ) *ParallelDownloadResult {
 	result := &ParallelDownloadResult{}
 	var wg sync.WaitGroup
+	var resultMu sync.Mutex
 
 	if coverURL != "" {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			data, err := downloadCoverToMemory(coverURL, maxQualityCover)
+			resultMu.Lock()
 			if err != nil {
 				result.CoverErr = err
 			} else {
 				result.CoverData = data
 			}
+			resultMu.Unlock()
 		}()
 	}
 
@@ -177,6 +181,7 @@ func FetchCoverAndLyricsParallel(
 			client := NewLyricsClient()
 			durationSec := float64(durationMs) / 1000.0
 			lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName, durationSec)
+			resultMu.Lock()
 			if err != nil {
 				result.LyricsErr = err
 			} else if lyrics != nil && len(lyrics.Lines) > 0 {
@@ -185,6 +190,7 @@ func FetchCoverAndLyricsParallel(
 			} else {
 				result.LyricsErr = fmt.Errorf("no lyrics found")
 			}
+			resultMu.Unlock()
 		}()
 	}
 
@@ -211,6 +217,9 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	var wg sync.WaitGroup
 
 	for _, req := range requests {
+		if req.ISRC == "" {
+			continue
+		}
 		if cached := cache.Get(req.ISRC); cached != nil {
 			continue
 		}
@@ -225,7 +234,7 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 			case "tidal":
 				preWarmTidalCache(r.ISRC, r.TrackName, r.ArtistName)
 			case "qobuz":
-				preWarmQobuzCache(r.ISRC)
+				preWarmQobuzCache(r.ISRC, r.SpotifyID)
 			case "amazon":
 				preWarmAmazonCache(r.ISRC, r.SpotifyID)
 			}
@@ -243,10 +252,30 @@ func preWarmTidalCache(isrc, _, _ string) {
 	}
 }
 
-func preWarmQobuzCache(isrc string) {
+// preWarmQobuzCache tries to get Qobuz Track ID in the following order:
+// 1. From SongLink (fast, no Qobuz API call needed)
+// 2. Direct ISRC search on Qobuz API (slower, may fail if ISRC not in Qobuz database)
+func preWarmQobuzCache(isrc, spotifyID string) {
+	// First, try to get QobuzID from SongLink - this is faster and more reliable
+	if spotifyID != "" {
+		client := NewSongLinkClient()
+		availability, err := client.CheckTrackAvailability(spotifyID, isrc)
+		if err == nil && availability != nil && availability.QobuzID != "" {
+			// Parse QobuzID to int64
+			var trackID int64
+			if _, parseErr := fmt.Sscanf(availability.QobuzID, "%d", &trackID); parseErr == nil && trackID > 0 {
+				GoLog("[Qobuz] Pre-warm cache: Got Qobuz ID %d from SongLink for ISRC %s\n", trackID, isrc)
+				GetTrackIDCache().SetQobuz(isrc, trackID)
+				return
+			}
+		}
+	}
+
+	// Fallback: Direct ISRC search on Qobuz API
 	downloader := NewQobuzDownloader()
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
+		GoLog("[Qobuz] Pre-warm cache: Got Qobuz ID %d from direct ISRC search for %s\n", track.ID, isrc)
 		GetTrackIDCache().SetQobuz(isrc, track.ID)
 	}
 }
@@ -254,13 +283,34 @@ func preWarmQobuzCache(isrc string) {
 func preWarmAmazonCache(isrc, spotifyID string) {
 	client := NewSongLinkClient()
 	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
-	if err == nil && availability != nil && availability.Amazon {
-		GetTrackIDCache().SetAmazon(isrc, availability.AmazonURL)
+	if err == nil && availability != nil && availability.AmazonURL != "" {
+		GetTrackIDCache().SetAmazonURL(isrc, availability.AmazonURL)
 	}
 }
 
 func PreWarmCache(tracksJSON string) error {
-	var requests []PreWarmCacheRequest
+	var tracks []struct {
+		ISRC       string `json:"isrc"`
+		TrackName  string `json:"track_name"`
+		ArtistName string `json:"artist_name"`
+		SpotifyID  string `json:"spotify_id"`
+		Service    string `json:"service"`
+	}
+
+	if err := json.Unmarshal([]byte(tracksJSON), &tracks); err != nil {
+		return fmt.Errorf("failed to parse tracks JSON: %w", err)
+	}
+
+	requests := make([]PreWarmCacheRequest, len(tracks))
+	for i, t := range tracks {
+		requests[i] = PreWarmCacheRequest{
+			ISRC:       t.ISRC,
+			TrackName:  t.TrackName,
+			ArtistName: t.ArtistName,
+			SpotifyID:  t.SpotifyID,
+			Service:    t.Service,
+		}
+	}
 
 	go PreWarmTrackCache(requests)
 	return nil

go_backend/qobuz.go

@@ -380,6 +380,42 @@ func decodeXOR(data []byte) string {
 	return string(result)
 }
 
+func extractQobuzDownloadURLFromBody(body []byte) (string, error) {
+	var raw map[string]any
+	if err := json.Unmarshal(body, &raw); err != nil {
+		return "", fmt.Errorf("invalid JSON: %v", err)
+	}
+
+	if errMsg, ok := raw["error"].(string); ok && strings.TrimSpace(errMsg) != "" {
+		return "", fmt.Errorf("%s", errMsg)
+	}
+
+	if success, ok := raw["success"].(bool); ok && !success {
+		if msg, ok := raw["message"].(string); ok && strings.TrimSpace(msg) != "" {
+			return "", fmt.Errorf("%s", msg)
+		}
+		return "", fmt.Errorf("api returned success=false")
+	}
+
+	if urlVal, ok := raw["url"].(string); ok && strings.TrimSpace(urlVal) != "" {
+		return strings.TrimSpace(urlVal), nil
+	}
+	if linkVal, ok := raw["link"].(string); ok && strings.TrimSpace(linkVal) != "" {
+		return strings.TrimSpace(linkVal), nil
+	}
+
+	if data, ok := raw["data"].(map[string]any); ok {
+		if urlVal, ok := data["url"].(string); ok && strings.TrimSpace(urlVal) != "" {
+			return strings.TrimSpace(urlVal), nil
+		}
+		if linkVal, ok := data["link"].(string); ok && strings.TrimSpace(linkVal) != "" {
+			return strings.TrimSpace(linkVal), nil
+		}
+	}
+
+	return "", fmt.Errorf("no download URL in response")
+}
+
 func (q *QobuzDownloader) downloadFromJumo(trackID int64, quality string) (string, error) {
 	formatID := mapJumoQuality(quality)
 	region := "US"
@@ -725,75 +761,126 @@ type qobuzAPIResult struct {
 	duration    time.Duration
 }
 
+// Qobuz API timeout configuration
+// Mobile networks are more unstable, so we use longer timeouts
+const (
+	qobuzAPITimeoutDesktop = 15 * time.Second
+	qobuzAPITimeoutMobile  = 25 * time.Second
+	qobuzMaxRetries        = 2 // Number of retries per API
+	qobuzRetryDelay        = 500 * time.Millisecond
+)
+
+// getQobuzAPITimeout returns appropriate timeout based on platform
+// For mobile (gomobile builds), we use longer timeouts
+func getQobuzAPITimeout() time.Duration {
+	// Since this runs in gomobile context, we always use mobile timeout
+	// The Go backend is only used on mobile (Android/iOS)
+	return qobuzAPITimeoutMobile
+}
+
+// fetchQobuzURLWithRetry fetches download URL from a single Qobuz API with retry logic
+func fetchQobuzURLWithRetry(api string, trackID int64, quality string, timeout time.Duration) (string, error) {
+	var lastErr error
+	retryDelay := qobuzRetryDelay
+
+	for attempt := 0; attempt <= qobuzMaxRetries; attempt++ {
+		if attempt > 0 {
+			GoLog("[Qobuz] Retry %d/%d for %s after %v\n", attempt, qobuzMaxRetries, api, retryDelay)
+			time.Sleep(retryDelay)
+			retryDelay *= 2 // Exponential backoff
+		}
+
+		client := NewHTTPClientWithTimeout(timeout)
+		reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			lastErr = err
+			// Check for retryable errors (timeout, connection reset)
+			errStr := strings.ToLower(err.Error())
+			if strings.Contains(errStr, "timeout") ||
+				strings.Contains(errStr, "reset") ||
+				strings.Contains(errStr, "connection refused") ||
+				strings.Contains(errStr, "eof") {
+				continue // Retry
+			}
+			break // Non-retryable error
+		}
+		// Server errors are retryable
+		if resp.StatusCode >= 500 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("HTTP %d", resp.StatusCode)
+			continue
+		}
+
+		// 429 rate limit - wait and retry
+		if resp.StatusCode == 429 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("rate limited")
+			retryDelay = 2 * time.Second // Wait longer for rate limit
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			return "", fmt.Errorf("HTTP %d", resp.StatusCode)
+		}
+
+		body, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		if len(body) > 0 && body[0] == '<' {
+			return "", fmt.Errorf("received HTML instead of JSON")
+		}
+
+		urlVal, parseErr := extractQobuzDownloadURLFromBody(body)
+		if parseErr == nil {
+			return urlVal, nil
+		}
+		lastErr = parseErr
+		continue
+	}
+
+	if lastErr != nil {
+		return "", lastErr
+	}
+	return "", fmt.Errorf("all retries failed")
+}
+
 func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (string, string, error) {
 	if len(apis) == 0 {
 		return "", "", fmt.Errorf("no APIs available")
 	}
 
-	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel...\n", len(apis))
+	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel (with retry)...\n", len(apis))
 
 	resultChan := make(chan qobuzAPIResult, len(apis))
 	startTime := time.Now()
+	timeout := getQobuzAPITimeout()
 
 	for _, apiURL := range apis {
 		go func(api string) {
 			reqStart := time.Now()
-
-			client := NewHTTPClientWithTimeout(15 * time.Second)
-
-			reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
-
-			req, err := http.NewRequest("GET", reqURL, nil)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
+			downloadURL, err := fetchQobuzURLWithRetry(api, trackID, quality, timeout)
+			resultChan <- qobuzAPIResult{
+				apiURL:      api,
+				downloadURL: downloadURL,
+				err:         err,
+				duration:    time.Since(reqStart),
 			}
-
-			resp, err := client.Do(req)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-			defer resp.Body.Close()
-
-			if resp.StatusCode != 200 {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
-				return
-			}
-
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-
-			if len(body) > 0 && body[0] == '<' {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("received HTML instead of JSON"), duration: time.Since(reqStart)}
-				return
-			}
-
-			var errorResp struct {
-				Error string `json:"error"`
-			}
-			if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("%s", errorResp.Error), duration: time.Since(reqStart)}
-				return
-			}
-
-			var result struct {
-				URL string `json:"url"`
-			}
-			if err := json.Unmarshal(body, &result); err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("invalid JSON: %v", err), duration: time.Since(reqStart)}
-				return
-			}
-
-			if result.URL != "" {
-				resultChan <- qobuzAPIResult{apiURL: api, downloadURL: result.URL, err: nil, duration: time.Since(reqStart)}
-				return
-			}
-
-			resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("no download URL in response"), duration: time.Since(reqStart)}
 		}(apiURL)
 	}
 
@@ -860,7 +947,7 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string,
 	return "", fmt.Errorf("all Qobuz APIs and Jumo fallback failed: %w", err)
 }
 
-func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()
 
 	if itemID != "" {
@@ -897,7 +984,7 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		SetItemBytesTotal(itemID, expectedSize)
 	}
 
-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -916,23 +1003,23 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	closeErr := out.Close()
 
 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}
 
 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}
 
@@ -950,13 +1037,17 @@ type QobuzDownloadResult struct {
 	TrackNumber int
 	DiscNumber  int
 	ISRC        string
+	LyricsLRC   string
 }
 
 func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	downloader := NewQobuzDownloader()
 
-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
 	}
 
 	expectedDurationSec := req.DurationMS / 1000
@@ -964,6 +1055,7 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	var track *QobuzTrack
 	var err error
 
+	// Strategy 1: Use Qobuz ID from Odesli enrichment (fastest, most accurate)
 	if req.QobuzID != "" {
 		GoLog("[Qobuz] Using Qobuz ID from Odesli enrichment: %s\n", req.QobuzID)
 		var trackID int64
@@ -978,17 +1070,43 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		}
 	}
 
+	// Strategy 2: Use cached Qobuz Track ID (fast, no search needed)
 	if track == nil && req.ISRC != "" {
 		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.QobuzTrackID > 0 {
 			GoLog("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
-			track, err = downloader.SearchTrackByISRC(req.ISRC)
+			track, err = downloader.GetTrackByID(cached.QobuzTrackID)
 			if err != nil {
-				GoLog("[Qobuz] Cache hit but search failed: %v\n", err)
+				GoLog("[Qobuz] Cache hit but GetTrackByID failed: %v\n", err)
 				track = nil
 			}
 		}
 	}
 
+	// Strategy 3: Try to get QobuzID from SongLink if we have SpotifyID
+	if track == nil && req.SpotifyID != "" && req.QobuzID == "" {
+		GoLog("[Qobuz] Trying to get Qobuz ID from SongLink for Spotify ID: %s\n", req.SpotifyID)
+		songLinkClient := NewSongLinkClient()
+		availability, slErr := songLinkClient.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+		if slErr == nil && availability != nil && availability.QobuzID != "" {
+			var trackID int64
+			if _, parseErr := fmt.Sscanf(availability.QobuzID, "%d", &trackID); parseErr == nil && trackID > 0 {
+				GoLog("[Qobuz] Got Qobuz ID %d from SongLink\n", trackID)
+				track, err = downloader.GetTrackByID(trackID)
+				if err != nil {
+					GoLog("[Qobuz] Failed to get track by SongLink ID %d: %v\n", trackID, err)
+					track = nil
+				} else if track != nil {
+					GoLog("[Qobuz] Successfully found track via SongLink ID: '%s' by '%s'\n", track.Title, track.Performer.Name)
+					// Cache for future use
+					if req.ISRC != "" {
+						GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
+					}
+				}
+			}
+		}
+	}
+
+	// Strategy 4: ISRC search with duration verification
 	if track == nil && req.ISRC != "" {
 		GoLog("[Qobuz] Trying ISRC search: %s\n", req.ISRC)
 		track, err = downloader.SearchTrackByISRCWithDuration(req.ISRC, expectedDurationSec)
@@ -1005,7 +1123,9 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		}
 	}
 
+	// Strategy 5: Metadata search with strict matching (duration tolerance: 10 seconds)
 	if track == nil {
+		GoLog("[Qobuz] Trying metadata search: '%s' by '%s'\n", req.TrackName, req.ArtistName)
 		track, err = downloader.SearchTrackByMetadataWithDuration(req.TrackName, req.ArtistName, expectedDurationSec)
 		if track != nil && !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
 			GoLog("[Qobuz] Artist mismatch from metadata search: expected '%s', got '%s'. Rejecting.\n",
@@ -1035,11 +1155,18 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		"year":   extractYear(req.ReleaseDate),
 		"disc":   req.DiscNumber,
 	})
-	filename = sanitizeFilename(filename) + ".flac"
-	outputPath := filepath.Join(req.OutputDir, filename)
-
-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+	var outputPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+	} else {
+		filename = sanitizeFilename(filename) + ".flac"
+		outputPath = filepath.Join(req.OutputDir, filename)
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
 	}
 
 	qobuzQuality := "27"
@@ -1077,7 +1204,7 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		)
 	}()
 
-	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadURL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return QobuzDownloadResult{}, ErrDownloadCancelled
 		}
@@ -1122,39 +1249,50 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		GoLog("[Qobuz] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
-	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
-		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+	if isSafOutput {
+		GoLog("[Qobuz] SAF output detected - skipping in-backend metadata/lyrics embedding (handled in Flutter)\n")
+	} else {
+		if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+		}
+
+		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+			lyricsMode := req.LyricsMode
+			if lyricsMode == "" {
+				lyricsMode = "embed"
+			}
+
+			if lyricsMode == "external" || lyricsMode == "both" {
+				GoLog("[Qobuz] Saving external LRC file...\n")
+				if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+					GoLog("[Qobuz] Warning: failed to save LRC file: %v\n", lrcErr)
+				} else {
+					GoLog("[Qobuz] LRC file saved: %s\n", lrcPath)
+				}
+			}
+
+			if lyricsMode == "embed" || lyricsMode == "both" {
+				GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+				if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+					GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					fmt.Println("[Qobuz] Lyrics embedded successfully")
+				}
+			}
+		} else if req.EmbedLyrics {
+			fmt.Println("[Qobuz] No lyrics available from parallel fetch")
+		}
 	}
 
+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	}
+
+	lyricsLRC := ""
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		lyricsMode := req.LyricsMode
-		if lyricsMode == "" {
-			lyricsMode = "embed"
-		}
-
-		if lyricsMode == "external" || lyricsMode == "both" {
-			GoLog("[Qobuz] Saving external LRC file...\n")
-			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
-				GoLog("[Qobuz] Warning: failed to save LRC file: %v\n", lrcErr)
-			} else {
-				GoLog("[Qobuz] LRC file saved: %s\n", lrcPath)
-			}
-		}
-
-		if lyricsMode == "embed" || lyricsMode == "both" {
-			GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-				GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Qobuz] Lyrics embedded successfully")
-			}
-		}
-	} else if req.EmbedLyrics {
-		fmt.Println("[Qobuz] No lyrics available from parallel fetch")
+		lyricsLRC = parallelResult.LyricsLRC
 	}
 
-	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
-
 	return QobuzDownloadResult{
 		FilePath:    outputPath,
 		BitDepth:    actualBitDepth,
@@ -1166,5 +1304,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		TrackNumber: actualTrackNumber,
 		DiscNumber:  req.DiscNumber,
 		ISRC:        track.ISRC,
+		LyricsLRC:   lyricsLRC,
 	}, nil
 }

go_backend/qobuz_test.go

@@ -0,0 +1,47 @@
+package gobackend
+
+import "testing"
+
+func TestExtractQobuzDownloadURLFromBody(t *testing.T) {
+	t.Run("reads nested data.url", func(t *testing.T) {
+		body := []byte(`{"success":true,"data":{"url":"https://example.test/audio.flac"}}`)
+
+		got, err := extractQobuzDownloadURLFromBody(body)
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+		if got != "https://example.test/audio.flac" {
+			t.Fatalf("unexpected URL: %q", got)
+		}
+	})
+
+	t.Run("reads top-level url", func(t *testing.T) {
+		body := []byte(`{"url":"https://example.test/top.flac"}`)
+
+		got, err := extractQobuzDownloadURLFromBody(body)
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+		if got != "https://example.test/top.flac" {
+			t.Fatalf("unexpected URL: %q", got)
+		}
+	})
+
+	t.Run("returns API error", func(t *testing.T) {
+		body := []byte(`{"error":"track not found"}`)
+
+		_, err := extractQobuzDownloadURLFromBody(body)
+		if err == nil || err.Error() != "track not found" {
+			t.Fatalf("expected track-not-found error, got %v", err)
+		}
+	})
+
+	t.Run("returns message when success false", func(t *testing.T) {
+		body := []byte(`{"success":false,"message":"blocked"}`)
+
+		_, err := extractQobuzDownloadURLFromBody(body)
+		if err == nil || err.Error() != "blocked" {
+			t.Fatalf("expected blocked error, got %v", err)
+		}
+	})
+}

go_backend/songlink.go

@@ -8,7 +8,6 @@ import (
 	"net/url"
 	"strings"
 	"sync"
-	"time"
 )
 
 type SongLinkClient struct {
@@ -26,6 +25,8 @@ type TrackAvailability struct {
 	QobuzURL  string `json:"qobuz_url,omitempty"`
 	DeezerURL string `json:"deezer_url,omitempty"`
 	DeezerID  string `json:"deezer_id,omitempty"`
+	QobuzID   string `json:"qobuz_id,omitempty"`
+	TidalID   string `json:"tidal_id,omitempty"`
 }
 
 var (
@@ -98,6 +99,7 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}
 
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -111,6 +113,12 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 
+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
 	return availability, nil
 }
 
@@ -131,40 +139,6 @@ func (s *SongLinkClient) GetStreamingURLs(spotifyTrackID string) (map[string]str
 	return urls, nil
 }
 
-func checkQobuzAvailability(isrc string) bool {
-	client := NewHTTPClientWithTimeout(10 * time.Second)
-	appID := "798273057"
-
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
-	searchURL := fmt.Sprintf("%s%s&limit=1&app_id=%s", string(apiBase), isrc, appID)
-
-	req, err := http.NewRequest("GET", searchURL, nil)
-	if err != nil {
-		return false
-	}
-
-	resp, err := DoRequestWithUserAgent(client, req)
-	if err != nil {
-		return false
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return false
-	}
-
-	var searchResp struct {
-		Tracks struct {
-			Total int `json:"total"`
-		} `json:"tracks"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
-		return false
-	}
-
-	return searchResp.Tracks.Total > 0
-}
-
 // extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
 func extractDeezerIDFromURL(deezerURL string) string {
 	parts := strings.Split(deezerURL, "/")
@@ -178,6 +152,102 @@ func extractDeezerIDFromURL(deezerURL string) string {
 	return ""
 }
 
+// extractQobuzIDFromURL extracts Qobuz track ID from URL
+// URL formats:
+//   - https://www.qobuz.com/us-en/album/.../12345678 (album page with track highlight)
+//   - https://open.qobuz.com/track/12345678
+//   - https://www.qobuz.com/track/12345678
+//   - https://play.qobuz.com/track/12345678
+func extractQobuzIDFromURL(qobuzURL string) string {
+	if qobuzURL == "" {
+		return ""
+	}
+
+	// Try to find /track/ID pattern first
+	if strings.Contains(qobuzURL, "/track/") {
+		parts := strings.Split(qobuzURL, "/track/")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			// Remove query parameters
+			if idx := strings.Index(idPart, "?"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			// Remove trailing slash or path
+			if idx := strings.Index(idPart, "/"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			// Validate it's a number
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	// Try to extract from album URL with track highlight
+	// Format: /album/albumname/trackid or ?trackId=12345678
+	if strings.Contains(qobuzURL, "trackId=") {
+		parts := strings.Split(qobuzURL, "trackId=")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			if idx := strings.Index(idPart, "&"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	// Last resort: get last numeric segment from URL
+	parts := strings.Split(qobuzURL, "/")
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		// Remove query parameters
+		if idx := strings.Index(part, "?"); idx > 0 {
+			part = part[:idx]
+		}
+		part = strings.TrimSpace(part)
+		if part != "" && isNumeric(part) {
+			return part
+		}
+	}
+
+	return ""
+}
+
+// extractTidalIDFromURL extracts Tidal track ID from URL
+// URL formats:
+//   - https://tidal.com/browse/track/12345678
+//   - https://listen.tidal.com/track/12345678
+func extractTidalIDFromURL(tidalURL string) string {
+	if tidalURL == "" {
+		return ""
+	}
+
+	if strings.Contains(tidalURL, "/track/") {
+		parts := strings.Split(tidalURL, "/track/")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			if idx := strings.Index(idPart, "?"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			if idx := strings.Index(idPart, "/"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	return ""
+}
+
+// isNumeric is defined in library_scan.go
+
 func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
@@ -353,6 +423,7 @@ func (s *SongLinkClient) checkAvailabilityFromDeezerSongLink(deezerTrackID strin
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}
 
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -360,6 +431,12 @@ func (s *SongLinkClient) checkAvailabilityFromDeezerSongLink(deezerTrackID strin
 		availability.AmazonURL = amazonLink.URL
 	}
 
+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.DeezerURL = deezerLink.URL
 	}
@@ -431,6 +508,7 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}
 
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -438,6 +516,12 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 		availability.AmazonURL = amazonLink.URL
 	}
 
+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
@@ -552,6 +636,7 @@ func (s *SongLinkClient) CheckAvailabilityFromURL(inputURL string) (*TrackAvaila
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
@@ -560,6 +645,7 @@ func (s *SongLinkClient) CheckAvailabilityFromURL(inputURL string) (*TrackAvaila
 	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
 		availability.Qobuz = true
 		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
 	}
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true

go_backend/tidal.go

@@ -582,12 +582,123 @@ type tidalAPIResult struct {
 	duration time.Duration
 }
 
+// Tidal API timeout configuration
+// Mobile networks are more unstable, so we use longer timeouts
+const (
+	tidalAPITimeoutMobile = 25 * time.Second
+	tidalMaxRetries       = 2 // Number of retries per API
+	tidalRetryDelay       = 500 * time.Millisecond
+)
+
+// fetchTidalURLWithRetry fetches download URL from a single Tidal API with retry logic
+func fetchTidalURLWithRetry(api string, trackID int64, quality string, timeout time.Duration) (TidalDownloadInfo, error) {
+	var lastErr error
+	retryDelay := tidalRetryDelay
+
+	for attempt := 0; attempt <= tidalMaxRetries; attempt++ {
+		if attempt > 0 {
+			GoLog("[Tidal] Retry %d/%d for %s after %v\n", attempt, tidalMaxRetries, api, retryDelay)
+			time.Sleep(retryDelay)
+			retryDelay *= 2 // Exponential backoff
+		}
+
+		client := NewHTTPClientWithTimeout(timeout)
+		reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			lastErr = err
+			// Check for retryable errors (timeout, connection reset)
+			errStr := strings.ToLower(err.Error())
+			if strings.Contains(errStr, "timeout") ||
+				strings.Contains(errStr, "reset") ||
+				strings.Contains(errStr, "connection refused") ||
+				strings.Contains(errStr, "eof") {
+				continue // Retry
+			}
+			break // Non-retryable error
+		}
+		// Server errors are retryable
+		if resp.StatusCode >= 500 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("HTTP %d", resp.StatusCode)
+			continue
+		}
+
+		// 429 rate limit - wait and retry
+		if resp.StatusCode == 429 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("rate limited")
+			retryDelay = 2 * time.Second // Wait longer for rate limit
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			return TidalDownloadInfo{}, fmt.Errorf("HTTP %d", resp.StatusCode)
+		}
+
+		body, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		// Try V2 response format (with manifest)
+		var v2Response TidalAPIResponseV2
+		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
+			if v2Response.Data.AssetPresentation == "PREVIEW" {
+				return TidalDownloadInfo{}, fmt.Errorf("returned PREVIEW instead of FULL")
+			}
+
+			return TidalDownloadInfo{
+				URL:        "MANIFEST:" + v2Response.Data.Manifest,
+				BitDepth:   v2Response.Data.BitDepth,
+				SampleRate: v2Response.Data.SampleRate,
+			}, nil
+		}
+
+		// Try V1 response format
+		var v1Responses []struct {
+			OriginalTrackURL string `json:"OriginalTrackUrl"`
+		}
+		if err := json.Unmarshal(body, &v1Responses); err == nil {
+			for _, item := range v1Responses {
+				if item.OriginalTrackURL != "" {
+					return TidalDownloadInfo{
+						URL:        item.OriginalTrackURL,
+						BitDepth:   16,
+						SampleRate: 44100,
+					}, nil
+				}
+			}
+		}
+
+		return TidalDownloadInfo{}, fmt.Errorf("no download URL or manifest in response")
+	}
+
+	if lastErr != nil {
+		return TidalDownloadInfo{}, lastErr
+	}
+	return TidalDownloadInfo{}, fmt.Errorf("all retries failed")
+}
+
 func getDownloadURLParallel(apis []string, trackID int64, quality string) (string, TidalDownloadInfo, error) {
 	if len(apis) == 0 {
 		return "", TidalDownloadInfo{}, fmt.Errorf("no APIs available")
 	}
 
-	GoLog("[Tidal] Requesting download URL from %d APIs in parallel...\n", len(apis))
+	GoLog("[Tidal] Requesting download URL from %d APIs in parallel (with retry)...\n", len(apis))
 
 	resultChan := make(chan tidalAPIResult, len(apis))
 	startTime := time.Now()
@@ -595,69 +706,13 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 	for _, apiURL := range apis {
 		go func(api string) {
 			reqStart := time.Now()
-
-			client := NewHTTPClientWithTimeout(15 * time.Second)
-
-			reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
-
-			req, err := http.NewRequest("GET", reqURL, nil)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
+			info, err := fetchTidalURLWithRetry(api, trackID, quality, tidalAPITimeoutMobile)
+			resultChan <- tidalAPIResult{
+				apiURL:   api,
+				info:     info,
+				err:      err,
+				duration: time.Since(reqStart),
 			}
-
-			resp, err := client.Do(req)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-			defer resp.Body.Close()
-
-			if resp.StatusCode != 200 {
-				resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
-				return
-			}
-
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-
-			var v2Response TidalAPIResponseV2
-			if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
-				if v2Response.Data.AssetPresentation == "PREVIEW" {
-					resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("returned PREVIEW instead of FULL"), duration: time.Since(reqStart)}
-					return
-				}
-
-				info := TidalDownloadInfo{
-					URL:        "MANIFEST:" + v2Response.Data.Manifest,
-					BitDepth:   v2Response.Data.BitDepth,
-					SampleRate: v2Response.Data.SampleRate,
-				}
-				resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
-				return
-			}
-
-			var v1Responses []struct {
-				OriginalTrackURL string `json:"OriginalTrackUrl"`
-			}
-			if err := json.Unmarshal(body, &v1Responses); err == nil {
-				for _, item := range v1Responses {
-					if item.OriginalTrackURL != "" {
-						info := TidalDownloadInfo{
-							URL:        item.OriginalTrackURL,
-							BitDepth:   16,
-							SampleRate: 44100,
-						}
-						resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
-						return
-					}
-				}
-			}
-
-			resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("no download URL or manifest in response"), duration: time.Since(reqStart)}
 		}(apiURL)
 	}
 
@@ -784,6 +839,10 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 		GoLog("[Tidal] Total segments from regex: %d\n", segmentCount)
 	}
 
+	if segmentCount == 0 {
+		return "", "", nil, fmt.Errorf("no segments found in manifest")
+	}
+
 	for i := 1; i <= segmentCount; i++ {
 		mediaURL := strings.ReplaceAll(mediaTemplate, "$Number$", fmt.Sprintf("%d", i))
 		mediaURLs = append(mediaURLs, mediaURL)
@@ -792,7 +851,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	return "", initURL, mediaURLs, nil
 }
 
-func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (t *TidalDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()
 
 	if strings.HasPrefix(downloadURL, "MANIFEST:") {
@@ -805,7 +864,7 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
-		return t.downloadFromManifest(ctx, strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, itemID)
+		return t.downloadFromManifest(ctx, strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, outputFD, itemID)
 	}
 
 	if itemID != "" {
@@ -842,7 +901,7 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		SetItemBytesTotal(itemID, expectedSize)
 	}
 
-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -861,30 +920,30 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	closeErr := out.Close()
 
 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}
 
 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}
 
 	return nil
 }
 
-func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64, outputPath, itemID string) error {
+func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64, outputPath string, outputFD int, itemID string) error {
 	fmt.Println("[Tidal] Parsing manifest...")
 	directURL, initURL, mediaURLs, err := parseManifest(manifestB64)
 	if err != nil {
@@ -929,7 +988,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 			SetItemBytesTotal(itemID, expectedSize)
 		}
 
-		out, err := os.Create(outputPath)
+		out, err := openOutputForWrite(outputPath, outputFD)
 		if err != nil {
 			return fmt.Errorf("failed to create file: %w", err)
 		}
@@ -945,19 +1004,19 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		closeErr := out.Close()
 
 		if err != nil {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
 			return fmt.Errorf("download interrupted: %w", err)
 		}
 		if closeErr != nil {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			return fmt.Errorf("failed to close file: %w", closeErr)
 		}
 
 		if expectedSize > 0 && written != expectedSize {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 		}
 
@@ -965,17 +1024,20 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	}
 
 	// For DASH format, determine correct M4A path
-	// If outputPath already ends with .m4a, use it directly
-	// Otherwise, convert .flac to .m4a
+	// If outputPath already ends with .m4a, use it directly.
+	// If outputPath ends with .flac, convert .flac to .m4a.
+	// Otherwise (e.g., SAF /proc/self/fd/*), use outputPath as-is.
 	var m4aPath string
 	if strings.HasSuffix(outputPath, ".m4a") {
 		m4aPath = outputPath
-	} else {
+	} else if strings.HasSuffix(outputPath, ".flac") {
 		m4aPath = strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	} else {
+		m4aPath = outputPath
 	}
 	GoLog("[Tidal] DASH format - downloading %d segments directly to: %s\n", len(mediaURLs), m4aPath)
 
-	out, err := os.Create(m4aPath)
+	out, err := openOutputForWrite(m4aPath, outputFD)
 	if err != nil {
 		GoLog("[Tidal] Failed to create M4A file: %v\n", err)
 		return fmt.Errorf("failed to create M4A file: %w", err)
@@ -984,20 +1046,20 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	GoLog("[Tidal] Downloading init segment...\n")
 	if isDownloadCancelled(itemID) {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		return ErrDownloadCancelled
 	}
 	req, err := http.NewRequestWithContext(ctx, "GET", initURL, nil)
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Init segment request failed: %v\n", err)
 		return fmt.Errorf("failed to create init segment request: %w", err)
 	}
 	resp, err := client.Do(req)
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
@@ -1007,7 +1069,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	if resp.StatusCode != 200 {
 		resp.Body.Close()
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Init segment HTTP error: %d\n", resp.StatusCode)
 		return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
 	}
@@ -1015,7 +1077,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	resp.Body.Close()
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
@@ -1027,7 +1089,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	for i, mediaURL := range mediaURLs {
 		if isDownloadCancelled(itemID) {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			return ErrDownloadCancelled
 		}
 
@@ -1043,14 +1105,14 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		req, err := http.NewRequestWithContext(ctx, "GET", mediaURL, nil)
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			GoLog("[Tidal] Segment %d request failed: %v\n", i+1, err)
 			return fmt.Errorf("failed to create segment %d request: %w", i+1, err)
 		}
 		resp, err := client.Do(req)
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
@@ -1060,7 +1122,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		if resp.StatusCode != 200 {
 			resp.Body.Close()
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			GoLog("[Tidal] Segment %d HTTP error: %d\n", i+1, resp.StatusCode)
 			return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
 		}
@@ -1068,7 +1130,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		resp.Body.Close()
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
@@ -1078,7 +1140,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	}
 
 	if err := out.Close(); err != nil {
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Failed to close M4A file: %v\n", err)
 		return fmt.Errorf("failed to close M4A file: %w", err)
 	}
@@ -1347,8 +1409,11 @@ func isLatinScript(s string) bool {
 func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	downloader := NewTidalDownloader()
 
-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
 	}
 
 	expectedDurationSec := req.DurationMS / 1000
@@ -1404,49 +1469,83 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 
 	if track == nil && req.SpotifyID != "" {
 		GoLog("[Tidal] ISRC search failed, trying SongLink...\n")
-		var tidalURL string
-		var slErr error
+
+		var trackID int64
+		var gotTidalID bool
 
 		if strings.HasPrefix(req.SpotifyID, "deezer:") {
 			deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
 			GoLog("[Tidal] Using Deezer ID for SongLink lookup: %s\n", deezerID)
 			songlink := NewSongLinkClient()
-			tidalURL, slErr = songlink.GetTidalURLFromDeezer(deezerID)
+			availability, slErr := songlink.CheckAvailabilityFromDeezer(deezerID)
+			if slErr == nil && availability != nil && availability.TidalID != "" {
+				if _, parseErr := fmt.Sscanf(availability.TidalID, "%d", &trackID); parseErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d directly from SongLink\n", trackID)
+					gotTidalID = true
+				}
+			}
+			// Fallback to URL parsing if TidalID not in struct
+			if !gotTidalID && availability != nil && availability.TidalURL != "" {
+				var idErr error
+				trackID, idErr = downloader.GetTrackIDFromURL(availability.TidalURL)
+				if idErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d from URL parsing\n", trackID)
+					gotTidalID = true
+				}
+			}
 		} else {
-			tidalURL, slErr = downloader.GetTidalURLFromSpotify(req.SpotifyID)
+			songlink := NewSongLinkClient()
+			availability, slErr := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+			if slErr == nil && availability != nil && availability.TidalID != "" {
+				if _, parseErr := fmt.Sscanf(availability.TidalID, "%d", &trackID); parseErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d directly from SongLink\n", trackID)
+					gotTidalID = true
+				}
+			}
+			// Fallback to URL parsing if TidalID not in struct
+			if !gotTidalID && availability != nil && availability.TidalURL != "" {
+				var idErr error
+				trackID, idErr = downloader.GetTrackIDFromURL(availability.TidalURL)
+				if idErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d from URL parsing\n", trackID)
+					gotTidalID = true
+				}
+			}
 		}
 
-		if slErr == nil && tidalURL != "" {
-			trackID, idErr := downloader.GetTrackIDFromURL(tidalURL)
-			if idErr == nil {
-				track, err = downloader.GetTrackInfoByID(trackID)
-				if track != nil {
-					tidalArtist := track.Artist.Name
-					if len(track.Artists) > 0 {
-						var artistNames []string
-						for _, a := range track.Artists {
-							artistNames = append(artistNames, a.Name)
-						}
-						tidalArtist = strings.Join(artistNames, ", ")
+		if gotTidalID && trackID > 0 {
+			track, err = downloader.GetTrackInfoByID(trackID)
+			if track != nil {
+				tidalArtist := track.Artist.Name
+				if len(track.Artists) > 0 {
+					var artistNames []string
+					for _, a := range track.Artists {
+						artistNames = append(artistNames, a.Name)
 					}
+					tidalArtist = strings.Join(artistNames, ", ")
+				}
 
-					if !artistsMatch(req.ArtistName, tidalArtist) {
-						GoLog("[Tidal] Artist mismatch from SongLink: expected '%s', got '%s'. Rejecting.\n",
-							req.ArtistName, tidalArtist)
-						track = nil
-					}
+				if !artistsMatch(req.ArtistName, tidalArtist) {
+					GoLog("[Tidal] Artist mismatch from SongLink: expected '%s', got '%s'. Rejecting.\n",
+						req.ArtistName, tidalArtist)
+					track = nil
+				}
 
-					if track != nil && expectedDurationSec > 0 {
-						durationDiff := track.Duration - expectedDurationSec
-						if durationDiff < 0 {
-							durationDiff = -durationDiff
-						}
-						if durationDiff > 3 {
-							GoLog("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n",
-								expectedDurationSec, track.Duration)
-							track = nil // Reject this match
-						}
+				if track != nil && expectedDurationSec > 0 {
+					durationDiff := track.Duration - expectedDurationSec
+					if durationDiff < 0 {
+						durationDiff = -durationDiff
 					}
+					if durationDiff > 3 {
+						GoLog("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n",
+							expectedDurationSec, track.Duration)
+						track = nil // Reject this match
+					}
+				}
+
+				// Cache for future use
+				if track != nil && req.ISRC != "" {
+					GetTrackIDCache().SetTidal(req.ISRC, track.ID)
 				}
 			}
 		}
@@ -1513,31 +1612,52 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		"disc":   req.DiscNumber,
 	})
 
-	var outputPath string
-	var m4aPath string
-	if quality == "HIGH" {
-		filename = sanitizeFilename(filename) + ".m4a"
-		outputPath = filepath.Join(req.OutputDir, filename)
-		m4aPath = outputPath
-	} else {
-		filename = sanitizeFilename(filename) + ".flac"
-		outputPath = filepath.Join(req.OutputDir, filename)
-		m4aPath = strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	outputExt := strings.TrimSpace(req.OutputExt)
+	if outputExt == "" {
+		if quality == "HIGH" {
+			outputExt = ".m4a"
+		} else {
+			outputExt = ".flac"
+		}
+	} else if !strings.HasPrefix(outputExt, ".") {
+		outputExt = "." + outputExt
 	}
 
-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
-	}
-	if quality != "HIGH" {
-		if fileInfo, statErr := os.Stat(m4aPath); statErr == nil && fileInfo.Size() > 0 {
-			return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
+	var outputPath string
+	var m4aPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+		m4aPath = outputPath
+	} else {
+		if outputExt == ".m4a" || quality == "HIGH" {
+			filename = sanitizeFilename(filename) + ".m4a"
+			outputPath = filepath.Join(req.OutputDir, filename)
+			m4aPath = outputPath
+		} else {
+			filename = sanitizeFilename(filename) + ".flac"
+			outputPath = filepath.Join(req.OutputDir, filename)
+			m4aPath = strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+		}
+
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
+		if quality != "HIGH" {
+			if fileInfo, statErr := os.Stat(m4aPath); statErr == nil && fileInfo.Size() > 0 {
+				return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
+			}
 		}
 	}
 
-	tmpPath := outputPath + ".m4a.tmp"
-	if _, err := os.Stat(tmpPath); err == nil {
-		GoLog("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
-		os.Remove(tmpPath)
+	if !isSafOutput {
+		tmpPath := outputPath + ".m4a.tmp"
+		if _, err := os.Stat(tmpPath); err == nil {
+			GoLog("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
+			os.Remove(tmpPath)
+		}
 	}
 
 	GoLog("[Tidal] Using quality: %s\n", quality)
@@ -1572,7 +1692,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return "Direct URL"
 	}())
 
-	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return TidalDownloadResult{}, ErrDownloadCancelled
 		}
@@ -1589,11 +1709,13 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	}
 
 	actualOutputPath := outputPath
-	if _, err := os.Stat(m4aPath); err == nil {
-		actualOutputPath = m4aPath
-		GoLog("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
-	} else if _, err := os.Stat(outputPath); err != nil {
-		return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+	if !isSafOutput {
+		if _, err := os.Stat(m4aPath); err == nil {
+			actualOutputPath = m4aPath
+			GoLog("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
+		} else if _, err := os.Stat(outputPath); err != nil {
+			return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+		}
 	}
 
 	releaseDate := req.ReleaseDate
@@ -1632,7 +1754,15 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		GoLog("[Tidal] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
-	if strings.HasSuffix(actualOutputPath, ".flac") {
+	actualExt := outputExt
+	if strings.HasPrefix(downloadInfo.URL, "MANIFEST:") {
+		actualExt = ".m4a"
+	}
+	if actualExt == "" && !isSafOutput {
+		actualExt = strings.ToLower(filepath.Ext(actualOutputPath))
+	}
+
+	if (isSafOutput && actualExt == ".flac") || (!isSafOutput && strings.HasSuffix(actualOutputPath, ".flac")) {
 		if err := EmbedMetadataWithCoverData(actualOutputPath, metadata, coverData); err != nil {
 			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 		}
@@ -1643,7 +1773,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 				lyricsMode = "embed"
 			}
 
-			if lyricsMode == "external" || lyricsMode == "both" {
+			if !isSafOutput && (lyricsMode == "external" || lyricsMode == "both") {
 				GoLog("[Tidal] Saving external LRC file...\n")
 				if lrcPath, lrcErr := SaveLRCFile(actualOutputPath, parallelResult.LyricsLRC); lrcErr != nil {
 					GoLog("[Tidal] Warning: failed to save LRC file: %v\n", lrcErr)
@@ -1663,7 +1793,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		} else if req.EmbedLyrics {
 			fmt.Println("[Tidal] No lyrics available from parallel fetch")
 		}
-	} else if strings.HasSuffix(actualOutputPath, ".m4a") {
+	} else if (isSafOutput && actualExt == ".m4a") || (!isSafOutput && strings.HasSuffix(actualOutputPath, ".m4a")) {
 		if quality == "HIGH" {
 			GoLog("[Tidal] HIGH quality M4A - skipping metadata embedding (file from server is already valid)\n")
 
@@ -1673,7 +1803,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 					lyricsMode = "embed"
 				}
 
-				if lyricsMode == "external" || lyricsMode == "both" {
+				if !isSafOutput && (lyricsMode == "external" || lyricsMode == "both") {
 					GoLog("[Tidal] Saving external LRC file for M4A (mode: %s)...\n", lyricsMode)
 					if lrcPath, lrcErr := SaveLRCFile(actualOutputPath, parallelResult.LyricsLRC); lrcErr != nil {
 						GoLog("[Tidal] Warning: failed to save LRC file: %v\n", lrcErr)
@@ -1687,7 +1817,9 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
+	}
 
 	bitDepth := downloadInfo.BitDepth
 	sampleRate := downloadInfo.SampleRate
@@ -1695,15 +1827,9 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	if quality == "HIGH" {
 		bitDepth = 0
 		sampleRate = 44100
-		if parallelResult != nil && parallelResult.LyricsLRC != "" {
-			lyricsMode := req.LyricsMode
-			if lyricsMode == "" {
-				lyricsMode = "embed"
-			}
-			if lyricsMode == "embed" || lyricsMode == "both" {
-				lyricsLRC = parallelResult.LyricsLRC
-			}
-		}
+	}
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		lyricsLRC = parallelResult.LyricsLRC
 	}
 
 	return TidalDownloadResult{

ios/Runner/AppDelegate.swift

@@ -639,6 +639,14 @@ import Gobackend  // Import Go framework
             let response = GobackendRunPostProcessingJSON(filePath, metadataJson, &error)
             if let error = error { throw error }
             return response
+
+        case "runPostProcessingV2":
+            let args = call.arguments as! [String: Any]
+            let inputJson = args["input"] as? String ?? ""
+            let metadataJson = args["metadata"] as? String ?? ""
+            let response = GobackendRunPostProcessingV2JSON(inputJson, metadataJson, &error)
+            if let error = error { throw error }
+            return response
             
         case "getPostProcessingProviders":
             let response = GobackendGetPostProcessingProvidersJSON(&error)

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 = '3.4.0';
-  static const String buildNumber = '72';
+  static const String version = '3.5.0-beta.1';
+  static const String buildNumber = '73';
   static const String fullVersion = '$version+$buildNumber';
   
   

lib/models/settings.dart

@@ -8,6 +8,8 @@ class AppSettings {
   final String audioQuality;
   final String filenameFormat;
   final String downloadDirectory;
+  final String storageMode; // 'app' or 'saf'
+  final String downloadTreeUri; // SAF persistable tree URI
   final bool autoFallback;
   final bool embedLyrics;
   final bool maxQualityCover;
@@ -32,7 +34,7 @@ class AppSettings {
   final bool showExtensionStore;
   final String locale;
   final String lyricsMode;
-  final String tidalHighFormat; // Format for Tidal HIGH quality: 'mp3_320' or 'opus_128'
+  final String tidalHighFormat; // Format for Tidal HIGH quality: 'mp3_320', 'opus_256', or 'opus_128'
   final bool useAllFilesAccess; // Android 13+ only: enable MANAGE_EXTERNAL_STORAGE
   final bool autoExportFailedDownloads; // Auto export failed downloads to TXT file
   final String downloadNetworkMode; // 'any' = WiFi + Mobile, 'wifi_only' = WiFi only
@@ -47,6 +49,8 @@ class AppSettings {
     this.audioQuality = 'LOSSLESS',
     this.filenameFormat = '{title} - {artist}',
     this.downloadDirectory = '',
+    this.storageMode = 'app',
+    this.downloadTreeUri = '',
     this.autoFallback = true,
     this.embedLyrics = true,
     this.maxQualityCover = true,
@@ -86,6 +90,8 @@ class AppSettings {
     String? audioQuality,
     String? filenameFormat,
     String? downloadDirectory,
+    String? storageMode,
+    String? downloadTreeUri,
     bool? autoFallback,
     bool? embedLyrics,
     bool? maxQualityCover,
@@ -125,6 +131,8 @@ class AppSettings {
       audioQuality: audioQuality ?? this.audioQuality,
       filenameFormat: filenameFormat ?? this.filenameFormat,
       downloadDirectory: downloadDirectory ?? this.downloadDirectory,
+      storageMode: storageMode ?? this.storageMode,
+      downloadTreeUri: downloadTreeUri ?? this.downloadTreeUri,
       autoFallback: autoFallback ?? this.autoFallback,
       embedLyrics: embedLyrics ?? this.embedLyrics,
       maxQualityCover: maxQualityCover ?? this.maxQualityCover,

lib/models/settings.g.dart

@@ -11,6 +11,8 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   audioQuality: json['audioQuality'] as String? ?? 'LOSSLESS',
   filenameFormat: json['filenameFormat'] as String? ?? '{title} - {artist}',
   downloadDirectory: json['downloadDirectory'] as String? ?? '',
+  storageMode: json['storageMode'] as String? ?? 'app',
+  downloadTreeUri: json['downloadTreeUri'] as String? ?? '',
   autoFallback: json['autoFallback'] as bool? ?? true,
   embedLyrics: json['embedLyrics'] as bool? ?? true,
   maxQualityCover: json['maxQualityCover'] as bool? ?? true,
@@ -54,6 +56,8 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'audioQuality': instance.audioQuality,
       'filenameFormat': instance.filenameFormat,
       'downloadDirectory': instance.downloadDirectory,
+      'storageMode': instance.storageMode,
+      'downloadTreeUri': instance.downloadTreeUri,
       'autoFallback': instance.autoFallback,
       'embedLyrics': instance.embedLyrics,
       'maxQualityCover': instance.maxQualityCover,

lib/providers/explore_provider.dart

@@ -1,4 +1,6 @@
+import 'dart:convert';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';
@@ -47,6 +49,20 @@ class ExploreItem {
       durationMs: json['duration_ms'] as int? ?? 0,
     );
   }
+
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'uri': uri,
+    'type': type,
+    'name': name,
+    'artists': artists,
+    'description': description,
+    'cover_url': coverUrl,
+    'provider_id': providerId,
+    'album_id': albumId,
+    'album_name': albumName,
+    'duration_ms': durationMs,
+  };
 }
 
 class ExploreSection {
@@ -75,6 +91,12 @@ class ExploreSection {
       isYTMusicQuickPicks: isQuickPicks,
     );
   }
+
+  Map<String, dynamic> toJson() => {
+    'uri': uri,
+    'title': title,
+    'items': items.map((i) => i.toJson()).toList(),
+  };
 }
 
 class ExploreState {
@@ -136,20 +158,71 @@ bool _isYTMusicQuickPicksItems(List<ExploreItem> items) {
 }
 
 class ExploreNotifier extends Notifier<ExploreState> {
+  static const _cacheKey = 'explore_home_feed_cache';
+  static const _cacheTsKey = 'explore_home_feed_ts';
+
   @override
   ExploreState build() {
+    _restoreFromCache();
     return const ExploreState();
   }
 
+  /// Restore cached home feed from SharedPreferences immediately on startup
+  Future<void> _restoreFromCache() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final cached = prefs.getString(_cacheKey);
+      final cachedTs = prefs.getInt(_cacheTsKey);
+      if (cached == null || cached.isEmpty) return;
+
+      final data = jsonDecode(cached) as Map<String, dynamic>;
+      final sectionsData = data['sections'] as List<dynamic>? ?? [];
+      final sections = sectionsData
+          .map((s) => ExploreSection.fromJson(s as Map<String, dynamic>))
+          .toList();
+
+      if (sections.isEmpty) return;
+
+      final lastFetched = cachedTs != null
+          ? DateTime.fromMillisecondsSinceEpoch(cachedTs)
+          : null;
+
+      _log.i('Restored ${sections.length} cached explore sections');
+      state = ExploreState(
+        greeting: _getLocalGreeting(),
+        sections: sections,
+        lastFetched: lastFetched,
+      );
+    } catch (e) {
+      _log.w('Failed to restore explore cache: $e');
+    }
+  }
+
+  /// Save home feed to SharedPreferences for instant restore on next launch
+  Future<void> _saveToCache(List<ExploreSection> sections) async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final data = {
+        'sections': sections.map((s) => s.toJson()).toList(),
+      };
+      await prefs.setString(_cacheKey, jsonEncode(data));
+      await prefs.setInt(_cacheTsKey, DateTime.now().millisecondsSinceEpoch);
+      _log.d('Saved ${sections.length} explore sections to cache');
+    } catch (e) {
+      _log.w('Failed to save explore cache: $e');
+    }
+  }
+
   /// Fetch home feed from spotify-web extension
   Future<void> fetchHomeFeed({bool forceRefresh = false}) async {
     _log.i('fetchHomeFeed called, forceRefresh=$forceRefresh');
     
+    // If we have cached content and it's fresh enough, skip network fetch
     if (!forceRefresh && 
         state.hasContent && 
         state.lastFetched != null &&
         DateTime.now().difference(state.lastFetched!).inMinutes < 5) {
-      _log.d('Using cached home feed');
+      _log.d('Using cached home feed (fresh enough)');
       return;
     }
     
@@ -158,7 +231,9 @@ class ExploreNotifier extends Notifier<ExploreState> {
       return;
     }
 
-    state = state.copyWith(isLoading: true, error: null);
+    // Only show loading spinner if we have no cached content to display
+    final showLoading = !state.hasContent;
+    state = state.copyWith(isLoading: showLoading, error: null);
 
     try {
       final extState = ref.read(extensionProvider);
@@ -231,6 +306,9 @@ class ExploreNotifier extends Notifier<ExploreState> {
         sections: sections,
         lastFetched: DateTime.now(),
       );
+
+      // Save to disk cache for instant restore on next app launch
+      _saveToCache(sections);
     } catch (e, stack) {
       _log.e('Error fetching home feed: $e', e, stack);
       state = state.copyWith(

lib/providers/extension_provider.dart

@@ -1,10 +1,15 @@
+import 'dart:convert';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 
 final _log = AppLogger('ExtensionProvider');
 
+const _metadataProviderPriorityKey = 'metadata_provider_priority';
+const _providerPriorityKey = 'provider_priority';
+
 class Extension {
   final String id;
   final String name;
@@ -622,7 +627,23 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
 
   Future<void> loadProviderPriority() async {
     try {
-      final priority = await PlatformBridge.getProviderPriority();
+      // Load from SharedPreferences first (persisted)
+      final prefs = await SharedPreferences.getInstance();
+      final savedJson = prefs.getString(_providerPriorityKey);
+      
+      List<String> priority;
+      if (savedJson != null) {
+        final saved = jsonDecode(savedJson) as List<dynamic>;
+        priority = saved.map((e) => e as String).toList();
+        _log.d('Loaded provider priority from prefs: $priority');
+        // Sync to Go backend
+        await PlatformBridge.setProviderPriority(priority);
+      } else {
+        // Fallback to Go backend default
+        priority = await PlatformBridge.getProviderPriority();
+        _log.d('Using default provider priority: $priority');
+      }
+      
       state = state.copyWith(providerPriority: priority);
     } catch (e) {
       _log.e('Failed to load provider priority: $e');
@@ -632,9 +653,14 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
 
   Future<void> setProviderPriority(List<String> priority) async {
     try {
+      // Save to SharedPreferences for persistence
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setString(_providerPriorityKey, jsonEncode(priority));
+      
+      // Sync to Go backend
       await PlatformBridge.setProviderPriority(priority);
       state = state.copyWith(providerPriority: priority);
-      _log.d('Updated provider priority: $priority');
+      _log.d('Saved provider priority: $priority');
     } catch (e) {
       _log.e('Failed to set provider priority: $e');
       state = state.copyWith(error: e.toString());
@@ -643,7 +669,23 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
 
   Future<void> loadMetadataProviderPriority() async {
     try {
-      final priority = await PlatformBridge.getMetadataProviderPriority();
+      // Load from SharedPreferences first (persisted)
+      final prefs = await SharedPreferences.getInstance();
+      final savedJson = prefs.getString(_metadataProviderPriorityKey);
+      
+      List<String> priority;
+      if (savedJson != null) {
+        final saved = jsonDecode(savedJson) as List<dynamic>;
+        priority = saved.map((e) => e as String).toList();
+        _log.d('Loaded metadata provider priority from prefs: $priority');
+        // Sync to Go backend
+        await PlatformBridge.setMetadataProviderPriority(priority);
+      } else {
+        // Fallback to Go backend default
+        priority = await PlatformBridge.getMetadataProviderPriority();
+        _log.d('Using default metadata provider priority: $priority');
+      }
+      
       state = state.copyWith(metadataProviderPriority: priority);
     } catch (e) {
       _log.e('Failed to load metadata provider priority: $e');
@@ -652,9 +694,14 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
 
   Future<void> setMetadataProviderPriority(List<String> priority) async {
     try {
+      // Save to SharedPreferences for persistence
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setString(_metadataProviderPriorityKey, jsonEncode(priority));
+      
+      // Sync to Go backend
       await PlatformBridge.setMetadataProviderPriority(priority);
       state = state.copyWith(metadataProviderPriority: priority);
-      _log.d('Updated metadata provider priority: $priority');
+      _log.d('Saved metadata provider priority: $priority');
     } catch (e) {
       _log.e('Failed to set metadata provider priority: $e');
       state = state.copyWith(error: e.toString());

lib/providers/local_library_provider.dart

@@ -17,6 +17,7 @@ class LocalLibraryState {
   final String? scanCurrentFile;
   final int scanTotalFiles;
   final int scanErrorCount;
+  final bool scanWasCancelled;
   final DateTime? lastScannedAt;
   final Set<String> _isrcSet;
   final Set<String> _trackKeySet;
@@ -29,6 +30,7 @@ class LocalLibraryState {
     this.scanCurrentFile,
     this.scanTotalFiles = 0,
     this.scanErrorCount = 0,
+    this.scanWasCancelled = false,
     this.lastScannedAt,
   })  : _isrcSet = items
             .where((item) => item.isrc != null && item.isrc!.isNotEmpty)
@@ -72,6 +74,7 @@ class LocalLibraryState {
     String? scanCurrentFile,
     int? scanTotalFiles,
     int? scanErrorCount,
+    bool? scanWasCancelled,
     DateTime? lastScannedAt,
   }) {
     return LocalLibraryState(
@@ -81,6 +84,7 @@ class LocalLibraryState {
       scanCurrentFile: scanCurrentFile ?? this.scanCurrentFile,
       scanTotalFiles: scanTotalFiles ?? this.scanTotalFiles,
       scanErrorCount: scanErrorCount ?? this.scanErrorCount,
+      scanWasCancelled: scanWasCancelled ?? this.scanWasCancelled,
       lastScannedAt: lastScannedAt ?? this.lastScannedAt,
     );
   }
@@ -90,6 +94,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
   final LibraryDatabase _db = LibraryDatabase.instance;
   Timer? _progressTimer;
   bool _isLoaded = false;
+  bool _scanCancelRequested = false;
 
   @override
   LocalLibraryState build() {
@@ -142,6 +147,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
       return;
     }
 
+    _scanCancelRequested = false;
     _log.i('Starting library scan: $folderPath');
     state = state.copyWith(
       isScanning: true,
@@ -149,6 +155,7 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
       scanCurrentFile: null,
       scanTotalFiles: 0,
       scanErrorCount: 0,
+      scanWasCancelled: false,
     );
 
     try {
@@ -163,7 +170,14 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
     _startProgressPolling();
 
     try {
-      final results = await PlatformBridge.scanLibraryFolder(folderPath);
+      final isSaf = folderPath.startsWith('content://');
+      final results = isSaf
+          ? await PlatformBridge.scanSafTree(folderPath)
+          : await PlatformBridge.scanLibraryFolder(folderPath);
+      if (_scanCancelRequested) {
+        state = state.copyWith(isScanning: false, scanWasCancelled: true);
+        return;
+      }
       
       final items = <LocalLibraryItem>[];
       for (final json in results) {
@@ -187,12 +201,13 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
         isScanning: false,
         scanProgress: 100,
         lastScannedAt: now,
+        scanWasCancelled: false,
       );
 
       _log.i('Scan complete: ${items.length} tracks found');
     } catch (e, stack) {
       _log.e('Library scan failed: $e', e, stack);
-      state = state.copyWith(isScanning: false);
+      state = state.copyWith(isScanning: false, scanWasCancelled: false);
     } finally {
       _stopProgressPolling();
     }
@@ -227,8 +242,9 @@ class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
     if (!state.isScanning) return;
     
     _log.i('Cancelling library scan');
+    _scanCancelRequested = true;
     await PlatformBridge.cancelLibraryScan();
-    state = state.copyWith(isScanning: false);
+    state = state.copyWith(isScanning: false, scanWasCancelled: true);
     _stopProgressPolling();
   }
 

lib/providers/settings_provider.dart

@@ -48,6 +48,9 @@ class SettingsNotifier extends Notifier<AppSettings> {
     }
     
     if (lastMigration < _currentMigrationVersion) {
+      if (state.downloadTreeUri.isNotEmpty && state.storageMode != 'saf') {
+        state = state.copyWith(storageMode: 'saf');
+      }
       await prefs.setInt(_migrationVersionKey, _currentMigrationVersion);
     }
   }
@@ -120,6 +123,22 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
+  void setStorageMode(String mode) {
+    final normalized = mode == 'saf' ? 'saf' : 'app';
+    state = state.copyWith(storageMode: normalized);
+    _saveSettings();
+  }
+
+  void setDownloadTreeUri(String uri, {String? displayName}) {
+    final nextDisplay = displayName ?? state.downloadDirectory;
+    state = state.copyWith(
+      downloadTreeUri: uri,
+      storageMode: uri.isNotEmpty ? 'saf' : state.storageMode,
+      downloadDirectory: nextDisplay,
+    );
+    _saveSettings();
+  }
+
   void setAutoFallback(bool enabled) {
     state = state.copyWith(autoFallback: enabled);
     _saveSettings();

lib/screens/album_screen.dart

@@ -1,4 +1,3 @@
-import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
@@ -12,6 +11,7 @@ import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/providers/recent_access_provider.dart';
 import 'package:spotiflac_android/providers/local_library_provider.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/widgets/download_service_picker.dart';
 import 'package:spotiflac_android/screens/artist_screen.dart';
 import 'package:spotiflac_android/screens/home_tab.dart' show ExtensionArtistScreen;
@@ -695,8 +695,8 @@ child: ListTile(
     if (isInHistory) {
       final historyItem = ref.read(downloadHistoryProvider.notifier).getBySpotifyId(track.id);
       if (historyItem != null) {
-        final fileExists = await File(historyItem.filePath).exists();
-        if (fileExists) {
+        final exists = await fileExists(historyItem.filePath);
+        if (exists) {
           if (context.mounted) {
             ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAlreadyDownloaded(track.name))));
           }

lib/screens/artist_screen.dart

@@ -1,4 +1,3 @@
-import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
@@ -14,6 +13,7 @@ import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/recent_access_provider.dart';
 import 'package:spotiflac_android/providers/local_library_provider.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/screens/album_screen.dart';
 import 'package:spotiflac_android/screens/home_tab.dart' show ExtensionAlbumScreen;
 import 'package:spotiflac_android/widgets/download_service_picker.dart';
@@ -1061,8 +1061,8 @@ if (hasValidImage)
     if (isInHistory) {
       final historyItem = ref.read(downloadHistoryProvider.notifier).getBySpotifyId(track.id);
       if (historyItem != null) {
-        final fileExists = await File(historyItem.filePath).exists();
-        if (fileExists) {
+        final exists = await fileExists(historyItem.filePath);
+        if (exists) {
           if (mounted) {
             ScaffoldMessenger.of(context).showSnackBar(
               SnackBar(content: Text(context.l10n.snackbarAlreadyDownloaded(track.name))),

lib/screens/downloaded_album_screen.dart

@@ -1,13 +1,11 @@
-import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
-import 'package:open_filex/open_filex.dart';
 import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/services/palette_service.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
-import 'package:spotiflac_android/utils/mime_utils.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/screens/track_metadata_screen.dart';
 
@@ -180,10 +178,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
         final item = currentTracks.where((e) => e.id == id).firstOrNull;
         if (item != null) {
           try {
-            final file = File(item.filePath);
-            if (await file.exists()) {
-              await file.delete();
-            }
+            await deleteFile(item.filePath);
           } catch (_) {}
           historyNotifier.removeFromHistory(id);
           deletedCount++;
@@ -202,8 +197,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
 
   Future<void> _openFile(String filePath) async {
     try {
-      final mimeType = audioMimeTypeForPath(filePath);
-      await OpenFilex.open(filePath, type: mimeType);
+      await openFile(filePath);
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(

lib/screens/home_tab.dart

@@ -19,6 +19,7 @@ import 'package:spotiflac_android/screens/album_screen.dart';
 import 'package:spotiflac_android/screens/artist_screen.dart';
 import 'package:spotiflac_android/services/csv_import_service.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/screens/playlist_screen.dart';
 import 'package:spotiflac_android/screens/downloaded_album_screen.dart';
 import 'package:spotiflac_android/models/download_item.dart';
@@ -494,7 +495,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
         : null;
     
     final hasExploreContent = exploreSections.isNotEmpty;
-    final showExplore = !hasActualResults && !isLoading && !showRecentAccess && hasHomeFeedExtension && hasExploreContent;
+    final showExplore = !hasActualResults && !isLoading && !showRecentAccess && (hasHomeFeedExtension || hasExploreContent) && hasExploreContent;
     
     // Get current search extension and its filters
     final settings = ref.watch(settingsProvider);
@@ -2569,8 +2570,8 @@ class _TrackItemWithStatus extends ConsumerWidget {
     if (isInHistory) {
       final historyItem = ref.read(downloadHistoryProvider.notifier).getBySpotifyId(track.id);
       if (historyItem != null) {
-        final fileExists = await File(historyItem.filePath).exists();
-        if (fileExists) {
+        final exists = await fileExists(historyItem.filePath);
+        if (exists) {
           if (context.mounted) {
             ScaffoldMessenger.of(context).showSnackBar(
               SnackBar(content: Text(context.l10n.snackbarAlreadyDownloaded(track.name))),

lib/screens/local_album_screen.dart

@@ -2,9 +2,8 @@ import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:open_filex/open_filex.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
-import 'package:spotiflac_android/utils/mime_utils.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/services/library_database.dart';
 import 'package:spotiflac_android/services/palette_service.dart';
 import 'package:spotiflac_android/providers/local_library_provider.dart';
@@ -192,10 +191,7 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
         final item = currentTracks.where((e) => e.id == id).firstOrNull;
         if (item != null) {
           try {
-            final file = File(item.filePath);
-            if (await file.exists()) {
-              await file.delete();
-            }
+            await deleteFile(item.filePath);
           } catch (_) {}
           libraryNotifier.removeItem(id);
           deletedCount++;
@@ -219,8 +215,7 @@ class _LocalAlbumScreenState extends ConsumerState<LocalAlbumScreen> {
 
   Future<void> _openFile(String filePath) async {
     try {
-      final mimeType = audioMimeTypeForPath(filePath);
-      await OpenFilex.open(filePath, type: mimeType);
+      await openFile(filePath);
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(

lib/screens/playlist_screen.dart

@@ -1,4 +1,3 @@
-import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
@@ -9,6 +8,7 @@ import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/providers/local_library_provider.dart';
 import 'package:spotiflac_android/widgets/download_service_picker.dart';
@@ -512,8 +512,8 @@ leading: track.coverUrl != null
     if (isInHistory) {
       final historyItem = ref.read(downloadHistoryProvider.notifier).getBySpotifyId(track.id);
       if (historyItem != null) {
-        final fileExists = await File(historyItem.filePath).exists();
-        if (fileExists) {
+        final exists = await fileExists(historyItem.filePath);
+        if (exists) {
           if (context.mounted) {
             ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAlreadyDownloaded(track.name))));
           }

lib/screens/queue_tab.dart

@@ -5,10 +5,9 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
-import 'package:open_filex/open_filex.dart';
 import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
-import 'package:spotiflac_android/utils/mime_utils.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
@@ -279,6 +278,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
   String _localFilterQueryCache = '';
   List<LocalLibraryItem> _filteredLocalItemsCache = const [];
   final Map<String, _UnifiedCacheEntry> _unifiedItemsCache = {};
+  bool _showSafRepairedBadge = false;
 
   // Advanced filters
   String? _filterSource; // null = all, 'downloaded', 'local'
@@ -637,10 +637,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
         if (item != null) {
           try {
             final cleanPath = _cleanFilePath(item.filePath);
-            final file = File(cleanPath);
-            if (await file.exists()) {
-              await file.delete();
-            }
+            await deleteFile(cleanPath);
           } catch (_) {}
           
           // Remove from appropriate database
@@ -695,7 +692,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     }
     _pendingChecks.add(cleanPath);
     Future.microtask(() async {
-      final exists = await File(cleanPath).exists();
+      final exists = await fileExists(cleanPath);
       _pendingChecks.remove(cleanPath);
       final previous = _fileExistsCache[cleanPath];
       _fileExistsCache[cleanPath] = exists;
@@ -1020,8 +1017,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
   Future<void> _openFile(String filePath) async {
     final cleanPath = _cleanFilePath(filePath);
     try {
-      final mimeType = audioMimeTypeForPath(cleanPath);
-      await OpenFilex.open(cleanPath, type: mimeType);
+      await openFile(cleanPath);
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(
@@ -1315,6 +1311,7 @@ final queueItems = ref.watch(downloadQueueProvider.select((s) => s.items));
     final groupedLocalAlbums = historyStats.groupedLocalAlbums;
     final albumCount = historyStats.totalAlbumCount;
     final singleCount = historyStats.totalSingleTracks;
+    final hasSafRepairedItems = allHistoryItems.any((item) => item.safRepaired);
 
     final bottomPadding = MediaQuery.of(context).padding.bottom;
 
@@ -1584,6 +1581,7 @@ const Spacer(),
                     albumCounts: historyStats.albumCounts,
                     localAlbumCounts: historyStats.localAlbumCounts,
                     localLibraryItems: localLibraryItems,
+                    hasSafRepairedItems: hasSafRepairedItems,
                   );
                 },
               ),
@@ -1705,6 +1703,7 @@ child: _buildSelectionBottomBar(
     required Map<String, int> albumCounts,
     required Map<String, int> localAlbumCounts,
     required List<LocalLibraryItem> localLibraryItems,
+    required bool hasSafRepairedItems,
   }) {
     final historyItems = _resolveHistoryItems(
       filterMode: filterMode,
@@ -1780,6 +1779,27 @@ child: _buildSelectionBottomBar(
                         ),
                       ),
                     ),
+                  if (!_isSelectionMode && hasSafRepairedItems)
+                    IconButton(
+                      onPressed: () {
+                        setState(() {
+                          _showSafRepairedBadge = !_showSafRepairedBadge;
+                        });
+                      },
+                      icon: Icon(
+                        _showSafRepairedBadge ? Icons.build : Icons.build_outlined,
+                        size: 18,
+                      ),
+                      tooltip: _showSafRepairedBadge
+                          ? 'Hide SAF repaired badge'
+                          : 'Show SAF repaired badge',
+                      style: IconButton.styleFrom(
+                        backgroundColor: _showSafRepairedBadge
+                            ? colorScheme.tertiaryContainer.withValues(alpha: 0.6)
+                            : colorScheme.surfaceContainerHighest,
+                        visualDensity: VisualDensity.compact,
+                      ),
+                    ),
                   if (!_isSelectionMode && filteredUnifiedItems.isNotEmpty)
                     TextButton.icon(
                       onPressed: () => _enterSelectionMode(filteredUnifiedItems.first.id),
@@ -2911,6 +2931,10 @@ child: CachedNetworkImage(
     final sourceTextColor = isDownloaded
         ? colorScheme.onPrimaryContainer
         : colorScheme.onSecondaryContainer;
+    final showSafRepaired = _showSafRepairedBadge &&
+        isDownloaded &&
+        item.historyItem != null &&
+        item.historyItem!.safRepaired;
 
     return Card(
       margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
@@ -3007,6 +3031,38 @@ child: CachedNetworkImage(
                                 ),
                           ),
                         ),
+                        if (showSafRepaired) ...[
+                          const SizedBox(width: 6),
+                          Container(
+                            padding: const EdgeInsets.symmetric(
+                              horizontal: 6,
+                              vertical: 2,
+                            ),
+                            decoration: BoxDecoration(
+                              color: colorScheme.tertiaryContainer,
+                              borderRadius: BorderRadius.circular(4),
+                            ),
+                            child: Row(
+                              mainAxisSize: MainAxisSize.min,
+                              children: [
+                                Icon(
+                                  Icons.build,
+                                  size: 10,
+                                  color: colorScheme.onTertiaryContainer,
+                                ),
+                                const SizedBox(width: 4),
+                                Text(
+                                  'SAF repaired',
+                                  style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                                    color: colorScheme.onTertiaryContainer,
+                                    fontSize: 10,
+                                    fontWeight: FontWeight.w500,
+                                  ),
+                                ),
+                              ],
+                            ),
+                          ),
+                        ],
                         const SizedBox(width: 8),
                         Text(
                           dateStr,
@@ -3092,6 +3148,10 @@ child: CachedNetworkImage(
     final fileExists = _checkFileExists(item.filePath);
     final isSelected = _selectedIds.contains(item.id);
     final isDownloaded = item.source == LibraryItemSource.downloaded;
+    final showSafRepaired = _showSafRepairedBadge &&
+        isDownloaded &&
+        item.historyItem != null &&
+        item.historyItem!.safRepaired;
 
     return GestureDetector(
       onTap: _isSelectionMode
@@ -3168,6 +3228,23 @@ child: CachedNetworkImage(
                         ),
                       ),
                     ),
+                  if (showSafRepaired)
+                    Positioned(
+                      left: 4,
+                      bottom: 4,
+                      child: Container(
+                        padding: const EdgeInsets.all(4),
+                        decoration: BoxDecoration(
+                          color: colorScheme.tertiaryContainer,
+                          borderRadius: BorderRadius.circular(6),
+                        ),
+                        child: Icon(
+                          Icons.build,
+                          size: 12,
+                          color: colorScheme.onTertiaryContainer,
+                        ),
+                      ),
+                    ),
                   if (fileExists && !_isSelectionMode)
                     Positioned(
                       right: 4,

lib/screens/settings/download_settings_page.dart

@@ -8,13 +8,15 @@ import 'package:device_info_plus/device_info_plus.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/widgets/settings_group.dart';
 
 class DownloadSettingsPage extends ConsumerStatefulWidget {
   const DownloadSettingsPage({super.key});
 
   @override
-  ConsumerState<DownloadSettingsPage> createState() => _DownloadSettingsPageState();
+  ConsumerState<DownloadSettingsPage> createState() =>
+      _DownloadSettingsPageState();
 }
 
 class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
@@ -92,7 +94,7 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
     final settings = ref.watch(settingsProvider);
     final colorScheme = Theme.of(context).colorScheme;
     final topPadding = MediaQuery.of(context).padding.top;
-    
+
     final isBuiltInService = _builtInServices.contains(settings.defaultService);
     final isTidalService = settings.defaultService == 'tidal';
 
@@ -102,43 +104,43 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
         body: CustomScrollView(
           slivers: [
             SliverAppBar(
-            expandedHeight: 120 + topPadding,
-            collapsedHeight: kToolbarHeight,
-            floating: false,
-            pinned: true,
-            backgroundColor: colorScheme.surface,
-            surfaceTintColor: Colors.transparent,
-            leading: IconButton(
-              icon: const Icon(Icons.arrow_back),
-              onPressed: () => Navigator.pop(context),
-            ),
-            flexibleSpace: LayoutBuilder(
-              builder: (context, constraints) {
-                final maxHeight = 120 + topPadding;
-                final minHeight = kToolbarHeight + topPadding;
-                final expandRatio =
-                    ((constraints.maxHeight - minHeight) /
-                            (maxHeight - minHeight))
-                        .clamp(0.0, 1.0);
-                final leftPadding = 56 - (32 * expandRatio); // 56 -> 24
-                return FlexibleSpaceBar(
-                  expandedTitleScale: 1.0,
-                  titlePadding: EdgeInsets.only(
-                    left: leftPadding,
-                    bottom: 16,
-                  ),
-                  title: Text(
-                    context.l10n.downloadTitle,
-                    style: TextStyle(
-                      fontSize: 20 + (8 * expandRatio), // 20 -> 28
-                      fontWeight: FontWeight.bold,
-                      color: colorScheme.onSurface,
+              expandedHeight: 120 + topPadding,
+              collapsedHeight: kToolbarHeight,
+              floating: false,
+              pinned: true,
+              backgroundColor: colorScheme.surface,
+              surfaceTintColor: Colors.transparent,
+              leading: IconButton(
+                icon: const Icon(Icons.arrow_back),
+                onPressed: () => Navigator.pop(context),
+              ),
+              flexibleSpace: LayoutBuilder(
+                builder: (context, constraints) {
+                  final maxHeight = 120 + topPadding;
+                  final minHeight = kToolbarHeight + topPadding;
+                  final expandRatio =
+                      ((constraints.maxHeight - minHeight) /
+                              (maxHeight - minHeight))
+                          .clamp(0.0, 1.0);
+                  final leftPadding = 56 - (32 * expandRatio); // 56 -> 24
+                  return FlexibleSpaceBar(
+                    expandedTitleScale: 1.0,
+                    titlePadding: EdgeInsets.only(
+                      left: leftPadding,
+                      bottom: 16,
                     ),
-                  ),
-                );
-              },
+                    title: Text(
+                      context.l10n.downloadTitle,
+                      style: TextStyle(
+                        fontSize: 20 + (8 * expandRatio), // 20 -> 28
+                        fontWeight: FontWeight.bold,
+                        color: colorScheme.onSurface,
+                      ),
+                    ),
+                  );
+                },
+              ),
             ),
-          ),
 
             SliverToBoxAdapter(
               child: SettingsSectionHeader(title: context.l10n.sectionService),
@@ -157,7 +159,9 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
             ),
 
             SliverToBoxAdapter(
-              child: SettingsSectionHeader(title: context.l10n.sectionAudioQuality),
+              child: SettingsSectionHeader(
+                title: context.l10n.sectionAudioQuality,
+              ),
             ),
             SliverToBoxAdapter(
               child: SettingsGroup(
@@ -165,7 +169,7 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                   SettingsSwitchItem(
                     icon: Icons.tune,
                     title: context.l10n.downloadAskBeforeDownload,
-                    subtitle: isBuiltInService 
+                    subtitle: isBuiltInService
                         ? context.l10n.downloadAskQualitySubtitle
                         : 'Select a built-in service to enable',
                     value: settings.askQualityBeforeDownload,
@@ -174,7 +178,8 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                         .read(settingsProvider.notifier)
                         .setAskQualityBeforeDownload(value),
                   ),
-                  if (!settings.askQualityBeforeDownload && isBuiltInService) ...[
+                  if (!settings.askQualityBeforeDownload &&
+                      isBuiltInService) ...[
                     _QualityOption(
                       title: context.l10n.qualityFlacLossless,
                       subtitle: context.l10n.qualityFlacLosslessSubtitle,
@@ -204,7 +209,9 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                     if (isTidalService)
                       _QualityOption(
                         title: 'Lossy 320kbps',
-                        subtitle: _getTidalHighFormatLabel(settings.tidalHighFormat),
+                        subtitle: _getTidalHighFormatLabel(
+                          settings.tidalHighFormat,
+                        ),
                         isSelected: settings.audioQuality == 'HIGH',
                         onTap: () => ref
                             .read(settingsProvider.notifier)
@@ -215,8 +222,14 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                       SettingsItem(
                         icon: Icons.tune,
                         title: 'Lossy Format',
-                        subtitle: _getTidalHighFormatLabel(settings.tidalHighFormat),
-                        onTap: () => _showTidalHighFormatPicker(context, ref, settings.tidalHighFormat),
+                        subtitle: _getTidalHighFormatLabel(
+                          settings.tidalHighFormat,
+                        ),
+                        onTap: () => _showTidalHighFormatPicker(
+                          context,
+                          ref,
+                          settings.tidalHighFormat,
+                        ),
                         showDivider: false,
                       ),
                   ],
@@ -234,43 +247,46 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                           Expanded(
                             child: Text(
                               'Select Tidal, Qobuz, or Amazon above to configure quality',
-                              style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                                color: colorScheme.onSurfaceVariant,
-                              ),
+                              style: Theme.of(context).textTheme.bodySmall
+                                  ?.copyWith(
+                                    color: colorScheme.onSurfaceVariant,
+                                  ),
                             ),
                           ),
                         ],
                       ),
                     ),
+                  ],
                 ],
-              ],
+              ),
             ),
-          ),
 
-          SliverToBoxAdapter(
-            child: SettingsSectionHeader(title: context.l10n.sectionLyrics),
-          ),
-          SliverToBoxAdapter(
-            child: SettingsGroup(
-              children: [
-                SettingsItem(
-                  icon: Icons.lyrics_outlined,
-                  title: context.l10n.lyricsMode,
-                  subtitle: _getLyricsModeLabel(context, settings.lyricsMode),
-                  onTap: () => _showLyricsModePicker(
-                    context,
-                    ref,
-                    settings.lyricsMode,
+            SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: context.l10n.sectionLyrics),
+            ),
+            SliverToBoxAdapter(
+              child: SettingsGroup(
+                children: [
+                  SettingsItem(
+                    icon: Icons.lyrics_outlined,
+                    title: context.l10n.lyricsMode,
+                    subtitle: _getLyricsModeLabel(context, settings.lyricsMode),
+                    onTap: () => _showLyricsModePicker(
+                      context,
+                      ref,
+                      settings.lyricsMode,
+                    ),
+                    showDivider: false,
                   ),
-                  showDivider: false,
-                ),
-              ],
+                ],
+              ),
             ),
-          ),
 
-          SliverToBoxAdapter(
-            child: SettingsSectionHeader(title: context.l10n.sectionFileSettings),
-          ),
+            SliverToBoxAdapter(
+              child: SettingsSectionHeader(
+                title: context.l10n.sectionFileSettings,
+              ),
+            ),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [
@@ -309,7 +325,9 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                     SettingsItem(
                       icon: Icons.folder_outlined,
                       title: context.l10n.downloadAlbumFolderStructure,
-                      subtitle: _getAlbumFolderStructureLabel(settings.albumFolderStructure),
+                      subtitle: _getAlbumFolderStructureLabel(
+                        settings.albumFolderStructure,
+                      ),
                       onTap: () => _showAlbumFolderStructurePicker(
                         context,
                         ref,
@@ -347,7 +365,11 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                     subtitle: settings.downloadNetworkMode == 'wifi_only'
                         ? context.l10n.settingsDownloadNetworkWifiOnly
                         : context.l10n.settingsDownloadNetworkAny,
-                    onTap: () => _showNetworkModePicker(context, ref, settings.downloadNetworkMode),
+                    onTap: () => _showNetworkModePicker(
+                      context,
+                      ref,
+                      settings.downloadNetworkMode,
+                    ),
                   ),
                   SettingsSwitchItem(
                     icon: Icons.file_download_outlined,
@@ -355,7 +377,9 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                     subtitle: context.l10n.settingsAutoExportFailedSubtitle,
                     value: settings.autoExportFailedDownloads,
                     onChanged: (value) {
-                      ref.read(settingsProvider.notifier).setAutoExportFailedDownloads(value);
+                      ref
+                          .read(settingsProvider.notifier)
+                          .setAutoExportFailedDownloads(value);
                     },
                     showDivider: false,
                   ),
@@ -366,7 +390,9 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
             // All Files Access section (Android 13+ only)
             if (Platform.isAndroid && _androidSdkVersion >= 33) ...[
               SliverToBoxAdapter(
-                child: SettingsSectionHeader(title: context.l10n.sectionStorageAccess),
+                child: SettingsSectionHeader(
+                  title: context.l10n.sectionStorageAccess,
+                ),
               ),
               SliverToBoxAdapter(
                 child: SettingsGroup(
@@ -405,16 +431,15 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                       Expanded(
                         child: Text(
                           context.l10n.allFilesAccessDescription,
-                          style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                            color: colorScheme.onSurfaceVariant,
-                          ),
+                          style: Theme.of(context).textTheme.bodySmall
+                              ?.copyWith(color: colorScheme.onSurfaceVariant),
                         ),
                       ),
                     ],
                   ),
                 ),
               ),
-],
+            ],
 
             const SliverToBoxAdapter(child: SizedBox(height: 32)),
           ],
@@ -438,7 +463,11 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
     }
   }
 
-  void _showAlbumFolderStructurePicker(BuildContext context, WidgetRef ref, String current) {
+  void _showAlbumFolderStructurePicker(
+    BuildContext context,
+    WidgetRef ref,
+    String current,
+  ) {
     showModalBottomSheet(
       context: context,
       builder: (context) => SafeArea(
@@ -449,9 +478,13 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
               leading: const Icon(Icons.folder_outlined),
               title: Text(context.l10n.albumFolderArtistAlbum),
               subtitle: Text(context.l10n.albumFolderArtistAlbumSubtitle),
-              trailing: current == 'artist_album' ? const Icon(Icons.check) : null,
+              trailing: current == 'artist_album'
+                  ? const Icon(Icons.check)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setAlbumFolderStructure('artist_album');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setAlbumFolderStructure('artist_album');
                 Navigator.pop(context);
               },
             ),
@@ -459,9 +492,13 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
               leading: const Icon(Icons.calendar_today_outlined),
               title: Text(context.l10n.albumFolderArtistYearAlbum),
               subtitle: Text(context.l10n.albumFolderArtistYearAlbumSubtitle),
-              trailing: current == 'artist_year_album' ? const Icon(Icons.check) : null,
+              trailing: current == 'artist_year_album'
+                  ? const Icon(Icons.check)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setAlbumFolderStructure('artist_year_album');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setAlbumFolderStructure('artist_year_album');
                 Navigator.pop(context);
               },
             ),
@@ -469,9 +506,13 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
               leading: const Icon(Icons.album_outlined),
               title: Text(context.l10n.albumFolderAlbumOnly),
               subtitle: Text(context.l10n.albumFolderAlbumOnlySubtitle),
-              trailing: current == 'album_only' ? const Icon(Icons.check) : null,
+              trailing: current == 'album_only'
+                  ? const Icon(Icons.check)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setAlbumFolderStructure('album_only');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setAlbumFolderStructure('album_only');
                 Navigator.pop(context);
               },
             ),
@@ -479,19 +520,29 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
               leading: const Icon(Icons.event_outlined),
               title: Text(context.l10n.albumFolderYearAlbum),
               subtitle: Text(context.l10n.albumFolderYearAlbumSubtitle),
-              trailing: current == 'year_album' ? const Icon(Icons.check) : null,
+              trailing: current == 'year_album'
+                  ? const Icon(Icons.check)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setAlbumFolderStructure('year_album');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setAlbumFolderStructure('year_album');
                 Navigator.pop(context);
               },
             ),
             ListTile(
               leading: const Icon(Icons.person_outlined),
               title: Text(context.l10n.albumFolderArtistAlbumSingles),
-              subtitle: Text(context.l10n.albumFolderArtistAlbumSinglesSubtitle),
-              trailing: current == 'artist_album_singles' ? const Icon(Icons.check) : null,
+              subtitle: Text(
+                context.l10n.albumFolderArtistAlbumSinglesSubtitle,
+              ),
+              trailing: current == 'artist_album_singles'
+                  ? const Icon(Icons.check)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setAlbumFolderStructure('artist_album_singles');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setAlbumFolderStructure('artist_album_singles');
                 Navigator.pop(context);
               },
             ),
@@ -634,7 +685,7 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                   Row(
                     children: [
                       Expanded(
-                          child: TextButton(
+                        child: TextButton(
                           onPressed: () => Navigator.pop(context),
                           style: TextButton.styleFrom(
                             padding: const EdgeInsets.symmetric(vertical: 16),
@@ -680,13 +731,123 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
     if (Platform.isIOS) {
       _showIOSDirectoryOptions(context, ref);
     } else {
-      final result = await FilePicker.platform.getDirectoryPath();
-      if (result != null) {
-        ref.read(settingsProvider.notifier).setDownloadDirectory(result);
-      }
+      _showAndroidDirectoryOptions(context, ref);
     }
   }
 
+  Future<String> _getDefaultAndroidDirectory() async {
+    final directMusicPath = '/storage/emulated/0/Music/SpotiFLAC';
+    try {
+      final musicDir = Directory(directMusicPath);
+      if (!await musicDir.exists()) {
+        await musicDir.create(recursive: true);
+      }
+      return musicDir.path;
+    } catch (_) {}
+
+    try {
+      final externalDir = await getExternalStorageDirectory();
+      if (externalDir != null) {
+        final musicDir = Directory(
+          '${externalDir.parent.parent.parent.parent.path}/Music/SpotiFLAC',
+        );
+        if (!await musicDir.exists()) {
+          await musicDir.create(recursive: true);
+        }
+        return musicDir.path;
+      }
+    } catch (_) {}
+
+    final appDir = await getApplicationDocumentsDirectory();
+    final fallbackDir = Directory('${appDir.path}/SpotiFLAC');
+    if (!await fallbackDir.exists()) {
+      await fallbackDir.create(recursive: true);
+    }
+    return fallbackDir.path;
+  }
+
+  void _showAndroidDirectoryOptions(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final settings = ref.read(settingsProvider);
+    final isSafMode =
+        settings.storageMode == 'saf' && settings.downloadTreeUri.isNotEmpty;
+    showModalBottomSheet(
+      context: context,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
+      builder: (ctx) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
+              child: Text(
+                'Download Location',
+                style: Theme.of(
+                  ctx,
+                ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
+              ),
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+              child: Text(
+                'Choose storage mode for downloaded files.',
+                style: Theme.of(ctx).textTheme.bodyMedium?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ),
+            ListTile(
+              leading: Icon(Icons.folder_special, color: colorScheme.primary),
+              title: const Text('App folder (non-SAF)'),
+              subtitle: const Text('Use default Music/SpotiFLAC path'),
+              trailing: !isSafMode ? const Icon(Icons.check) : null,
+              onTap: () async {
+                Navigator.pop(ctx);
+                final defaultDir = await _getDefaultAndroidDirectory();
+                final notifier = ref.read(settingsProvider.notifier);
+                notifier.setStorageMode('app');
+                notifier.setDownloadDirectory(defaultDir);
+                notifier.setDownloadTreeUri('');
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.folder_open, color: colorScheme.primary),
+              title: const Text('SAF folder'),
+              subtitle: const Text(
+                'Pick folder via Android Storage Access Framework',
+              ),
+              trailing: isSafMode ? const Icon(Icons.check) : null,
+              onTap: () async {
+                Navigator.pop(ctx);
+                final result = await PlatformBridge.pickSafTree();
+                if (result != null) {
+                  final treeUri = result['tree_uri'] as String? ?? '';
+                  final displayName = result['display_name'] as String? ?? '';
+                  if (treeUri.isNotEmpty) {
+                    ref.read(settingsProvider.notifier).setStorageMode('saf');
+                    ref
+                        .read(settingsProvider.notifier)
+                        .setDownloadTreeUri(
+                          treeUri,
+                          displayName: displayName.isNotEmpty
+                              ? displayName
+                              : treeUri,
+                        );
+                  }
+                }
+              },
+            ),
+            const SizedBox(height: 8),
+          ],
+        ),
+      ),
+    );
+  }
+
   void _showIOSDirectoryOptions(BuildContext context, WidgetRef ref) {
     final colorScheme = Theme.of(context).colorScheme;
     showModalBottomSheet(
@@ -731,7 +892,7 @@ class _DownloadSettingsPageState extends ConsumerState<DownloadSettingsPage> {
                 if (ctx.mounted) Navigator.pop(ctx);
               },
             ),
-ListTile(
+            ListTile(
               leading: Icon(Icons.cloud, color: colorScheme.onSurfaceVariant),
               title: Text(context.l10n.setupChooseFromFiles),
               subtitle: Text(context.l10n.setupChooseFromFilesSubtitle),
@@ -742,7 +903,8 @@ ListTile(
                 if (result != null) {
                   // iOS: Check if user selected iCloud Drive (not accessible by Go backend)
                   if (Platform.isIOS) {
-                    final isICloudPath = result.contains('Mobile Documents') ||
+                    final isICloudPath =
+                        result.contains('Mobile Documents') ||
                         result.contains('CloudDocs') ||
                         result.contains('com~apple~CloudDocs');
                     if (isICloudPath) {
@@ -899,6 +1061,8 @@ ListTile(
     switch (format) {
       case 'mp3_320':
         return 'MP3 320kbps';
+      case 'opus_256':
+        return 'Opus 256kbps';
       case 'opus_128':
         return 'Opus 128kbps';
       default:
@@ -945,19 +1109,41 @@ ListTile(
               leading: const Icon(Icons.audiotrack),
               title: const Text('MP3 320kbps'),
               subtitle: const Text('Best compatibility, ~10MB per track'),
-              trailing: current == 'mp3_320' ? Icon(Icons.check, color: colorScheme.primary) : null,
+              trailing: current == 'mp3_320'
+                  ? Icon(Icons.check, color: colorScheme.primary)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setTidalHighFormat('mp3_320');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setTidalHighFormat('mp3_320');
+                Navigator.pop(context);
+              },
+            ),
+            ListTile(
+              leading: const Icon(Icons.graphic_eq),
+              title: const Text('Opus 256kbps'),
+              subtitle: const Text('Best quality Opus, ~8MB per track'),
+              trailing: current == 'opus_256'
+                  ? Icon(Icons.check, color: colorScheme.primary)
+                  : null,
+              onTap: () {
+                ref
+                    .read(settingsProvider.notifier)
+                    .setTidalHighFormat('opus_256');
                 Navigator.pop(context);
               },
             ),
             ListTile(
               leading: const Icon(Icons.graphic_eq),
               title: const Text('Opus 128kbps'),
-              subtitle: const Text('Modern codec, ~4MB per track'),
-              trailing: current == 'opus_128' ? Icon(Icons.check, color: colorScheme.primary) : null,
+              subtitle: const Text('Smallest size, ~4MB per track'),
+              trailing: current == 'opus_128'
+                  ? Icon(Icons.check, color: colorScheme.primary)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setTidalHighFormat('opus_128');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setTidalHighFormat('opus_128');
                 Navigator.pop(context);
               },
             ),
@@ -1007,9 +1193,13 @@ ListTile(
               leading: const Icon(Icons.signal_cellular_alt),
               title: Text(context.l10n.settingsDownloadNetworkAny),
               subtitle: const Text('WiFi + Mobile Data'),
-              trailing: current == 'any' ? Icon(Icons.check, color: colorScheme.primary) : null,
+              trailing: current == 'any'
+                  ? Icon(Icons.check, color: colorScheme.primary)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setDownloadNetworkMode('any');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setDownloadNetworkMode('any');
                 Navigator.pop(context);
               },
             ),
@@ -1017,9 +1207,13 @@ ListTile(
               leading: const Icon(Icons.wifi),
               title: Text(context.l10n.settingsDownloadNetworkWifiOnly),
               subtitle: const Text('Pause downloads on mobile data'),
-              trailing: current == 'wifi_only' ? Icon(Icons.check, color: colorScheme.primary) : null,
+              trailing: current == 'wifi_only'
+                  ? Icon(Icons.check, color: colorScheme.primary)
+                  : null,
               onTap: () {
-                ref.read(settingsProvider.notifier).setDownloadNetworkMode('wifi_only');
+                ref
+                    .read(settingsProvider.notifier)
+                    .setDownloadNetworkMode('wifi_only');
                 Navigator.pop(context);
               },
             ),
@@ -1076,7 +1270,9 @@ ListTile(
                 example: 'SpotiFLAC/Track.flac',
                 isSelected: current == 'none',
                 onTap: () {
-                  ref.read(settingsProvider.notifier).setFolderOrganization('none');
+                  ref
+                      .read(settingsProvider.notifier)
+                      .setFolderOrganization('none');
                   Navigator.pop(context);
                 },
               ),
@@ -1086,7 +1282,9 @@ ListTile(
                 example: 'SpotiFLAC/Artist Name/Track.flac',
                 isSelected: current == 'artist',
                 onTap: () {
-                  ref.read(settingsProvider.notifier).setFolderOrganization('artist');
+                  ref
+                      .read(settingsProvider.notifier)
+                      .setFolderOrganization('artist');
                   Navigator.pop(context);
                 },
               ),
@@ -1096,7 +1294,9 @@ ListTile(
                 example: 'SpotiFLAC/Album Name/Track.flac',
                 isSelected: current == 'album',
                 onTap: () {
-                  ref.read(settingsProvider.notifier).setFolderOrganization('album');
+                  ref
+                      .read(settingsProvider.notifier)
+                      .setFolderOrganization('album');
                   Navigator.pop(context);
                 },
               ),
@@ -1106,7 +1306,9 @@ ListTile(
                 example: 'SpotiFLAC/Artist/Album/Track.flac',
                 isSelected: current == 'artist_album',
                 onTap: () {
-                  ref.read(settingsProvider.notifier).setFolderOrganization('artist_album');
+                  ref
+                      .read(settingsProvider.notifier)
+                      .setFolderOrganization('artist_album');
                   Navigator.pop(context);
                 },
               ),
@@ -1130,18 +1332,22 @@ class _ServiceSelector extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final extState = ref.watch(extensionProvider);
-    
+
     final extensionProviders = extState.extensions
         .where((e) => e.enabled && e.hasDownloadProvider)
         .toList();
-    
-    final isExtensionService = !['tidal', 'qobuz', 'amazon'].contains(currentService);
-    final isCurrentExtensionEnabled = isExtensionService 
+
+    final isExtensionService = ![
+      'tidal',
+      'qobuz',
+      'amazon',
+    ].contains(currentService);
+    final isCurrentExtensionEnabled = isExtensionService
         ? extensionProviders.any((e) => e.id == currentService)
         : true;
-    
+
     final effectiveService = isCurrentExtensionEnabled ? currentService : '';
-    
+
     return Padding(
       padding: const EdgeInsets.all(12),
       child: Column(
@@ -1167,6 +1373,7 @@ class _ServiceSelector extends ConsumerWidget {
                 label: 'Amazon',
                 isSelected: effectiveService == 'amazon',
                 isDisabled: true,
+                disabledReason: 'Coming soon',
                 onTap: () {},
               ),
             ],
@@ -1241,8 +1448,8 @@ class _ServiceChip extends StatelessWidget {
           color: isDisabled
               ? disabledColor
               : isSelected
-                  ? colorScheme.primaryContainer
-                  : unselectedColor,
+              ? colorScheme.primaryContainer
+              : unselectedColor,
           borderRadius: BorderRadius.circular(12),
           child: InkWell(
             onTap: isDisabled ? null : onTap,
@@ -1256,8 +1463,8 @@ class _ServiceChip extends StatelessWidget {
                     color: isDisabled
                         ? colorScheme.onSurface.withValues(alpha: 0.38)
                         : isSelected
-                            ? colorScheme.onPrimaryContainer
-                            : colorScheme.onSurfaceVariant,
+                        ? colorScheme.onPrimaryContainer
+                        : colorScheme.onSurfaceVariant,
                   ),
                   const SizedBox(height: 6),
                   Text(
@@ -1270,8 +1477,8 @@ class _ServiceChip extends StatelessWidget {
                       color: isDisabled
                           ? colorScheme.onSurface.withValues(alpha: 0.38)
                           : isSelected
-                              ? colorScheme.onPrimaryContainer
-                              : colorScheme.onSurfaceVariant,
+                          ? colorScheme.onPrimaryContainer
+                          : colorScheme.onSurfaceVariant,
                     ),
                   ),
                   if (isDisabled && disabledReason != null)

lib/screens/settings/library_settings_page.dart

@@ -117,7 +117,8 @@ class _LibrarySettingsPageState extends ConsumerState<LibrarySettingsPage> {
       return;
     }
 
-    if (!await Directory(libraryPath).exists()) {
+    if (!libraryPath.startsWith('content://') &&
+        !await Directory(libraryPath).exists()) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(content: Text(context.l10n.libraryFolderNotExist)),
@@ -290,6 +291,53 @@ class _LibrarySettingsPageState extends ConsumerState<LibrarySettingsPage> {
             SliverToBoxAdapter(
               child: SettingsSectionHeader(title: context.l10n.libraryActions),
             ),
+            if (libraryState.scanWasCancelled)
+              SliverToBoxAdapter(
+                child: Padding(
+                  padding: const EdgeInsets.fromLTRB(16, 8, 16, 4),
+                  child: Container(
+                    padding: const EdgeInsets.all(12),
+                    decoration: BoxDecoration(
+                      color: colorScheme.tertiaryContainer.withValues(alpha: 0.6),
+                      borderRadius: BorderRadius.circular(12),
+                    ),
+                    child: Row(
+                      children: [
+                        Icon(
+                          Icons.warning_amber_outlined,
+                          color: colorScheme.onTertiaryContainer,
+                        ),
+                        const SizedBox(width: 12),
+                        Expanded(
+                          child: Column(
+                            crossAxisAlignment: CrossAxisAlignment.start,
+                            children: [
+                              Text(
+                                'Scan cancelled',
+                                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                                  fontWeight: FontWeight.w600,
+                                  color: colorScheme.onTertiaryContainer,
+                                ),
+                              ),
+                              const SizedBox(height: 2),
+                              Text(
+                                'You can retry the scan when ready.',
+                                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                                  color: colorScheme.onTertiaryContainer.withValues(alpha: 0.8),
+                                ),
+                              ),
+                            ],
+                          ),
+                        ),
+                        TextButton(
+                          onPressed: _startScan,
+                          child: Text(context.l10n.dialogRetry),
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [

lib/screens/setup_screen.dart

@@ -9,6 +9,7 @@ import 'package:go_router/go_router.dart';
 import 'package:device_info_plus/device_info_plus.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
 
 class SetupScreen extends ConsumerStatefulWidget {
   const SetupScreen({super.key});
@@ -22,6 +23,7 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
   bool _storagePermissionGranted = false;
   bool _notificationPermissionGranted = false;
   String? _selectedDirectory;
+  String? _selectedTreeUri;
   bool _isLoading = false;
   int _androidSdkVersion = 0;
   
@@ -246,13 +248,19 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       if (Platform.isIOS) {
         await _showIOSDirectoryOptions();
       } else {
-        String? selectedDirectory = await FilePicker.platform.getDirectoryPath(
-          dialogTitle: context.l10n.setupSelectDownloadFolder,
-        );
+        final result = await PlatformBridge.pickSafTree();
+        if (result != null) {
+          final treeUri = result['tree_uri'] as String? ?? '';
+          final displayName = result['display_name'] as String? ?? '';
+          if (treeUri.isNotEmpty) {
+            setState(() {
+              _selectedTreeUri = treeUri;
+              _selectedDirectory = displayName.isNotEmpty ? displayName : treeUri;
+            });
+          }
+        }
 
-        if (selectedDirectory != null) {
-          setState(() => _selectedDirectory = selectedDirectory);
-        } else {
+        if (_selectedTreeUri == null || _selectedTreeUri!.isEmpty) {
           final defaultDir = await _getDefaultDirectory();
           if (mounted) {
             final useDefault = await showDialog<bool>(
@@ -268,7 +276,10 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
             );
 
             if (useDefault == true) {
-              setState(() => _selectedDirectory = defaultDir);
+              setState(() {
+                _selectedTreeUri = '';
+                _selectedDirectory = defaultDir;
+              });
             }
           }
         }
@@ -387,12 +398,21 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
     setState(() => _isLoading = true);
 
     try {
-      final dir = Directory(_selectedDirectory!);
-      if (!await dir.exists()) {
-        await dir.create(recursive: true);
+      if (!Platform.isAndroid || _selectedTreeUri == null || _selectedTreeUri!.isEmpty) {
+        final dir = Directory(_selectedDirectory!);
+        if (!await dir.exists()) {
+          await dir.create(recursive: true);
+        }
+        ref.read(settingsProvider.notifier).setStorageMode('app');
+        ref.read(settingsProvider.notifier).setDownloadDirectory(_selectedDirectory!);
+        ref.read(settingsProvider.notifier).setDownloadTreeUri('');
+      } else {
+        ref.read(settingsProvider.notifier).setStorageMode('saf');
+        ref.read(settingsProvider.notifier).setDownloadTreeUri(
+          _selectedTreeUri!,
+          displayName: _selectedDirectory,
+        );
       }
-
-      ref.read(settingsProvider.notifier).setDownloadDirectory(_selectedDirectory!);
       
       if (_useSpotifyApi && 
           _clientIdController.text.trim().isNotEmpty && 

lib/screens/track_metadata_screen.dart

@@ -3,11 +3,10 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
-import 'package:open_filex/open_filex.dart';
 import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/services/library_database.dart';
 import 'package:spotiflac_android/services/palette_service.dart';
-import 'package:spotiflac_android/utils/mime_utils.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 import 'package:url_launcher/url_launcher.dart';
 import 'package:share_plus/share_plus.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
@@ -128,9 +127,9 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
     bool exists = false;
     int? size;
     try {
-      final stat = await FileStat.stat(filePath);
-      exists = stat.type != FileSystemEntityType.notFound;
-      if (exists) {
+      final stat = await fileStat(filePath);
+      if (stat != null) {
+        exists = true;
         size = stat.size;
       }
     } catch (_) {}
@@ -1212,10 +1211,7 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
               if (_isLocalItem) {
                 // For local items, just delete the file
                 try {
-                  final file = File(cleanFilePath);
-                  if (await file.exists()) {
-                    await file.delete();
-                  }
+                  await deleteFile(cleanFilePath);
                 } catch (e) {
                   debugPrint('Failed to delete file: $e');
                 }
@@ -1224,10 +1220,7 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
               } else {
                 // Existing download history deletion logic
                 try {
-                  final file = File(cleanFilePath);
-                  if (await file.exists()) {
-                    await file.delete();
-                  }
+                  await deleteFile(cleanFilePath);
                 } catch (e) {
                   debugPrint('Failed to delete file: $e');
                 }
@@ -1249,13 +1242,7 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
 
   Future<void> _openFile(BuildContext context, String filePath) async {
     try {
-      final mimeType = audioMimeTypeForPath(filePath);
-      final result = await OpenFilex.open(filePath, type: mimeType);
-      if (result.type != ResultType.done && context.mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text(context.l10n.trackCannotOpen(result.message))),
-        );
-      }
+      await openFile(filePath);
     } catch (e) {
       if (context.mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
@@ -1276,8 +1263,8 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   }
 
   Future<void> _shareFile(BuildContext context) async {
-    final file = File(cleanFilePath);
-    if (!await file.exists()) {
+    String sharePath = cleanFilePath;
+    if (!await fileExists(sharePath)) {
       if (context.mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(content: Text(context.l10n.snackbarFileNotFound)),
@@ -1285,10 +1272,23 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
       }
       return;
     }
+
+    if (isContentUri(sharePath)) {
+      final tempPath = await PlatformBridge.copyContentUriToTemp(sharePath);
+      if (tempPath == null || tempPath.isEmpty) {
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(content: Text(context.l10n.snackbarCannotOpenFile('Failed to prepare file for sharing'))),
+          );
+        }
+        return;
+      }
+      sharePath = tempPath;
+    }
     
     await SharePlus.instance.share(
       ShareParams(
-        files: [XFile(cleanFilePath)],
+        files: [XFile(sharePath)],
         text: '$trackName - $artistName',
       ),
     );

lib/services/ffmpeg_service.dart

@@ -10,12 +10,28 @@ import 'package:spotiflac_android/utils/logger.dart';
 final _log = AppLogger('FFmpeg');
 
 class FFmpegService {
+  static String _buildOutputPath(String inputPath, String extension) {
+    final normalizedExt = extension.startsWith('.') ? extension : '.$extension';
+    final inputFile = File(inputPath);
+    final dir = inputFile.parent.path;
+    final filename = inputFile.uri.pathSegments.last;
+    final dotIndex = filename.lastIndexOf('.');
+    final baseName = dotIndex > 0 ? filename.substring(0, dotIndex) : filename;
+    var outputPath = '$dir${Platform.pathSeparator}$baseName$normalizedExt';
+
+    if (outputPath == inputPath) {
+      outputPath =
+          '$dir${Platform.pathSeparator}${baseName}_converted$normalizedExt';
+    }
+    return outputPath;
+  }
+
   static Future<FFmpegResult> _execute(String command) async {
     try {
       final session = await FFmpegKit.execute(command);
       final returnCode = await session.getReturnCode();
       final output = await session.getOutput() ?? '';
-      
+
       return FFmpegResult(
         success: ReturnCode.isSuccess(returnCode),
         returnCode: returnCode?.getValue() ?? -1,
@@ -28,7 +44,7 @@ class FFmpegService {
   }
 
   static Future<String?> convertM4aToFlac(String inputPath) async {
-    final outputPath = inputPath.replaceAll('.m4a', '.flac');
+    final outputPath = _buildOutputPath(inputPath, '.flac');
 
     final command =
         '-i "$inputPath" -c:a flac -compression_level 8 "$outputPath" -y';
@@ -59,10 +75,10 @@ class FFmpegService {
         bitrateValue = '${parts[1]}k';
       }
     }
-    
+
     final extension = format == 'opus' ? '.opus' : '.mp3';
-    final outputPath = inputPath.replaceAll('.m4a', extension);
-    
+    final outputPath = _buildOutputPath(inputPath, extension);
+
     String command;
     if (format == 'opus') {
       command =
@@ -92,7 +108,7 @@ class FFmpegService {
     String bitrate = '320k',
     bool deleteOriginal = true,
   }) async {
-    final outputPath = inputPath.replaceAll('.flac', '.mp3');
+    final outputPath = _buildOutputPath(inputPath, '.mp3');
 
     final command =
         '-i "$inputPath" -codec:a libmp3lame -b:a $bitrate -map 0:a -map_metadata 0 -id3v2_version 3 "$outputPath" -y';
@@ -117,7 +133,7 @@ class FFmpegService {
     String bitrate = '128k',
     bool deleteOriginal = true,
   }) async {
-    final outputPath = inputPath.replaceAll('.flac', '.opus');
+    final outputPath = _buildOutputPath(inputPath, '.opus');
 
     final command =
         '-i "$inputPath" -codec:a libopus -b:a $bitrate -vbr on -compression_level 10 -map 0:a -map_metadata 0 "$outputPath" -y';
@@ -150,15 +166,27 @@ class FFmpegService {
         bitrateValue = '${parts[1]}k';
       }
     }
-    
+
     switch (format.toLowerCase()) {
       case 'opus':
-        final opusBitrate = bitrate?.startsWith('opus_') == true ? bitrateValue : '128k';
-        return convertFlacToOpus(inputPath, bitrate: opusBitrate, deleteOriginal: deleteOriginal);
+        final opusBitrate = bitrate?.startsWith('opus_') == true
+            ? bitrateValue
+            : '128k';
+        return convertFlacToOpus(
+          inputPath,
+          bitrate: opusBitrate,
+          deleteOriginal: deleteOriginal,
+        );
       case 'mp3':
       default:
-        final mp3Bitrate = bitrate?.startsWith('mp3_') == true ? bitrateValue : '320k';
-        return convertFlacToMp3(inputPath, bitrate: mp3Bitrate, deleteOriginal: deleteOriginal);
+        final mp3Bitrate = bitrate?.startsWith('mp3_') == true
+            ? bitrateValue
+            : '320k';
+        return convertFlacToMp3(
+          inputPath,
+          bitrate: mp3Bitrate,
+          deleteOriginal: deleteOriginal,
+        );
     }
   }
 
@@ -168,8 +196,10 @@ class FFmpegService {
     String bitrate = '256k',
   }) async {
     final dir = File(inputPath).parent.path;
-    final baseName =
-        inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
+    final baseName = inputPath
+        .split(Platform.pathSeparator)
+        .last
+        .replaceAll('.flac', '');
     final outputDir = '$dir${Platform.pathSeparator}M4A';
 
     await Directory(outputDir).create(recursive: true);
@@ -220,16 +250,16 @@ class FFmpegService {
     final tempDir = await getTemporaryDirectory();
     final uniqueId = DateTime.now().millisecondsSinceEpoch;
     final tempOutput = '${tempDir.path}/temp_embed_$uniqueId.flac';
-    
+
     final StringBuffer cmdBuffer = StringBuffer();
     cmdBuffer.write('-i "$flacPath" ');
-    
+
     if (coverPath != null) {
       cmdBuffer.write('-i "$coverPath" ');
     }
-    
+
     cmdBuffer.write('-map 0:a ');
-    
+
     if (coverPath != null) {
       cmdBuffer.write('-map 1:0 ');
       cmdBuffer.write('-c:v copy ');
@@ -237,18 +267,18 @@ class FFmpegService {
       cmdBuffer.write('-metadata:s:v title="Album cover" ');
       cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
     }
-    
+
     cmdBuffer.write('-c:a copy ');
-    
+
     if (metadata != null) {
       metadata.forEach((key, value) {
         final sanitizedValue = value.replaceAll('"', '\\"');
         cmdBuffer.write('-metadata $key="$sanitizedValue" ');
       });
     }
-    
+
     cmdBuffer.write('"$tempOutput" -y');
-    
+
     final command = cmdBuffer.toString();
     _log.d('Executing FFmpeg command: $command');
 
@@ -258,20 +288,19 @@ class FFmpegService {
       try {
         final tempFile = File(tempOutput);
         final originalFile = File(flacPath);
-        
-        if (await tempFile.exists()) {
-             if (await originalFile.exists()) {
-               await originalFile.delete();
-             }
-             await tempFile.copy(flacPath);
-             await tempFile.delete();
-             
-             return flacPath;
-        } else {
-             _log.e('Temp output file not found: $tempOutput');
-             return null;
-        }
 
+        if (await tempFile.exists()) {
+          if (await originalFile.exists()) {
+            await originalFile.delete();
+          }
+          await tempFile.copy(flacPath);
+          await tempFile.delete();
+
+          return flacPath;
+        } else {
+          _log.e('Temp output file not found: $tempOutput');
+          return null;
+        }
       } catch (e) {
         _log.e('Failed to replace file after metadata embed: $e');
         return null;
@@ -299,16 +328,16 @@ class FFmpegService {
     final tempDir = await getTemporaryDirectory();
     final uniqueId = DateTime.now().millisecondsSinceEpoch;
     final tempOutput = '${tempDir.path}/temp_embed_$uniqueId.mp3';
-    
+
     final StringBuffer cmdBuffer = StringBuffer();
     cmdBuffer.write('-i "$mp3Path" ');
-    
+
     if (coverPath != null) {
       cmdBuffer.write('-i "$coverPath" ');
     }
-    
+
     cmdBuffer.write('-map 0:a ');
-    
+
     if (coverPath != null) {
       cmdBuffer.write('-map 1:0 ');
       cmdBuffer.write('-c:v:0 copy ');
@@ -316,9 +345,9 @@ class FFmpegService {
       cmdBuffer.write('-metadata:s:v title="Album cover" ');
       cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
     }
-    
+
     cmdBuffer.write('-c:a copy ');
-    
+
     if (metadata != null) {
       final id3Metadata = _convertToId3Tags(metadata);
       id3Metadata.forEach((key, value) {
@@ -326,9 +355,9 @@ class FFmpegService {
         cmdBuffer.write('-metadata $key="$sanitizedValue" ');
       });
     }
-    
+
     cmdBuffer.write('-id3v2_version 3 "$tempOutput" -y');
-    
+
     final command = cmdBuffer.toString();
     _log.d('Executing FFmpeg MP3 embed command: $command');
 
@@ -338,21 +367,20 @@ class FFmpegService {
       try {
         final tempFile = File(tempOutput);
         final originalFile = File(mp3Path);
-        
-        if (await tempFile.exists()) {
-             if (await originalFile.exists()) {
-               await originalFile.delete();
-             }
-             await tempFile.copy(mp3Path);
-             await tempFile.delete();
-             
-             _log.d('MP3 metadata embedded successfully');
-             return mp3Path;
-        } else {
-             _log.e('Temp MP3 output file not found: $tempOutput');
-             return null;
-        }
 
+        if (await tempFile.exists()) {
+          if (await originalFile.exists()) {
+            await originalFile.delete();
+          }
+          await tempFile.copy(mp3Path);
+          await tempFile.delete();
+
+          _log.d('MP3 metadata embedded successfully');
+          return mp3Path;
+        } else {
+          _log.e('Temp MP3 output file not found: $tempOutput');
+          return null;
+        }
       } catch (e) {
         _log.e('Failed to replace MP3 file after metadata embed: $e');
         return null;
@@ -380,26 +408,28 @@ class FFmpegService {
     final tempDir = await getTemporaryDirectory();
     final uniqueId = DateTime.now().millisecondsSinceEpoch;
     final tempOutput = '${tempDir.path}/temp_embed_$uniqueId.opus';
-    
+
     final StringBuffer cmdBuffer = StringBuffer();
     cmdBuffer.write('-i "$opusPath" ');
     cmdBuffer.write('-map 0:a ');
     cmdBuffer.write('-c:a copy ');
-    
+
     if (metadata != null) {
       metadata.forEach((key, value) {
         final sanitizedValue = value.replaceAll('"', '\\"');
         cmdBuffer.write('-metadata $key="$sanitizedValue" ');
       });
     }
-    
+
     if (coverPath != null) {
       try {
         final pictureBlock = await _createMetadataBlockPicture(coverPath);
         if (pictureBlock != null) {
           final escapedBlock = pictureBlock.replaceAll('"', '\\"');
           cmdBuffer.write('-metadata METADATA_BLOCK_PICTURE="$escapedBlock" ');
-          _log.d('Created METADATA_BLOCK_PICTURE for Opus (${pictureBlock.length} chars)');
+          _log.d(
+            'Created METADATA_BLOCK_PICTURE for Opus (${pictureBlock.length} chars)',
+          );
         } else {
           _log.w('Failed to create METADATA_BLOCK_PICTURE, skipping cover');
         }
@@ -407,9 +437,9 @@ class FFmpegService {
         _log.e('Error creating METADATA_BLOCK_PICTURE: $e');
       }
     }
-    
+
     cmdBuffer.write('"$tempOutput" -y');
-    
+
     final command = cmdBuffer.toString();
     _log.d('Executing FFmpeg Opus embed command');
 
@@ -419,21 +449,20 @@ class FFmpegService {
       try {
         final tempFile = File(tempOutput);
         final originalFile = File(opusPath);
-        
-        if (await tempFile.exists()) {
-             if (await originalFile.exists()) {
-               await originalFile.delete();
-             }
-             await tempFile.copy(opusPath);
-             await tempFile.delete();
-             
-             _log.d('Opus metadata embedded successfully');
-             return opusPath;
-        } else {
-             _log.e('Temp Opus output file not found: $tempOutput');
-             return null;
-        }
 
+        if (await tempFile.exists()) {
+          if (await originalFile.exists()) {
+            await originalFile.delete();
+          }
+          await tempFile.copy(opusPath);
+          await tempFile.delete();
+
+          _log.d('Opus metadata embedded successfully');
+          return opusPath;
+        } else {
+          _log.e('Temp Opus output file not found: $tempOutput');
+          return null;
+        }
       } catch (e) {
         _log.e('Failed to replace Opus file after metadata embed: $e');
         return null;
@@ -460,81 +489,94 @@ class FFmpegService {
         _log.e('Cover image not found: $imagePath');
         return null;
       }
-      
+
       final imageData = await file.readAsBytes();
-      
+
       String mimeType;
       if (imagePath.toLowerCase().endsWith('.png')) {
         mimeType = 'image/png';
-      } else if (imagePath.toLowerCase().endsWith('.jpg') || 
-                 imagePath.toLowerCase().endsWith('.jpeg')) {
+      } else if (imagePath.toLowerCase().endsWith('.jpg') ||
+          imagePath.toLowerCase().endsWith('.jpeg')) {
         mimeType = 'image/jpeg';
       } else {
-        if (imageData.length >= 8 && 
-            imageData[0] == 0x89 && imageData[1] == 0x50 && 
-            imageData[2] == 0x4E && imageData[3] == 0x47) {
+        if (imageData.length >= 8 &&
+            imageData[0] == 0x89 &&
+            imageData[1] == 0x50 &&
+            imageData[2] == 0x4E &&
+            imageData[3] == 0x47) {
           mimeType = 'image/png';
-        } else if (imageData.length >= 2 && 
-                   imageData[0] == 0xFF && imageData[1] == 0xD8) {
+        } else if (imageData.length >= 2 &&
+            imageData[0] == 0xFF &&
+            imageData[1] == 0xD8) {
           mimeType = 'image/jpeg';
         } else {
           mimeType = 'image/jpeg';
         }
       }
-      
+
       final mimeBytes = utf8.encode(mimeType);
       const description = '';
       final descBytes = utf8.encode(description);
-      
-      final blockSize = 4 + 4 + mimeBytes.length + 4 + descBytes.length + 
-                        4 + 4 + 4 + 4 + 4 + imageData.length;
-      
+
+      final blockSize =
+          4 +
+          4 +
+          mimeBytes.length +
+          4 +
+          descBytes.length +
+          4 +
+          4 +
+          4 +
+          4 +
+          4 +
+          imageData.length;
+
       final buffer = ByteData(blockSize);
       var offset = 0;
-      
+
       buffer.setUint32(offset, 3, Endian.big);
       offset += 4;
-      
+
       buffer.setUint32(offset, mimeBytes.length, Endian.big);
       offset += 4;
-      
+
       final blockBytes = Uint8List(blockSize);
       blockBytes.setRange(0, offset, buffer.buffer.asUint8List());
       blockBytes.setRange(offset, offset + mimeBytes.length, mimeBytes);
       offset += mimeBytes.length;
-      
+
       final tempBuffer = ByteData(4);
       tempBuffer.setUint32(0, descBytes.length, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       blockBytes.setRange(offset, offset + descBytes.length, descBytes);
       offset += descBytes.length;
-      
+
       tempBuffer.setUint32(0, 0, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       tempBuffer.setUint32(0, 0, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       tempBuffer.setUint32(0, 0, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       tempBuffer.setUint32(0, 0, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       tempBuffer.setUint32(0, imageData.length, Endian.big);
       blockBytes.setRange(offset, offset + 4, tempBuffer.buffer.asUint8List());
       offset += 4;
-      
+
       blockBytes.setRange(offset, offset + imageData.length, imageData);
-      
+
       final base64String = base64Encode(blockBytes);
-      
+
       return base64String;
     } catch (e) {
       _log.e('Error creating METADATA_BLOCK_PICTURE: $e');
@@ -542,13 +584,15 @@ class FFmpegService {
     }
   }
 
-  static Map<String, String> _convertToId3Tags(Map<String, String> vorbisMetadata) {
+  static Map<String, String> _convertToId3Tags(
+    Map<String, String> vorbisMetadata,
+  ) {
     final id3Map = <String, String>{};
-    
+
     for (final entry in vorbisMetadata.entries) {
       final key = entry.key.toUpperCase();
       final value = entry.value;
-      
+
       switch (key) {
         case 'TITLE':
           id3Map['title'] = value;
@@ -585,7 +629,7 @@ class FFmpegService {
           id3Map[key.toLowerCase()] = value;
       }
     }
-    
+
     return id3Map;
   }
 }

lib/services/history_database.dart

@@ -34,7 +34,7 @@ class HistoryDatabase {
     
     return await openDatabase(
       path,
-      version: 1,
+      version: 3,
       onCreate: _createDB,
       onUpgrade: _upgradeDB,
     );
@@ -52,6 +52,11 @@ class HistoryDatabase {
         album_artist TEXT,
         cover_url TEXT,
         file_path TEXT NOT NULL,
+        storage_mode TEXT,
+        download_tree_uri TEXT,
+        saf_relative_dir TEXT,
+        saf_file_name TEXT,
+        saf_repaired INTEGER,
         service TEXT NOT NULL,
         downloaded_at TEXT NOT NULL,
         isrc TEXT,
@@ -80,7 +85,15 @@ class HistoryDatabase {
   
   Future<void> _upgradeDB(Database db, int oldVersion, int newVersion) async {
     _log.i('Upgrading database from v$oldVersion to v$newVersion');
-    // Future migrations go here
+    if (oldVersion < 2) {
+      await db.execute('ALTER TABLE history ADD COLUMN storage_mode TEXT');
+      await db.execute('ALTER TABLE history ADD COLUMN download_tree_uri TEXT');
+      await db.execute('ALTER TABLE history ADD COLUMN saf_relative_dir TEXT');
+      await db.execute('ALTER TABLE history ADD COLUMN saf_file_name TEXT');
+    }
+    if (oldVersion < 3) {
+      await db.execute('ALTER TABLE history ADD COLUMN saf_repaired INTEGER');
+    }
   }
   
   // ==================== iOS Path Normalization ====================
@@ -244,6 +257,11 @@ class HistoryDatabase {
       'album_artist': json['albumArtist'],
       'cover_url': json['coverUrl'],
       'file_path': json['filePath'],
+      'storage_mode': json['storageMode'],
+      'download_tree_uri': json['downloadTreeUri'],
+      'saf_relative_dir': json['safRelativeDir'],
+      'saf_file_name': json['safFileName'],
+      'saf_repaired': json['safRepaired'] == true ? 1 : 0,
       'service': json['service'],
       'downloaded_at': json['downloadedAt'],
       'isrc': json['isrc'],
@@ -272,6 +290,11 @@ class HistoryDatabase {
       'albumArtist': row['album_artist'],
       'coverUrl': row['cover_url'],
       'filePath': _normalizeIosPath(row['file_path'] as String?),
+      'storageMode': row['storage_mode'],
+      'downloadTreeUri': row['download_tree_uri'],
+      'safRelativeDir': row['saf_relative_dir'],
+      'safFileName': row['saf_file_name'],
+      'safRepaired': row['saf_repaired'] == 1 || row['saf_repaired'] == true,
       'service': row['service'],
       'downloadedAt': row['downloaded_at'],
       'isrc': row['isrc'],

lib/services/library_database.dart

@@ -1,8 +1,8 @@
-import 'dart:io';
 import 'package:sqflite/sqflite.dart';
 import 'package:path/path.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:spotiflac_android/utils/logger.dart';
+import 'package:spotiflac_android/utils/file_access.dart';
 
 final _log = AppLogger('LibraryDatabase');
 
@@ -341,7 +341,7 @@ class LibraryDatabase {
     int removed = 0;
     for (final row in rows) {
       final filePath = row['file_path'] as String;
-      if (!await File(filePath).exists()) {
+      if (!await fileExists(filePath)) {
         await db.delete('library', where: 'id = ?', whereArgs: [row['id']]);
         removed++;
       }

lib/services/platform_bridge.dart

@@ -67,6 +67,11 @@ class PlatformBridge {
     String? releaseDate,
     String? itemId,
     int durationMs = 0,
+    String storageMode = 'app',
+    String safTreeUri = '',
+    String safRelativeDir = '',
+    String safFileName = '',
+    String safOutputExt = '',
   }) async {
     _log.i('downloadTrack: "$trackName" by $artistName via $service');
     final request = jsonEncode({
@@ -89,6 +94,11 @@ class PlatformBridge {
       'release_date': releaseDate ?? '',
       'item_id': itemId ?? '',
       'duration_ms': durationMs,
+      'storage_mode': storageMode,
+      'saf_tree_uri': safTreeUri,
+      'saf_relative_dir': safRelativeDir,
+      'saf_file_name': safFileName,
+      'saf_output_ext': safOutputExt,
     });
     
     final result = await _channel.invokeMethod('downloadTrack', request);
@@ -125,6 +135,11 @@ class PlatformBridge {
     String? label,
     String? copyright,
     String lyricsMode = 'embed',
+    String storageMode = 'app',
+    String safTreeUri = '',
+    String safRelativeDir = '',
+    String safFileName = '',
+    String safOutputExt = '',
   }) async {
     _log.i('downloadWithFallback: "$trackName" by $artistName (preferred: $preferredService)');
     final request = jsonEncode({
@@ -151,6 +166,11 @@ class PlatformBridge {
       'label': label ?? '',
       'copyright': copyright ?? '',
       'lyrics_mode': lyricsMode,
+      'storage_mode': storageMode,
+      'saf_tree_uri': safTreeUri,
+      'saf_relative_dir': safRelativeDir,
+      'saf_file_name': safFileName,
+      'saf_output_ext': safOutputExt,
     });
     
     final result = await _channel.invokeMethod('downloadWithFallback', request);
@@ -225,6 +245,80 @@ class PlatformBridge {
     return result as String;
   }
 
+  static Future<Map<String, dynamic>?> pickSafTree() async {
+    final result = await _channel.invokeMethod('pickSafTree');
+    if (result == null) return null;
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  static Future<bool> safExists(String uri) async {
+    final result = await _channel.invokeMethod('safExists', {'uri': uri});
+    return result as bool;
+  }
+
+  static Future<bool> safDelete(String uri) async {
+    final result = await _channel.invokeMethod('safDelete', {'uri': uri});
+    return result as bool;
+  }
+
+  static Future<Map<String, dynamic>> safStat(String uri) async {
+    final result = await _channel.invokeMethod('safStat', {'uri': uri});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  static Future<Map<String, dynamic>> resolveSafFile({
+    required String treeUri,
+    required String fileName,
+    String relativeDir = '',
+  }) async {
+    final result = await _channel.invokeMethod('resolveSafFile', {
+      'tree_uri': treeUri,
+      'relative_dir': relativeDir,
+      'file_name': fileName,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  static Future<String?> copyContentUriToTemp(String uri) async {
+    final result = await _channel.invokeMethod('safCopyToTemp', {'uri': uri});
+    return result as String?;
+  }
+
+  static Future<bool> replaceContentUriFromPath(
+    String uri,
+    String srcPath,
+  ) async {
+    final result = await _channel.invokeMethod('safReplaceFromPath', {
+      'uri': uri,
+      'src_path': srcPath,
+    });
+    return result as bool;
+  }
+
+  static Future<String?> createSafFileFromPath({
+    required String treeUri,
+    required String relativeDir,
+    required String fileName,
+    required String mimeType,
+    required String srcPath,
+  }) async {
+    final result = await _channel.invokeMethod('safCreateFromPath', {
+      'tree_uri': treeUri,
+      'relative_dir': relativeDir,
+      'file_name': fileName,
+      'mime_type': mimeType,
+      'src_path': srcPath,
+    });
+    return result as String?;
+  }
+
+  static Future<void> openContentUri(String uri, {String mimeType = ''}) async {
+    await _channel.invokeMethod('openContentUri', {
+      'uri': uri,
+      'mime_type': mimeType,
+    });
+  }
+
   static Future<Map<String, dynamic>> fetchLyrics(
     String spotifyId,
     String trackName,
@@ -593,6 +687,11 @@ static Future<Map<String, dynamic>> downloadWithExtensions({
     String? label,
     String lyricsMode = 'embed',
     String? preferredService,
+    String storageMode = 'app',
+    String safTreeUri = '',
+    String safRelativeDir = '',
+    String safFileName = '',
+    String safOutputExt = '',
   }) async {
     _log.i('downloadWithExtensions: "$trackName" by $artistName${source != null ? ' (source: $source)' : ''}${preferredService != null ? ' (service: $preferredService)' : ''}');
     final request = jsonEncode({
@@ -619,6 +718,11 @@ static Future<Map<String, dynamic>> downloadWithExtensions({
       'label': label ?? '',
       'lyrics_mode': lyricsMode,
       'service': preferredService ?? '',
+      'storage_mode': storageMode,
+      'saf_tree_uri': safTreeUri,
+      'saf_relative_dir': safRelativeDir,
+      'saf_file_name': safFileName,
+      'saf_output_ext': safOutputExt,
     });
     
     final result = await _channel.invokeMethod('downloadWithExtensions', request);
@@ -852,6 +956,15 @@ static Future<Map<String, dynamic>> downloadWithExtensions({
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
+  static Future<List<Map<String, dynamic>>> scanSafTree(String treeUri) async {
+    _log.i('scanSafTree: $treeUri');
+    final result = await _channel.invokeMethod('scanSafTree', {
+      'tree_uri': treeUri,
+    });
+    final list = jsonDecode(result as String) as List<dynamic>;
+    return list.map((e) => e as Map<String, dynamic>).toList();
+  }
+
   /// Get current library scan progress
   static Future<Map<String, dynamic>> getLibraryScanProgress() async {
     final result = await _channel.invokeMethod('getLibraryScanProgress');
@@ -889,6 +1002,23 @@ static Future<Map<String, dynamic>> downloadWithExtensions({
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
+  static Future<Map<String, dynamic>> runPostProcessingV2(
+    String filePath, {
+    Map<String, dynamic>? metadata,
+  }) async {
+    final input = <String, dynamic>{};
+    if (filePath.startsWith('content://')) {
+      input['uri'] = filePath;
+    } else {
+      input['path'] = filePath;
+    }
+    final result = await _channel.invokeMethod('runPostProcessingV2', {
+      'input': jsonEncode(input),
+      'metadata': metadata != null ? jsonEncode(metadata) : '',
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
   static Future<List<Map<String, dynamic>>> getPostProcessingProviders() async {
     final result = await _channel.invokeMethod('getPostProcessingProviders');
     final list = jsonDecode(result as String) as List<dynamic>;

lib/utils/file_access.dart

@@ -0,0 +1,66 @@
+import 'dart:io';
+
+import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/mime_utils.dart';
+
+class FileAccessStat {
+  final int? size;
+  final DateTime? modified;
+
+  const FileAccessStat({this.size, this.modified});
+}
+
+bool isContentUri(String? path) {
+  return path != null && path.startsWith('content://');
+}
+
+Future<bool> fileExists(String? path) async {
+  if (path == null || path.isEmpty) return false;
+  if (isContentUri(path)) {
+    return PlatformBridge.safExists(path);
+  }
+  return File(path).exists();
+}
+
+Future<void> deleteFile(String? path) async {
+  if (path == null || path.isEmpty) return;
+  if (isContentUri(path)) {
+    await PlatformBridge.safDelete(path);
+    return;
+  }
+  try {
+    await File(path).delete();
+  } catch (_) {}
+}
+
+Future<FileAccessStat?> fileStat(String? path) async {
+  if (path == null || path.isEmpty) return null;
+  if (isContentUri(path)) {
+    final stat = await PlatformBridge.safStat(path);
+    final exists = stat['exists'] as bool? ?? true;
+    if (!exists) return null;
+    return FileAccessStat(
+      size: stat['size'] as int?,
+      modified: stat['modified'] != null
+          ? DateTime.fromMillisecondsSinceEpoch(stat['modified'] as int)
+          : null,
+    );
+  }
+
+  final stat = await FileStat.stat(path);
+  if (stat.type == FileSystemEntityType.notFound) return null;
+  return FileAccessStat(size: stat.size, modified: stat.modified);
+}
+
+Future<void> openFile(String path) async {
+  if (isContentUri(path)) {
+    await PlatformBridge.openContentUri(path, mimeType: '');
+    return;
+  }
+  final mimeType = audioMimeTypeForPath(path);
+  final result = await OpenFilex.open(path, type: mimeType);
+  if (result.type != ResultType.done) {
+    throw Exception(result.message);
+  }
+}

lib/widgets/download_service_picker.dart

@@ -334,6 +334,28 @@ Padding(
                 widget.onSelect('HIGH', _selectedService);
               },
             ),
+            ListTile(
+              contentPadding: const EdgeInsets.symmetric(horizontal: 24),
+              leading: Container(
+                padding: const EdgeInsets.all(10),
+                decoration: BoxDecoration(
+                  color: colorScheme.primaryContainer,
+                  borderRadius: BorderRadius.circular(12),
+                ),
+                child: Icon(Icons.graphic_eq, color: colorScheme.onPrimaryContainer, size: 20),
+              ),
+              title: const Text('Opus 256kbps'),
+              subtitle: const Text('Best quality Opus, ~8MB per track'),
+              trailing: currentFormat == 'opus_256'
+                  ? Icon(Icons.check_circle, color: colorScheme.primary)
+                  : null,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setTidalHighFormat('opus_256');
+                Navigator.pop(modalContext); // Close format picker
+                Navigator.pop(context); // Close service picker
+                widget.onSelect('HIGH', _selectedService);
+              },
+            ),
             ListTile(
               contentPadding: const EdgeInsets.symmetric(horizontal: 24),
               leading: Container(
@@ -345,7 +367,7 @@ Padding(
                 child: Icon(Icons.graphic_eq, color: colorScheme.onPrimaryContainer, size: 20),
               ),
               title: const Text('Opus 128kbps'),
-              subtitle: const Text('Modern codec, ~4MB per track'),
+              subtitle: const Text('Smallest size, ~4MB per track'),
               trailing: currentFormat == 'opus_128'
                   ? Icon(Icons.check_circle, color: colorScheme.primary)
                   : null,

pubspec.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: "none"
-version: 3.4.0+72
+version: 3.5.0-beta.1+73
 
 environment:
   sdk: ^3.10.0