Initial commit: SpotiFLAC Android/iOS app

2026-06-01 03:15:17 +07:00 · 2026-01-01 19:28:15 +07:00 · 2026-01-01 19:28:15 +07:00 · 3fdcf6d5b7
commit 3fdcf6d5b7
126 changed files with 14079 additions and 0 deletions
--- a/.github/workflows/android-build.yml
+++ b/.github/workflows/android-build.yml
@ -0,0 +1,77 @@
+name: Android Build
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  build-android:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+          cache-dependency-path: go_backend/go.sum
+
+      - name: Install Android SDK & NDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install gomobile
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+
+      - name: Build Go backend for Android
+        working-directory: go_backend
+        run: |
+          mkdir -p ../android/app/libs
+          gomobile bind -target=android -androidapi 24 -o ../android/app/libs/gobackend.aar .
+        env:
+          CGO_ENABLED: 1
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.24.0'
+          channel: 'stable'
+          cache: true
+
+      - name: Get Flutter dependencies
+        run: flutter pub get
+
+      - name: Generate app icons
+        run: dart run flutter_launcher_icons
+
+      - name: Build APK (Release)
+        run: flutter build apk --release
+
+      - name: Build App Bundle (Release)
+        run: flutter build appbundle --release
+
+      - name: Upload APK artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: SpotiFLAC-Android-APK
+          path: build/app/outputs/flutter-apk/app-release.apk
+          retention-days: 30
+
+      - name: Upload AAB artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: SpotiFLAC-Android-AAB
+          path: build/app/outputs/bundle/release/app-release.aab
+          retention-days: 30
--- a/.github/workflows/ios-build.yml
+++ b/.github/workflows/ios-build.yml
@ -0,0 +1,74 @@
+name: iOS Build
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  build-ios:
+    runs-on: macos-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+          cache-dependency-path: go_backend/go.sum
+
+      - name: Install gomobile
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+
+      - name: Build Go backend for iOS (XCFramework)
+        working-directory: go_backend
+        run: |
+          mkdir -p ../ios/Frameworks
+          gomobile bind -target=ios -o ../ios/Frameworks/Gobackend.xcframework .
+        env:
+          CGO_ENABLED: 1
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.24.0'
+          channel: 'stable'
+          cache: true
+
+      - name: Get Flutter dependencies
+        run: flutter pub get
+
+      - name: Generate app icons
+        run: dart run flutter_launcher_icons
+
+      - name: Build iOS (no codesign)
+        run: flutter build ios --release --no-codesign
+
+      - name: Create IPA (unsigned)
+        run: |
+          mkdir -p build/ios/ipa
+          cd build/ios/iphoneos
+          mkdir Payload
+          cp -r Runner.app Payload/
+          zip -r ../ipa/SpotiFLAC-unsigned.ipa Payload
+          rm -rf Payload
+
+      - name: Upload IPA artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: SpotiFLAC-iOS-unsigned
+          path: build/ios/ipa/SpotiFLAC-unsigned.ipa
+          retention-days: 30
+
+      - name: Upload XCFramework artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Gobackend-XCFramework
+          path: ios/Frameworks/Gobackend.xcframework
+          retention-days: 30
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -0,0 +1,202 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version tag (e.g., v1.0.0)'
+        required: true
+        default: 'v1.0.0'
+
+jobs:
+  build-android:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get_version.outputs.version }}
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Get version
+        id: get_version
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "version=${{ github.event.inputs.version }}" >> $GITHUB_OUTPUT
+          else
+            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+          cache-dependency-path: go_backend/go.sum
+
+      - name: Install Android SDK & NDK
+        uses: android-actions/setup-android@v3
+
+      - name: Install gomobile
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+
+      - name: Build Go backend for Android
+        working-directory: go_backend
+        run: |
+          mkdir -p ../android/app/libs
+          gomobile bind -target=android -androidapi 24 -o ../android/app/libs/gobackend.aar .
+        env:
+          CGO_ENABLED: 1
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.24.0'
+          channel: 'stable'
+          cache: true
+
+      - name: Get Flutter dependencies
+        run: flutter pub get
+
+      - name: Generate app icons
+        run: dart run flutter_launcher_icons
+
+      - name: Build APK (Release)
+        run: flutter build apk --release
+
+      - name: Rename APK
+        run: |
+          VERSION=${{ steps.get_version.outputs.version }}
+          mv build/app/outputs/flutter-apk/app-release.apk build/app/outputs/flutter-apk/SpotiFLAC-${VERSION}-android.apk
+
+      - name: Upload APK artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: android-apk
+          path: build/app/outputs/flutter-apk/SpotiFLAC-*.apk
+
+  build-ios:
+    runs-on: macos-latest
+    needs: build-android
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.21'
+          cache-dependency-path: go_backend/go.sum
+
+      - name: Install gomobile
+        run: |
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          gomobile init
+
+      - name: Build Go backend for iOS
+        working-directory: go_backend
+        run: |
+          mkdir -p ../ios/Frameworks
+          gomobile bind -target=ios -o ../ios/Frameworks/Gobackend.xcframework .
+        env:
+          CGO_ENABLED: 1
+
+      - name: Setup Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          flutter-version: '3.24.0'
+          channel: 'stable'
+          cache: true
+
+      - name: Get Flutter dependencies
+        run: flutter pub get
+
+      - name: Generate app icons
+        run: dart run flutter_launcher_icons
+
+      - name: Build iOS (unsigned)
+        run: flutter build ios --release --no-codesign
+
+      - name: Create IPA
+        run: |
+          VERSION=${{ needs.build-android.outputs.version }}
+          mkdir -p build/ios/ipa
+          cd build/ios/iphoneos
+          mkdir Payload
+          cp -r Runner.app Payload/
+          zip -r ../ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa Payload
+          rm -rf Payload
+
+      - name: Upload IPA artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ios-ipa
+          path: build/ios/ipa/SpotiFLAC-*.ipa
+
+  create-release:
+    runs-on: ubuntu-latest
+    needs: [build-android, build-ios]
+    permissions:
+      contents: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Download Android APK
+        uses: actions/download-artifact@v4
+        with:
+          name: android-apk
+          path: ./release
+
+      - name: Download iOS IPA
+        uses: actions/download-artifact@v4
+        with:
+          name: ios-ipa
+          path: ./release
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ needs.build-android.outputs.version }}
+          name: SpotiFLAC ${{ needs.build-android.outputs.version }}
+          body: |
+            ## SpotiFLAC ${{ needs.build-android.outputs.version }}
+            
+            Download Spotify tracks in FLAC quality from Tidal, Qobuz & Amazon Music.
+            
+            ### Downloads
+            - **Android**: `SpotiFLAC-${{ needs.build-android.outputs.version }}-android.apk`
+            - **iOS**: `SpotiFLAC-${{ needs.build-android.outputs.version }}-ios-unsigned.ipa` (requires sideloading)
+            
+            ### Features
+            - Search Spotify tracks, albums, and playlists
+            - Download in FLAC quality from multiple sources
+            - Automatic fallback to available services
+            - Embedded metadata and cover art
+            - Lyrics support (synced and plain)
+            - Material 3 Expressive UI with dynamic colors
+            
+            ### Installation
+            **Android**: Enable "Install from unknown sources" and install the APK
+            **iOS**: Use AltStore, Sideloadly, or similar tools to sideload the IPA
+            
+            ---
+            *Note: iOS IPA is unsigned and requires sideloading*
+          files: |
+            ./release/*
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,14 @@
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.iml
+
+# Kiro specs (optional - remove if you want to track specs)
+# .kiro/
+
+# Reference folder (if you don't want to include it)
+# referensi/
--- a/README.md
+++ b/README.md
@ -0,0 +1,116 @@
+# SpotiFLAC
+
+Download Spotify tracks in FLAC quality from Tidal, Qobuz & Amazon Music.
+
+![Android Build](https://github.com/zarzet/SpotiFLAC-Android/actions/workflows/android-build.yml/badge.svg)
+![iOS Build](https://github.com/zarzet/SpotiFLAC-Android/actions/workflows/ios-build.yml/badge.svg)
+
+## Features
+
+- 🔍 Search Spotify tracks, albums, and playlists
+- 📥 Download in FLAC quality from multiple sources (Tidal, Qobuz, Amazon Music)
+- 🔄 Automatic fallback to available services
+- 🎵 Embedded metadata and cover art
+- 📝 Lyrics support (synced and plain)
+- 🎨 Material 3 Expressive UI with dynamic colors
+- 📱 Cross-platform: Android & iOS
+
+## Download
+
+### Latest Release
+Download the latest version from [Releases](https://github.com/zarzet/SpotiFLAC-Android/releases)
+
+- **Android**: Download `SpotiFLAC-vX.X.X-android.apk`
+- **iOS**: Download `SpotiFLAC-vX.X.X-ios-unsigned.ipa` (requires sideloading)
+
+### Requirements
+
+**Android**
+- Android 7.0 (API 24) or higher
+- Storage permission for saving music files
+
+**iOS**
+- iOS 14.0 or higher
+- Sideloading tool (AltStore, Sideloadly, etc.)
+
+## Building from Source
+
+### Prerequisites
+- Flutter 3.24.0 or higher
+- Go 1.21 or higher
+- gomobile (`go install golang.org/x/mobile/cmd/gomobile@latest`)
+
+### Android Build
+
+```bash
+# Build Go backend
+cd go_backend
+gomobile bind -target=android -androidapi 24 -o ../android/app/libs/gobackend.aar .
+cd ..
+
+# Build APK
+flutter build apk --release
+```
+
+### iOS Build
+
+#### Option 1: Using GitHub Actions (Recommended - No Mac Required)
+Push to the repository and GitHub Actions will automatically build the iOS app.
+Download the unsigned IPA from the Actions artifacts.
+
+#### Option 2: Local Build (Requires macOS)
+
+```bash
+# Build Go backend for iOS
+cd go_backend
+gomobile bind -target=ios -o ../ios/Frameworks/Gobackend.xcframework .
+cd ..
+
+# Build iOS (unsigned)
+flutter build ios --release --no-codesign
+```
+
+## Project Structure
+
+```
+SpotiFLAC-Android/
+├── lib/                    # Flutter/Dart code
+│   ├── models/             # Data models
+│   ├── providers/          # Riverpod state management
+│   ├── screens/            # UI screens
+│   ├── services/           # Platform bridge & FFmpeg
+│   └── theme/              # Material 3 theming
+├── go_backend/             # Go backend (Tidal, Qobuz, Amazon APIs)
+├── android/                # Android platform code
+├── ios/                    # iOS platform code
+└── .github/workflows/      # CI/CD workflows
+```
+
+## Creating a Release
+
+Releases are automated via GitHub Actions. To create a new release:
+
+1. Create and push a tag:
+   ```bash
+   git tag v1.0.0
+   git push origin v1.0.0
+   ```
+
+2. GitHub Actions will automatically:
+   - Build Android APK
+   - Build iOS IPA (unsigned)
+   - Create a GitHub Release with both artifacts
+
+## Known Limitations
+
+- iOS IPA is unsigned and requires sideloading
+- TestFlight distribution requires Apple Developer account ($99/year)
+- Some streaming services may have regional restrictions
+
+## License
+
+Private project - not for public distribution.
+
+## Disclaimer
+
+This project is for educational purposes only. Please respect copyright laws and the terms of service of streaming platforms.
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@ -0,0 +1,28 @@
+# This file configures the analyzer, which statically analyzes Dart code to
+# check for errors, warnings, and lints.
+#
+# The issues identified by the analyzer are surfaced in the UI of Dart-enabled
+# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be
+# invoked from the command line by running `flutter analyze`.
+
+# The following line activates a set of recommended lints for Flutter apps,
+# packages, and plugins designed to encourage good coding practices.
+include: package:flutter_lints/flutter.yaml
+
+linter:
+  # The lint rules applied to this project can be customized in the
+  # section below to disable rules from the `package:flutter_lints/flutter.yaml`
+  # included above or to enable additional rules. A list of all available lints
+  # and their documentation is published at https://dart.dev/lints.
+  #
+  # Instead of disabling a lint rule for the entire project in the
+  # section below, it can also be suppressed for a single line of code
+  # or a specific dart file by using the `// ignore: name_of_lint` and
+  # `// ignore_for_file: name_of_lint` syntax on the line or in the file
+  # producing the lint.
+  rules:
+    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
+    # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
+
+# Additional information about this file can be found at
+# https://dart.dev/guides/language/analysis-options
--- a/android/.gitignore
+++ b/android/.gitignore
@ -0,0 +1,14 @@
+gradle-wrapper.jar
+/.gradle
+/captures/
+/gradlew
+/gradlew.bat
+/local.properties
+GeneratedPluginRegistrant.java
+.cxx/
+
+# Remember to never publicly share your keystore.
+# See https://flutter.dev/to/reference-keystore
+key.properties
+**/*.keystore
+**/*.jks
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@ -0,0 +1,71 @@
+plugins {
+    id "com.android.application"
+    id "kotlin-android"
+    id "dev.flutter.flutter-gradle-plugin"
+}
+
+def localProperties = new Properties()
+def localPropertiesFile = rootProject.file('local.properties')
+if (localPropertiesFile.exists()) {
+    localPropertiesFile.withReader('UTF-8') { reader ->
+        localProperties.load(reader)
+    }
+}
+
+def flutterVersionCode = localProperties.getProperty('flutter.versionCode')
+if (flutterVersionCode == null) {
+    flutterVersionCode = '1'
+}
+
+def flutterVersionName = localProperties.getProperty('flutter.versionName')
+if (flutterVersionName == null) {
+    flutterVersionName = '1.0'
+}
+
+android {
+    namespace "com.zarz.spotiflac"
+    compileSdk flutter.compileSdkVersion
+    ndkVersion flutter.ndkVersion
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+
+    defaultConfig {
+        applicationId "com.zarz.spotiflac"
+        minSdkVersion flutter.minSdkVersion
+        targetSdk flutter.targetSdkVersion
+        versionCode flutterVersionCode.toInteger()
+        versionName flutterVersionName
+    }
+
+    buildTypes {
+        release {
+            signingConfig signingConfigs.debug
+            minifyEnabled false
+            shrinkResources false
+        }
+    }
+}
+
+flutter {
+    source '../..'
+}
+
+dependencies {
+    // Go backend library (gomobile generated)
+    implementation fileTree(dir: 'libs', include: ['*.aar'])
+    
+    // Kotlin coroutines for async Go backend calls
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+}
--- a/android/app/build.gradle.kts
+++ b/android/app/build.gradle.kts
@ -0,0 +1,58 @@
+plugins {
+    id("com.android.application")
+    id("kotlin-android")
+    // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
+    id("dev.flutter.flutter-gradle-plugin")
+}
+
+android {
+    namespace = "com.zarz.spotiflac"
+    compileSdk = flutter.compileSdkVersion
+    ndkVersion = flutter.ndkVersion
+
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlin {
+        compilerOptions {
+            jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
+        }
+    }
+
+    defaultConfig {
+        applicationId = "com.zarz.spotiflac"
+        minSdk = flutter.minSdkVersion
+        targetSdk = 34
+        versionCode = flutter.versionCode
+        versionName = flutter.versionName
+        multiDexEnabled = true
+    }
+
+    buildTypes {
+        release {
+            signingConfig = signingConfigs.getByName("debug")
+            isMinifyEnabled = false
+            isShrinkResources = false
+        }
+    }
+}
+
+flutter {
+    source = "../.."
+}
+
+repositories {
+    flatDir {
+        dirs("libs")
+    }
+}
+
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.4")
+    implementation(files("libs/gobackend.aar"))
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
+}
--- a/android/app/src/debug/AndroidManifest.xml
+++ b/android/app/src/debug/AndroidManifest.xml
@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@ -0,0 +1,87 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.zarz.spotiflac">
+
+    <!-- Permissions -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" 
+        android:maxSdkVersion="28" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" 
+        android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <application
+        android:label="SpotiFLAC"
+        android:name="${applicationName}"
+        android:icon="@mipmap/ic_launcher"
+        android:requestLegacyExternalStorage="true"
+        android:usesCleartextTraffic="true">
+
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:theme="@style/LaunchTheme"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+            android:hardwareAccelerated="true"
+            android:windowSoftInputMode="adjustResize">
+
+            <meta-data
+                android:name="io.flutter.embedding.android.NormalTheme"
+                android:resource="@style/NormalTheme" />
+
+            <!-- Main launcher -->
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+
+            <!-- Handle Spotify URL sharing -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="text/plain" />
+            </intent-filter>
+
+            <!-- Handle Spotify deep links -->
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="https" android:host="open.spotify.com" />
+            </intent-filter>
+        </activity>
+
+        <!-- Download Service -->
+        <service
+            android:name=".DownloadService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
+
+        <!-- flutter_local_notifications receivers -->
+        <receiver android:exported="false" android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationReceiver" />
+        <receiver android:exported="false" android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationBootReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED"/>
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED"/>
+                <action android:name="android.intent.action.QUICKBOOT_POWERON" />
+                <action android:name="com.htc.intent.action.QUICKBOOT_POWERON"/>
+            </intent-filter>
+        </receiver>
+
+        <!-- Don't delete the meta-data below -->
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
+    </application>
+
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.PROCESS_TEXT"/>
+            <data android:mimeType="text/plain"/>
+        </intent>
+    </queries>
+</manifest>
--- a/android/app/src/main/kotlin/com/example/temp_project/MainActivity.kt
+++ b/android/app/src/main/kotlin/com/example/temp_project/MainActivity.kt
@ -0,0 +1,5 @@
+package com.example.temp_project
+
+import io.flutter.embedding.android.FlutterActivity
+
+class MainActivity : FlutterActivity()
--- a/android/app/src/main/kotlin/com/zarz/spotiflac/DownloadService.kt
+++ b/android/app/src/main/kotlin/com/zarz/spotiflac/DownloadService.kt
@ -0,0 +1,87 @@
+package com.zarz.spotiflac
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import androidx.core.app.NotificationCompat
+
+class DownloadService : Service() {
+    companion object {
+        const val CHANNEL_ID = "spotiflac_download_channel"
+        const val NOTIFICATION_ID = 1
+        const val ACTION_START = "com.zarz.spotiflac.START_DOWNLOAD"
+        const val ACTION_STOP = "com.zarz.spotiflac.STOP_DOWNLOAD"
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        createNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_START -> startForegroundService()
+            ACTION_STOP -> stopSelf()
+        }
+        return START_NOT_STICKY
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "Download Progress",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Shows download progress for SpotiFLAC"
+                setShowBadge(false)
+            }
+            val manager = getSystemService(NotificationManager::class.java)
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun startForegroundService() {
+        val notification = createNotification("Downloading...", 0)
+        startForeground(NOTIFICATION_ID, notification)
+    }
+
+    fun updateProgress(trackName: String, progress: Int) {
+        val notification = createNotification(trackName, progress)
+        val manager = getSystemService(NotificationManager::class.java)
+        manager.notify(NOTIFICATION_ID, notification)
+    }
+
+    private fun createNotification(title: String, progress: Int): Notification {
+        val intent = Intent(this, MainActivity::class.java)
+        val pendingIntent = PendingIntent.getActivity(
+            this, 0, intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val stopIntent = Intent(this, DownloadService::class.java).apply {
+            action = ACTION_STOP
+        }
+        val stopPendingIntent = PendingIntent.getService(
+            this, 0, stopIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle("SpotiFLAC")
+            .setContentText(title)
+            .setSmallIcon(android.R.drawable.stat_sys_download)
+            .setProgress(100, progress, progress == 0)
+            .setOngoing(true)
+            .setContentIntent(pendingIntent)
+            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Cancel", stopPendingIntent)
+            .build()
+    }
+}
--- a/android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt
+++ b/android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt
@ -0,0 +1,138 @@
+package com.zarz.spotiflac
+
+import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.plugin.common.MethodChannel
+import gobackend.Gobackend
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class MainActivity: FlutterActivity() {
+    private val CHANNEL = "com.zarz.spotiflac/backend"
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+        super.configureFlutterEngine(flutterEngine)
+        
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
+            scope.launch {
+                try {
+                    when (call.method) {
+                        "parseSpotifyUrl" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.parseSpotifyURL(url)
+                            }
+                            result.success(response)
+                        }
+                        "getSpotifyMetadata" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getSpotifyMetadata(url)
+                            }
+                            result.success(response)
+                        }
+                        "searchSpotify" -> {
+                            val query = call.argument<String>("query") ?: ""
+                            val limit = call.argument<Int>("limit") ?: 10
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchSpotify(query, limit.toLong())
+                            }
+                            result.success(response)
+                        }
+                        "checkAvailability" -> {
+                            val spotifyId = call.argument<String>("spotify_id") ?: ""
+                            val isrc = call.argument<String>("isrc") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.checkAvailability(spotifyId, isrc)
+                            }
+                            result.success(response)
+                        }
+                        "downloadTrack" -> {
+                            val requestJson = call.arguments as String
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.downloadTrack(requestJson)
+                            }
+                            result.success(response)
+                        }
+                        "downloadWithFallback" -> {
+                            val requestJson = call.arguments as String
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.downloadWithFallback(requestJson)
+                            }
+                            result.success(response)
+                        }
+                        "getDownloadProgress" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getDownloadProgress()
+                            }
+                            result.success(response)
+                        }
+                        "setDownloadDirectory" -> {
+                            val path = call.argument<String>("path") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setDownloadDirectory(path)
+                            }
+                            result.success(null)
+                        }
+                        "checkDuplicate" -> {
+                            val outputDir = call.argument<String>("output_dir") ?: ""
+                            val isrc = call.argument<String>("isrc") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.checkDuplicate(outputDir, isrc)
+                            }
+                            result.success(response)
+                        }
+                        "buildFilename" -> {
+                            val template = call.argument<String>("template") ?: ""
+                            val metadata = call.argument<String>("metadata") ?: "{}"
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.buildFilename(template, metadata)
+                            }
+                            result.success(response)
+                        }
+                        "sanitizeFilename" -> {
+                            val filename = call.argument<String>("filename") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.sanitizeFilename(filename)
+                            }
+                            result.success(response)
+                        }
+                        "fetchLyrics" -> {
+                            val spotifyId = call.argument<String>("spotify_id") ?: ""
+                            val trackName = call.argument<String>("track_name") ?: ""
+                            val artistName = call.argument<String>("artist_name") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.fetchLyrics(spotifyId, trackName, artistName)
+                            }
+                            result.success(response)
+                        }
+                        "getLyricsLRC" -> {
+                            val spotifyId = call.argument<String>("spotify_id") ?: ""
+                            val trackName = call.argument<String>("track_name") ?: ""
+                            val artistName = call.argument<String>("artist_name") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getLyricsLRC(spotifyId, trackName, artistName)
+                            }
+                            result.success(response)
+                        }
+                        "embedLyricsToFile" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val lyrics = call.argument<String>("lyrics") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.embedLyricsToFile(filePath, lyrics)
+                            }
+                            result.success(response)
+                        }
+                        else -> result.notImplemented()
+                    }
+                } catch (e: Exception) {
+                    result.error("ERROR", e.message, null)
+                }
+            }
+        }
+    }
+}
--- a/android/app/src/main/res/drawable-hdpi/ic_launcher_foreground.png
+++ b/android/app/src/main/res/drawable-hdpi/ic_launcher_foreground.png
--- a/android/app/src/main/res/drawable-mdpi/ic_launcher_foreground.png
+++ b/android/app/src/main/res/drawable-mdpi/ic_launcher_foreground.png
--- a/android/app/src/main/res/drawable-v21/launch_background.xml
+++ b/android/app/src/main/res/drawable-v21/launch_background.xml
@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="?android:colorBackground" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>
--- a/android/app/src/main/res/drawable-xhdpi/ic_launcher_foreground.png
+++ b/android/app/src/main/res/drawable-xhdpi/ic_launcher_foreground.png
--- a/android/app/src/main/res/drawable-xxhdpi/ic_launcher_foreground.png
+++ b/android/app/src/main/res/drawable-xxhdpi/ic_launcher_foreground.png
--- a/android/app/src/main/res/drawable-xxxhdpi/ic_launcher_foreground.png
+++ b/android/app/src/main/res/drawable-xxxhdpi/ic_launcher_foreground.png
--- a/android/app/src/main/res/drawable/launch_background.xml
+++ b/android/app/src/main/res/drawable/launch_background.xml
@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@android:color/white" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>
--- a/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
+++ b/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml
@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/ic_launcher_background"/>
+  <foreground>
+      <inset
+          android:drawable="@drawable/ic_launcher_foreground"
+          android:inset="16%" />
+  </foreground>
+</adaptive-icon>
--- a/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
+++ b/android/app/src/main/res/mipmap-hdpi/ic_launcher.png
--- a/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
+++ b/android/app/src/main/res/mipmap-mdpi/ic_launcher.png
--- a/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
+++ b/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png
--- a/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
+++ b/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
--- a/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
+++ b/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
--- a/android/app/src/main/res/values-night/styles.xml
+++ b/android/app/src/main/res/values-night/styles.xml
@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>
--- a/android/app/src/main/res/values/colors.xml
+++ b/android/app/src/main/res/values/colors.xml
@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#1a1a2e</color>
+</resources>
--- a/android/app/src/main/res/values/styles.xml
+++ b/android/app/src/main/res/values/styles.xml
@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>
--- a/android/app/src/profile/AndroidManifest.xml
+++ b/android/app/src/profile/AndroidManifest.xml
@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>
--- a/android/build.gradle.kts
+++ b/android/build.gradle.kts
@ -0,0 +1,43 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+subprojects {
+    afterEvaluate {
+        if (project.hasProperty("android")) {
+            project.extensions.configure<com.android.build.gradle.BaseExtension>("android") {
+                compileOptions {
+                    sourceCompatibility = JavaVersion.VERSION_17
+                    targetCompatibility = JavaVersion.VERSION_17
+                }
+            }
+        }
+        
+        tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+            compilerOptions {
+                jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
+            }
+        }
+    }
+}
+
+val newBuildDir: Directory =
+    rootProject.layout.buildDirectory
+        .dir("../../build")
+        .get()
+rootProject.layout.buildDirectory.value(newBuildDir)
+
+subprojects {
+    val newSubprojectBuildDir: Directory = newBuildDir.dir(project.name)
+    project.layout.buildDirectory.value(newSubprojectBuildDir)
+}
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register<Delete>("clean") {
+    delete(rootProject.layout.buildDirectory)
+}
--- a/android/gradle.properties
+++ b/android/gradle.properties
@ -0,0 +1,2 @@
+org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
+android.useAndroidX=true
--- a/android/gradle/wrapper/gradle-wrapper.properties
+++ b/android/gradle/wrapper/gradle-wrapper.properties
@ -0,0 +1,5 @@
+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
--- a/android/settings.gradle.kts
+++ b/android/settings.gradle.kts
@ -0,0 +1,26 @@
+pluginManagement {
+    val flutterSdkPath =
+        run {
+            val properties = java.util.Properties()
+            file("local.properties").inputStream().use { properties.load(it) }
+            val flutterSdkPath = properties.getProperty("flutter.sdk")
+            require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
+            flutterSdkPath
+        }
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
+    id("com.android.application") version "8.11.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.20" apply false
+}
+
+include(":app")
--- a/assets/images/logo.png
+++ b/assets/images/logo.png
--- a/go_backend/amazon.go
+++ b/go_backend/amazon.go
@ -0,0 +1,363 @@
+package gobackend
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// AmazonDownloader handles Amazon Music downloads using DoubleDouble service (same as PC)
+type AmazonDownloader struct {
+	client  *http.Client
+	regions []string // us, eu regions for DoubleDouble service
+}
+
+// DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
+type DoubleDoubleSubmitResponse struct {
+	Success bool   `json:"success"`
+	ID      string `json:"id"`
+}
+
+// DoubleDoubleStatusResponse is the response from DoubleDouble status endpoint
+type DoubleDoubleStatusResponse struct {
+	Status         string `json:"status"`
+	FriendlyStatus string `json:"friendlyStatus"`
+	URL            string `json:"url"`
+	Current        struct {
+		Name   string `json:"name"`
+		Artist string `json:"artist"`
+	} `json:"current"`
+}
+
+// NewAmazonDownloader creates a new Amazon downloader using DoubleDouble service
+func NewAmazonDownloader() *AmazonDownloader {
+	return &AmazonDownloader{
+		client:  NewHTTPClientWithTimeout(120 * time.Second), // 120s timeout like PC
+		regions: []string{"us", "eu"},                        // Same regions as PC
+	}
+}
+
+// GetAvailableAPIs returns list of available DoubleDouble regions
+// Uses same service as PC version (doubledouble.top)
+func (a *AmazonDownloader) GetAvailableAPIs() []string {
+	// DoubleDouble service regions (same as PC)
+	// Format: https://{region}.doubledouble.top
+	var apis []string
+	for _, region := range a.regions {
+		apis = append(apis, fmt.Sprintf("https://%s.doubledouble.top", region))
+	}
+	return apis
+}
+
+
+// downloadFromDoubleDoubleService downloads a track using DoubleDouble service (same as PC)
+// This uses submit → poll → download mechanism
+// Internal function - not exported to gomobile
+func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir string) (string, string, string, error) {
+	var lastError error
+
+	for _, region := range a.regions {
+		fmt.Printf("[Amazon] Trying region: %s...\n", region)
+
+		// Build base URL for DoubleDouble service
+		// Decode base64 service URL (same as PC)
+		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")         // https://
+		serviceDomain, _ := base64.StdEncoding.DecodeString("LmRvdWJsZWRvdWJsZS50b3A=") // .doubledouble.top
+		baseURL := fmt.Sprintf("%s%s%s", string(serviceBase), region, string(serviceDomain))
+
+		// Step 1: Submit download request
+		encodedURL := url.QueryEscape(amazonURL)
+		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)
+
+		req, err := http.NewRequest("GET", submitURL, nil)
+		if err != nil {
+			lastError = fmt.Errorf("failed to create request: %w", err)
+			continue
+		}
+
+		req.Header.Set("User-Agent", getRandomUserAgent())
+
+		fmt.Println("[Amazon] Submitting download request...")
+		resp, err := a.client.Do(req)
+		if err != nil {
+			lastError = fmt.Errorf("failed to submit request: %w", err)
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			resp.Body.Close()
+			lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+			continue
+		}
+
+		var submitResp DoubleDoubleSubmitResponse
+		if err := json.NewDecoder(resp.Body).Decode(&submitResp); err != nil {
+			resp.Body.Close()
+			lastError = fmt.Errorf("failed to decode submit response: %w", err)
+			continue
+		}
+		resp.Body.Close()
+
+		if !submitResp.Success || submitResp.ID == "" {
+			lastError = fmt.Errorf("submit request failed")
+			continue
+		}
+
+		downloadID := submitResp.ID
+		fmt.Printf("[Amazon] Download ID: %s\n", downloadID)
+
+		// Step 2: Poll for completion
+		statusURL := fmt.Sprintf("%s/dl/%s", baseURL, downloadID)
+		fmt.Println("[Amazon] Waiting for download to complete...")
+
+		maxWait := 300 * time.Second // 5 minutes max wait
+		elapsed := time.Duration(0)
+		pollInterval := 3 * time.Second
+
+		for elapsed < maxWait {
+			time.Sleep(pollInterval)
+			elapsed += pollInterval
+
+			statusReq, err := http.NewRequest("GET", statusURL, nil)
+			if err != nil {
+				continue
+			}
+
+			statusReq.Header.Set("User-Agent", getRandomUserAgent())
+
+			statusResp, err := a.client.Do(statusReq)
+			if err != nil {
+				fmt.Printf("\r[Amazon] Status check failed, retrying...")
+				continue
+			}
+
+			if statusResp.StatusCode != 200 {
+				statusResp.Body.Close()
+				fmt.Printf("\r[Amazon] Status check failed (status %d), retrying...", statusResp.StatusCode)
+				continue
+			}
+
+			var status DoubleDoubleStatusResponse
+			if err := json.NewDecoder(statusResp.Body).Decode(&status); err != nil {
+				statusResp.Body.Close()
+				fmt.Printf("\r[Amazon] Invalid JSON response, retrying...")
+				continue
+			}
+			statusResp.Body.Close()
+
+			if status.Status == "done" {
+				fmt.Println("\n[Amazon] Download ready!")
+
+				// Build download URL
+				fileURL := status.URL
+				if strings.HasPrefix(fileURL, "./") {
+					fileURL = fmt.Sprintf("%s/%s", baseURL, fileURL[2:])
+				} else if strings.HasPrefix(fileURL, "/") {
+					fileURL = fmt.Sprintf("%s%s", baseURL, fileURL)
+				}
+
+				trackName := status.Current.Name
+				artist := status.Current.Artist
+
+				fmt.Printf("[Amazon] Downloading: %s - %s\n", artist, trackName)
+				return fileURL, trackName, artist, nil
+
+			} else if status.Status == "error" {
+				errorMsg := status.FriendlyStatus
+				if errorMsg == "" {
+					errorMsg = "Unknown error"
+				}
+				lastError = fmt.Errorf("processing failed: %s", errorMsg)
+				break
+			} else {
+				// Still processing
+				friendlyStatus := status.FriendlyStatus
+				if friendlyStatus == "" {
+					friendlyStatus = status.Status
+				}
+				fmt.Printf("\r[Amazon] %s...", friendlyStatus)
+			}
+		}
+
+		if elapsed >= maxWait {
+			lastError = fmt.Errorf("download timeout")
+			fmt.Printf("\n[Amazon] Error with %s region: %v\n", region, lastError)
+			continue
+		}
+
+		if lastError != nil {
+			fmt.Printf("\n[Amazon] Error with %s region: %v\n", region, lastError)
+		}
+	}
+
+	return "", "", "", fmt.Errorf("all regions failed. Last error: %v", lastError)
+}
+
+
+// DownloadFile downloads a file from URL with User-Agent and progress tracking
+func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath string) error {
+	// Set current file being downloaded
+	SetCurrentFile(filepath.Base(outputPath))
+	SetDownloading(true)
+	defer SetDownloading(false)
+
+	req, err := http.NewRequest("GET", downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+	}
+
+	// Set total bytes if available
+	if resp.ContentLength > 0 {
+		SetBytesTotal(resp.ContentLength)
+	}
+
+	out, err := os.Create(outputPath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Track download progress
+	pw := NewProgressWriter(out)
+	_, err = io.Copy(pw, resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to write file: %w", err)
+	}
+
+	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
+	return nil
+}
+
+// downloadFromAmazon downloads a track using the request parameters
+// Uses DoubleDouble service (same as PC version)
+func downloadFromAmazon(req DownloadRequest) (string, error) {
+	downloader := NewAmazonDownloader()
+
+	// Check for existing file first
+	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+		return "EXISTS:" + existingFile, nil
+	}
+
+	// Get Amazon URL from SongLink
+	songlink := NewSongLinkClient()
+	availability, err := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	if err != nil {
+		return "", fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
+	}
+
+	if !availability.Amazon || availability.AmazonURL == "" {
+		return "", fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
+	}
+
+	// Create output directory if needed
+	if req.OutputDir != "." {
+		if err := os.MkdirAll(req.OutputDir, 0755); err != nil {
+			return "", fmt.Errorf("failed to create output directory: %w", err)
+		}
+	}
+
+	// Download using DoubleDouble service (same as PC)
+	downloadURL, trackName, artistName, err := downloader.downloadFromDoubleDoubleService(availability.AmazonURL, req.OutputDir)
+	if err != nil {
+		return "", fmt.Errorf("failed to get download URL: %w", err)
+	}
+
+	// Build filename using Spotify metadata (more accurate)
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
+		"title":  req.TrackName,
+		"artist": req.ArtistName,
+		"album":  req.AlbumName,
+		"track":  req.TrackNumber,
+		"year":   extractYear(req.ReleaseDate),
+		"disc":   req.DiscNumber,
+	})
+	filename = sanitizeFilename(filename) + ".flac"
+	outputPath := filepath.Join(req.OutputDir, filename)
+
+	// Check if file already exists
+	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+		return "EXISTS:" + outputPath, nil
+	}
+
+	// Download file
+	if err := downloader.DownloadFile(downloadURL, outputPath); err != nil {
+		return "", fmt.Errorf("download failed: %w", err)
+	}
+
+	// Log track info from DoubleDouble (for debugging)
+	if trackName != "" && artistName != "" {
+		fmt.Printf("[Amazon] DoubleDouble returned: %s - %s\n", artistName, trackName)
+	}
+
+	// Embed metadata using Spotify data (more accurate than DoubleDouble)
+	metadata := Metadata{
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		AlbumArtist: req.AlbumArtist,
+		Date:        req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		TotalTracks: req.TotalTracks,
+		DiscNumber:  req.DiscNumber,
+		ISRC:        req.ISRC,
+	}
+
+	// Download cover to memory (avoids file permission issues on Android)
+	var coverData []byte
+	if req.CoverURL != "" {
+		fmt.Println("[Amazon] Downloading cover to memory...")
+		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
+		if err == nil {
+			coverData = data
+			fmt.Printf("[Amazon] Cover downloaded successfully (%d bytes)\n", len(coverData))
+		} else {
+			fmt.Printf("[Amazon] Warning: failed to download cover: %v\n", err)
+		}
+	}
+
+	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+	}
+
+	// Embed lyrics if enabled
+	if req.EmbedLyrics {
+		fmt.Println("[Amazon] Fetching lyrics...")
+		lyricsClient := NewLyricsClient()
+		lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
+		if lyricsErr != nil {
+			fmt.Printf("[Amazon] Warning: lyrics fetch error: %v\n", lyricsErr)
+		} else if lyrics == nil || len(lyrics.Lines) == 0 {
+			fmt.Println("[Amazon] No lyrics found for this track")
+		} else {
+			fmt.Printf("[Amazon] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
+			lrcContent := convertToLRC(lyrics)
+			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
+				fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+			} else {
+				fmt.Println("[Amazon] Lyrics embedded successfully")
+			}
+		}
+	}
+
+	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
+	return outputPath, nil
+}
--- a/go_backend/cover.go
+++ b/go_backend/cover.go
@ -0,0 +1,101 @@
+package gobackend
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+)
+
+// Spotify image size codes (same as PC version)
+const (
+	spotifySize640 = "ab67616d0000b273" // 640x640
+	spotifySizeMax = "ab67616d000082c1" // Max resolution (~2000x2000)
+)
+
+// downloadCoverToMemory downloads cover art and returns as bytes (no file creation)
+// This avoids file permission issues on Android
+func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
+	if coverURL == "" {
+		return nil, fmt.Errorf("no cover URL provided")
+	}
+
+	fmt.Printf("[Cover] Downloading cover from: %s\n", coverURL)
+
+	// Upgrade to max quality if requested
+	downloadURL := coverURL
+	if maxQuality {
+		downloadURL = upgradeToMaxQuality(coverURL)
+		if downloadURL != coverURL {
+			fmt.Printf("[Cover] Upgraded to max quality URL: %s\n", downloadURL)
+		}
+	}
+
+	client := NewHTTPClientWithTimeout(DefaultTimeout)
+
+	// Create request with User-Agent (required by Spotify CDN)
+	req, err := http.NewRequest("GET", downloadURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := DoRequestWithUserAgent(client, req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to download cover: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("cover download failed: HTTP %d", resp.StatusCode)
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read cover data: %w", err)
+	}
+
+	fmt.Printf("[Cover] Downloaded %d bytes\n", len(data))
+	return data, nil
+}
+
+// upgradeToMaxQuality upgrades Spotify cover URL to maximum quality
+// Uses same logic as PC version - replaces 640x640 size code with max resolution
+func upgradeToMaxQuality(coverURL string) string {
+	// Spotify image URLs can be upgraded by changing the size parameter
+	// Format: https://i.scdn.co/image/ab67616d0000b273...
+	// ab67616d0000b273 = 640x640
+	// ab67616d000082c1 = Max resolution (~2000x2000)
+
+	if strings.Contains(coverURL, spotifySize640) {
+		// Try max resolution first
+		maxURL := strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
+
+		// Verify max resolution URL is available
+		client := NewHTTPClientWithTimeout(DefaultTimeout)
+		req, err := http.NewRequest("HEAD", maxURL, nil)
+		if err == nil {
+			resp, err := DoRequestWithUserAgent(client, req)
+			if err == nil {
+				resp.Body.Close()
+				if resp.StatusCode == http.StatusOK {
+					return maxURL
+				}
+			}
+		}
+	}
+
+	return coverURL
+}
+
+// GetCoverFromSpotify gets cover URL from Spotify metadata
+func GetCoverFromSpotify(imageURL string, maxQuality bool) string {
+	if imageURL == "" {
+		return ""
+	}
+
+	if maxQuality {
+		return upgradeToMaxQuality(imageURL)
+	}
+
+	return imageURL
+}
--- a/go_backend/duplicate.go
+++ b/go_backend/duplicate.go
@ -0,0 +1,63 @@
+package gobackend
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// checkISRCExistsInternal checks if a file with the given ISRC exists (internal use)
+func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
+	if isrc == "" || outputDir == "" {
+		return "", false
+	}
+
+	// Walk through directory looking for FLAC files
+	var foundFile string
+	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		// Only check FLAC files
+		if info.IsDir() || !strings.HasSuffix(strings.ToLower(path), ".flac") {
+			return nil
+		}
+
+		// Read metadata from file
+		metadata, err := ReadMetadata(path)
+		if err != nil {
+			return nil
+		}
+
+		// Check if ISRC matches
+		if metadata.ISRC == isrc {
+			foundFile = path
+			return filepath.SkipAll // Stop walking
+		}
+
+		return nil
+	})
+
+	if foundFile != "" {
+		return foundFile, true
+	}
+
+	return "", false
+}
+
+// CheckISRCExists is the exported version for gomobile (returns string, error)
+// Returns the filepath if exists, empty string if not
+func CheckISRCExists(outputDir, isrc string) (string, error) {
+	filepath, _ := checkISRCExistsInternal(outputDir, isrc)
+	return filepath, nil
+}
+
+// CheckFileExists checks if a file with the given name exists
+func CheckFileExists(filePath string) bool {
+	info, err := os.Stat(filePath)
+	if err != nil {
+		return false
+	}
+	return !info.IsDir() && info.Size() > 0
+}
--- a/go_backend/exports.go
+++ b/go_backend/exports.go
@ -0,0 +1,339 @@
+// Package gobackend provides exported functions for gomobile binding
+// These functions are the bridge between Flutter and Go backend
+package gobackend
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+)
+
+// ParseSpotifyURL parses and validates a Spotify URL
+// Returns JSON with type (track/album/playlist) and ID
+func ParseSpotifyURL(url string) (string, error) {
+	parsed, err := parseSpotifyURI(url)
+	if err != nil {
+		return "", err
+	}
+	
+	result := map[string]string{
+		"type": parsed.Type,
+		"id":   parsed.ID,
+	}
+	
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// GetSpotifyMetadata fetches metadata from Spotify URL
+// Returns JSON with track/album/playlist data
+func GetSpotifyMetadata(spotifyURL string) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	
+	client := NewSpotifyMetadataClient()
+	data, err := client.GetFilteredData(ctx, spotifyURL, false, 0)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(data)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// SearchSpotify searches for tracks on Spotify
+// Returns JSON array of track results
+func SearchSpotify(query string, limit int) (string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	
+	client := NewSpotifyMetadataClient()
+	results, err := client.SearchTracks(ctx, query, limit)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(results)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// CheckAvailability checks track availability on streaming services
+// Returns JSON with availability info for Tidal, Qobuz, Amazon
+func CheckAvailability(spotifyID, isrc string) (string, error) {
+	client := NewSongLinkClient()
+	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
+	if err != nil {
+		return "", err
+	}
+	
+	jsonBytes, err := json.Marshal(availability)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// DownloadRequest represents a download request from Flutter
+type DownloadRequest struct {
+	ISRC                 string `json:"isrc"`
+	Service              string `json:"service"`
+	SpotifyID            string `json:"spotify_id"`
+	TrackName            string `json:"track_name"`
+	ArtistName           string `json:"artist_name"`
+	AlbumName            string `json:"album_name"`
+	AlbumArtist          string `json:"album_artist"`
+	CoverURL             string `json:"cover_url"`
+	OutputDir            string `json:"output_dir"`
+	FilenameFormat       string `json:"filename_format"`
+	EmbedLyrics          bool   `json:"embed_lyrics"`
+	EmbedMaxQualityCover bool   `json:"embed_max_quality_cover"`
+	TrackNumber          int    `json:"track_number"`
+	DiscNumber           int    `json:"disc_number"`
+	TotalTracks          int    `json:"total_tracks"`
+	ReleaseDate          string `json:"release_date"`
+}
+
+// DownloadResponse represents the result of a download
+type DownloadResponse struct {
+	Success       bool   `json:"success"`
+	Message       string `json:"message"`
+	FilePath      string `json:"file_path,omitempty"`
+	Error         string `json:"error,omitempty"`
+	AlreadyExists bool   `json:"already_exists,omitempty"`
+}
+
+// DownloadTrack downloads a track from the specified service
+// requestJSON is a JSON string of DownloadRequest
+// Returns JSON string of DownloadResponse
+func DownloadTrack(requestJSON string) (string, error) {
+	var req DownloadRequest
+	if err := json.Unmarshal([]byte(requestJSON), &req); err != nil {
+		return errorResponse("Invalid request: " + err.Error())
+	}
+	
+	var filePath string
+	var err error
+	
+	switch req.Service {
+	case "tidal":
+		filePath, err = downloadFromTidal(req)
+	case "qobuz":
+		filePath, err = downloadFromQobuz(req)
+	case "amazon":
+		filePath, err = downloadFromAmazon(req)
+	default:
+		return errorResponse("Unknown service: " + req.Service)
+	}
+	
+	if err != nil {
+		return errorResponse(err.Error())
+	}
+	
+	// Check if file already exists
+	if len(filePath) > 7 && filePath[:7] == "EXISTS:" {
+		resp := DownloadResponse{
+			Success:       true,
+			Message:       "File already exists",
+			FilePath:      filePath[7:],
+			AlreadyExists: true,
+		}
+		jsonBytes, _ := json.Marshal(resp)
+		return string(jsonBytes), nil
+	}
+	
+	resp := DownloadResponse{
+		Success:  true,
+		Message:  "Download complete",
+		FilePath: filePath,
+	}
+	
+	jsonBytes, _ := json.Marshal(resp)
+	return string(jsonBytes), nil
+}
+
+// DownloadWithFallback tries to download from services in order
+// Starts with the preferred service from request, then tries others
+func DownloadWithFallback(requestJSON string) (string, error) {
+	var req DownloadRequest
+	if err := json.Unmarshal([]byte(requestJSON), &req); err != nil {
+		return errorResponse("Invalid request: " + err.Error())
+	}
+	
+	// Build service order starting with preferred service
+	allServices := []string{"tidal", "qobuz", "amazon"}
+	preferredService := req.Service
+	if preferredService == "" {
+		preferredService = "tidal"
+	}
+	
+	// Create ordered list: preferred first, then others
+	services := []string{preferredService}
+	for _, s := range allServices {
+		if s != preferredService {
+			services = append(services, s)
+		}
+	}
+	
+	var lastErr error
+	
+	for _, service := range services {
+		req.Service = service
+		
+		var filePath string
+		var err error
+		
+		switch service {
+		case "tidal":
+			filePath, err = downloadFromTidal(req)
+		case "qobuz":
+			filePath, err = downloadFromQobuz(req)
+		case "amazon":
+			filePath, err = downloadFromAmazon(req)
+		}
+		
+		if err == nil {
+			// Check if file already exists
+			if len(filePath) > 7 && filePath[:7] == "EXISTS:" {
+				resp := DownloadResponse{
+					Success:       true,
+					Message:       "File already exists",
+					FilePath:      filePath[7:],
+					AlreadyExists: true,
+				}
+				jsonBytes, _ := json.Marshal(resp)
+				return string(jsonBytes), nil
+			}
+			
+			resp := DownloadResponse{
+				Success:  true,
+				Message:  "Downloaded from " + service,
+				FilePath: filePath,
+			}
+			jsonBytes, _ := json.Marshal(resp)
+			return string(jsonBytes), nil
+		}
+		
+		lastErr = err
+	}
+	
+	return errorResponse("All services failed. Last error: " + lastErr.Error())
+}
+
+// GetDownloadProgress returns current download progress
+func GetDownloadProgress() string {
+	progress := getProgress()
+	jsonBytes, _ := json.Marshal(progress)
+	return string(jsonBytes)
+}
+
+// SetDownloadDirectory sets the default download directory
+func SetDownloadDirectory(path string) error {
+	return setDownloadDir(path)
+}
+
+// CheckDuplicate checks if a file with the given ISRC exists
+func CheckDuplicate(outputDir, isrc string) (string, error) {
+	existingFile, exists := CheckISRCExists(outputDir, isrc)
+	
+	result := map[string]interface{}{
+		"exists":   exists,
+		"filepath": existingFile,
+	}
+	
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+	
+	return string(jsonBytes), nil
+}
+
+// BuildFilename builds a filename from template and metadata
+func BuildFilename(template string, metadataJSON string) (string, error) {
+	var metadata map[string]interface{}
+	if err := json.Unmarshal([]byte(metadataJSON), &metadata); err != nil {
+		return "", err
+	}
+	
+	filename := buildFilenameFromTemplate(template, metadata)
+	return filename, nil
+}
+
+// SanitizeFilename removes invalid characters from filename
+func SanitizeFilename(filename string) string {
+	return sanitizeFilename(filename)
+}
+
+// FetchLyrics fetches lyrics for a track from LRCLIB
+// Returns JSON with lyrics data
+func FetchLyrics(spotifyID, trackName, artistName string) (string, error) {
+	client := NewLyricsClient()
+	lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
+	if err != nil {
+		return "", err
+	}
+
+	result := map[string]interface{}{
+		"success":   true,
+		"source":    lyrics.Source,
+		"sync_type": lyrics.SyncType,
+		"lines":     lyrics.Lines,
+	}
+
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", err
+	}
+
+	return string(jsonBytes), nil
+}
+
+// GetLyricsLRC fetches lyrics and converts to LRC format string
+func GetLyricsLRC(spotifyID, trackName, artistName string) (string, error) {
+	client := NewLyricsClient()
+	lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
+	if err != nil {
+		return "", err
+	}
+
+	lrcContent := convertToLRC(lyrics)
+	return lrcContent, nil
+}
+
+// EmbedLyricsToFile embeds lyrics into an existing FLAC file
+func EmbedLyricsToFile(filePath, lyrics string) (string, error) {
+	err := EmbedLyrics(filePath, lyrics)
+	if err != nil {
+		return errorResponse("Failed to embed lyrics: " + err.Error())
+	}
+
+	resp := map[string]interface{}{
+		"success": true,
+		"message": "Lyrics embedded successfully",
+	}
+
+	jsonBytes, _ := json.Marshal(resp)
+	return string(jsonBytes), nil
+}
+
+func errorResponse(msg string) (string, error) {
+	resp := DownloadResponse{
+		Success: false,
+		Error:   msg,
+	}
+	jsonBytes, _ := json.Marshal(resp)
+	return string(jsonBytes), nil
+}
--- a/go_backend/filename.go
+++ b/go_backend/filename.go
@ -0,0 +1,106 @@
+package gobackend
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Invalid filename characters for Android/Windows/Linux
+var invalidChars = regexp.MustCompile(`[<>:"/\\|?*\x00-\x1f]`)
+
+// sanitizeFilename removes invalid characters from filename
+func sanitizeFilename(filename string) string {
+	// Replace invalid characters with underscore
+	sanitized := invalidChars.ReplaceAllString(filename, "_")
+	
+	// Remove leading/trailing spaces and dots
+	sanitized = strings.TrimSpace(sanitized)
+	sanitized = strings.Trim(sanitized, ".")
+	
+	// Collapse multiple underscores
+	multiUnderscore := regexp.MustCompile(`_+`)
+	sanitized = multiUnderscore.ReplaceAllString(sanitized, "_")
+	
+	// Limit length (Android has 255 byte limit for filenames)
+	if len(sanitized) > 200 {
+		sanitized = sanitized[:200]
+	}
+	
+	// Ensure not empty
+	if sanitized == "" {
+		sanitized = "untitled"
+	}
+	
+	return sanitized
+}
+
+// buildFilenameFromTemplate builds a filename from template and metadata
+func buildFilenameFromTemplate(template string, metadata map[string]interface{}) string {
+	if template == "" {
+		template = "{artist} - {title}"
+	}
+	
+	result := template
+	
+	// Replace placeholders
+	placeholders := map[string]string{
+		"{title}":  getString(metadata, "title"),
+		"{artist}": getString(metadata, "artist"),
+		"{album}":  getString(metadata, "album"),
+		"{track}":  formatTrackNumber(getInt(metadata, "track")),
+		"{year}":   getString(metadata, "year"),
+		"{disc}":   formatDiscNumber(getInt(metadata, "disc")),
+	}
+	
+	for placeholder, value := range placeholders {
+		result = strings.ReplaceAll(result, placeholder, value)
+	}
+	
+	return result
+}
+
+func getString(m map[string]interface{}, key string) string {
+	if v, ok := m[key]; ok {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+func getInt(m map[string]interface{}, key string) int {
+	if v, ok := m[key]; ok {
+		switch n := v.(type) {
+		case int:
+			return n
+		case int64:
+			return int(n)
+		case float64:
+			return int(n)
+		}
+	}
+	return 0
+}
+
+func formatTrackNumber(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("%02d", n)
+}
+
+func formatDiscNumber(n int) string {
+	if n <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("%d", n)
+}
+
+// extractYear extracts year from date string (YYYY-MM-DD or YYYY)
+func extractYear(date string) string {
+	if len(date) >= 4 {
+		return date[:4]
+	}
+	return date
+}
--- a/go_backend/go.mod
+++ b/go_backend/go.mod
@ -0,0 +1,18 @@
+module github.com/zarz/spotiflac_android/go_backend
+
+go 1.24.0
+
+toolchain go1.24.5
+
+require (
+	github.com/go-flac/flacpicture v0.3.0
+	github.com/go-flac/flacvorbis v0.2.0
+	github.com/go-flac/go-flac v1.0.0
+)
+
+require (
+	golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 // indirect
+	golang.org/x/mod v0.31.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/tools v0.40.0 // indirect
+)
--- a/go_backend/go.sum
+++ b/go_backend/go.sum
@ -0,0 +1,14 @@
+github.com/go-flac/flacpicture v0.3.0 h1:LkmTxzFLIynwfhHiZsX0s8xcr3/u33MzvV89u+zOT8I=
+github.com/go-flac/flacpicture v0.3.0/go.mod h1:DPbrzVYQ3fJcvSgLFp9HXIrEQEdfdk/+m0nQCzwodZI=
+github.com/go-flac/flacvorbis v0.2.0 h1:KH0xjpkNTXFER4cszH4zeJxYcrHbUobz/RticWGOESs=
+github.com/go-flac/flacvorbis v0.2.0/go.mod h1:uIysHOtuU7OLGoCRG92bvnkg7QEqHx19qKRV6K1pBrI=
+github.com/go-flac/go-flac v1.0.0 h1:6qI9XOVLcO50xpzm3nXvO31BgDgHhnr/p/rER/K/doY=
+github.com/go-flac/go-flac v1.0.0/go.mod h1:WnZhcpmq4u1UdZMNn9LYSoASpWOCMOoxXxcWEHSzkW8=
+golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 h1:Cr6kbEvA6nqvdHynE4CtVKlqpZB9dS1Jva/6IsHA19g=
+golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294/go.mod h1:RdZ+3sb4CVgpCFnzv+I4haEpwqFfsfzlLHs3L7ok+e0=
+golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
--- a/go_backend/httputil.go
+++ b/go_backend/httputil.go
@ -0,0 +1,213 @@
+package gobackend
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+// HTTP utility functions for consistent request handling across all downloaders
+
+// User-Agent pool for Android Chrome browsers
+var userAgentTemplates = []string{
+	"Mozilla/5.0 (Linux; Android %d; SM-G%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+	"Mozilla/5.0 (Linux; Android %d; Pixel %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+	"Mozilla/5.0 (Linux; Android %d; SM-A%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+	"Mozilla/5.0 (Linux; Android %d; Redmi Note %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+}
+
+// getRandomUserAgent generates a random browser-like User-Agent string (Android Chrome format)
+func getRandomUserAgent() string {
+	template := userAgentTemplates[rand.Intn(len(userAgentTemplates))]
+
+	androidVersion := rand.Intn(5) + 10 // Android 10-14
+	deviceModel := rand.Intn(900) + 100 // Random model number
+	chromeVersion := rand.Intn(25) + 100 // Chrome 100-124
+	chromeBuild := rand.Intn(5000) + 5000
+	chromePatch := rand.Intn(200) + 100
+
+	return fmt.Sprintf(template, androidVersion, deviceModel, chromeVersion, chromeBuild, chromePatch)
+}
+
+// Default timeout values
+const (
+	DefaultTimeout     = 60 * time.Second  // Default HTTP timeout
+	DownloadTimeout    = 120 * time.Second // Timeout for file downloads
+	SongLinkTimeout    = 30 * time.Second  // Timeout for SongLink API
+	DefaultMaxRetries  = 3                 // Default retry count
+	DefaultRetryDelay  = 1 * time.Second   // Initial retry delay
+)
+
+// NewHTTPClientWithTimeout creates an HTTP client with specified timeout
+func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
+	return &http.Client{
+		Timeout: timeout,
+	}
+}
+
+// DoRequestWithUserAgent executes an HTTP request with a random User-Agent header
+func DoRequestWithUserAgent(client *http.Client, req *http.Request) (*http.Response, error) {
+	req.Header.Set("User-Agent", getRandomUserAgent())
+	return client.Do(req)
+}
+
+// RetryConfig holds configuration for retry logic
+type RetryConfig struct {
+	MaxRetries    int
+	InitialDelay  time.Duration
+	MaxDelay      time.Duration
+	BackoffFactor float64
+}
+
+// DefaultRetryConfig returns default retry configuration
+func DefaultRetryConfig() RetryConfig {
+	return RetryConfig{
+		MaxRetries:    DefaultMaxRetries,
+		InitialDelay:  DefaultRetryDelay,
+		MaxDelay:      16 * time.Second,
+		BackoffFactor: 2.0,
+	}
+}
+
+// DoRequestWithRetry executes an HTTP request with retry logic and exponential backoff
+// Handles 429 (Too Many Requests) responses with Retry-After header
+func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConfig) (*http.Response, error) {
+	var lastErr error
+	delay := config.InitialDelay
+
+	for attempt := 0; attempt <= config.MaxRetries; attempt++ {
+		// Clone request for retry (body needs to be re-readable)
+		reqCopy := req.Clone(req.Context())
+		reqCopy.Header.Set("User-Agent", getRandomUserAgent())
+
+		resp, err := client.Do(reqCopy)
+		if err != nil {
+			lastErr = err
+			if attempt < config.MaxRetries {
+				time.Sleep(delay)
+				delay = calculateNextDelay(delay, config)
+			}
+			continue
+		}
+
+		// Success
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			return resp, nil
+		}
+
+		// Handle rate limiting (429)
+		if resp.StatusCode == 429 {
+			resp.Body.Close()
+			retryAfter := getRetryAfterDuration(resp)
+			if retryAfter > 0 {
+				delay = retryAfter
+			}
+			lastErr = fmt.Errorf("rate limited (429)")
+			if attempt < config.MaxRetries {
+				time.Sleep(delay)
+				delay = calculateNextDelay(delay, config)
+			}
+			continue
+		}
+
+		// Server errors (5xx) - retry
+		if resp.StatusCode >= 500 {
+			resp.Body.Close()
+			lastErr = fmt.Errorf("server error: HTTP %d", resp.StatusCode)
+			if attempt < config.MaxRetries {
+				time.Sleep(delay)
+				delay = calculateNextDelay(delay, config)
+			}
+			continue
+		}
+
+		// Client errors (4xx except 429) - don't retry
+		return resp, nil
+	}
+
+	return nil, fmt.Errorf("request failed after %d retries: %w", config.MaxRetries+1, lastErr)
+}
+
+// calculateNextDelay calculates the next delay with exponential backoff
+func calculateNextDelay(currentDelay time.Duration, config RetryConfig) time.Duration {
+	nextDelay := time.Duration(float64(currentDelay) * config.BackoffFactor)
+	if nextDelay > config.MaxDelay {
+		nextDelay = config.MaxDelay
+	}
+	return nextDelay
+}
+
+// getRetryAfterDuration parses Retry-After header and returns duration
+// Returns 60 seconds as default if header is missing or invalid
+func getRetryAfterDuration(resp *http.Response) time.Duration {
+	retryAfter := resp.Header.Get("Retry-After")
+	if retryAfter == "" {
+		return 60 * time.Second // Default wait time
+	}
+
+	// Try parsing as seconds
+	if seconds, err := strconv.Atoi(retryAfter); err == nil {
+		return time.Duration(seconds) * time.Second
+	}
+
+	// Try parsing as HTTP date
+	if t, err := http.ParseTime(retryAfter); err == nil {
+		duration := time.Until(t)
+		if duration > 0 {
+			return duration
+		}
+	}
+
+	return 60 * time.Second // Default
+}
+
+// ReadResponseBody reads and returns the response body
+// Returns error if body is empty
+func ReadResponseBody(resp *http.Response) ([]byte, error) {
+	if resp == nil {
+		return nil, fmt.Errorf("response is nil")
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	if len(body) == 0 {
+		return nil, fmt.Errorf("response body is empty")
+	}
+
+	return body, nil
+}
+
+// ValidateResponse checks if response is valid (non-nil, status 2xx)
+func ValidateResponse(resp *http.Response) error {
+	if resp == nil {
+		return fmt.Errorf("response is nil")
+	}
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return fmt.Errorf("HTTP %d: %s", resp.StatusCode, resp.Status)
+	}
+
+	return nil
+}
+
+// BuildErrorMessage creates a detailed error message for API failures
+func BuildErrorMessage(apiURL string, statusCode int, responsePreview string) string {
+	msg := fmt.Sprintf("API %s failed", apiURL)
+	if statusCode > 0 {
+		msg += fmt.Sprintf(" (HTTP %d)", statusCode)
+	}
+	if responsePreview != "" {
+		// Truncate preview if too long
+		if len(responsePreview) > 100 {
+			responsePreview = responsePreview[:100] + "..."
+		}
+		msg += fmt.Sprintf(": %s", responsePreview)
+	}
+	return msg
+}
--- a/go_backend/lyrics.go
+++ b/go_backend/lyrics.go
@ -0,0 +1,299 @@
+package gobackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type LRCLibResponse struct {
+	ID           int     `json:"id"`
+	Name         string  `json:"name"`
+	TrackName    string  `json:"trackName"`
+	ArtistName   string  `json:"artistName"`
+	AlbumName    string  `json:"albumName"`
+	Duration     float64 `json:"duration"`
+	Instrumental bool    `json:"instrumental"`
+	PlainLyrics  string  `json:"plainLyrics"`
+	SyncedLyrics string  `json:"syncedLyrics"`
+}
+
+type LyricsLine struct {
+	StartTimeMs int64  `json:"startTimeMs"`
+	Words       string `json:"words"`
+	EndTimeMs   int64  `json:"endTimeMs"`
+}
+
+type LyricsResponse struct {
+	Lines        []LyricsLine `json:"lines"`
+	SyncType     string       `json:"syncType"`
+	Instrumental bool         `json:"instrumental"`
+	PlainLyrics  string       `json:"plainLyrics"`
+	Provider     string       `json:"provider"`
+	Source       string       `json:"source"`
+}
+
+type LyricsClient struct {
+	httpClient *http.Client
+}
+
+func NewLyricsClient() *LyricsClient {
+	return &LyricsClient{
+		httpClient: &http.Client{
+			Timeout: 15 * time.Second,
+		},
+	}
+}
+
+func (c *LyricsClient) FetchLyricsWithMetadata(artist, track string) (*LyricsResponse, error) {
+	baseURL := "https://lrclib.net/api/get"
+	params := url.Values{}
+	params.Set("artist_name", artist)
+	params.Set("track_name", track)
+
+	fullURL := baseURL + "?" + params.Encode()
+
+	req, err := http.NewRequest("GET", fullURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", "SpotiFLAC-Android/1.0")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch lyrics: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("lyrics not found")
+	}
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var lrcResp LRCLibResponse
+	if err := json.NewDecoder(resp.Body).Decode(&lrcResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return c.parseLRCLibResponse(&lrcResp), nil
+}
+
+func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string) (*LyricsResponse, error) {
+	baseURL := "https://lrclib.net/api/search"
+	params := url.Values{}
+	params.Set("q", query)
+
+	fullURL := baseURL + "?" + params.Encode()
+
+	req, err := http.NewRequest("GET", fullURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", "SpotiFLAC-Android/1.0")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to search lyrics: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	var results []LRCLibResponse
+	if err := json.NewDecoder(resp.Body).Decode(&results); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	if len(results) == 0 {
+		return nil, fmt.Errorf("no lyrics found")
+	}
+
+	for _, result := range results {
+		if result.SyncedLyrics != "" {
+			return c.parseLRCLibResponse(&result), nil
+		}
+	}
+
+	return c.parseLRCLibResponse(&results[0]), nil
+}
+
+func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string) (*LyricsResponse, error) {
+	// Strategy 1: Direct match with artist and track name
+	lyrics, err := c.FetchLyricsWithMetadata(artistName, trackName)
+	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+		lyrics.Source = "LRCLIB"
+		return lyrics, nil
+	}
+
+	// Strategy 2: Try with simplified track name
+	simplifiedTrack := simplifyTrackName(trackName)
+	if simplifiedTrack != trackName {
+		lyrics, err = c.FetchLyricsWithMetadata(artistName, simplifiedTrack)
+		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+			lyrics.Source = "LRCLIB (simplified)"
+			return lyrics, nil
+		}
+	}
+
+	// Strategy 3: Search with full query
+	query := artistName + " " + trackName
+	lyrics, err = c.FetchLyricsFromLRCLibSearch(query)
+	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+		lyrics.Source = "LRCLIB Search"
+		return lyrics, nil
+	}
+
+	// Strategy 4: Search with simplified query
+	if simplifiedTrack != trackName {
+		query = artistName + " " + simplifiedTrack
+		lyrics, err = c.FetchLyricsFromLRCLibSearch(query)
+		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+			lyrics.Source = "LRCLIB Search (simplified)"
+			return lyrics, nil
+		}
+	}
+
+	return nil, fmt.Errorf("lyrics not found from any source")
+}
+
+func (c *LyricsClient) parseLRCLibResponse(resp *LRCLibResponse) *LyricsResponse {
+	result := &LyricsResponse{
+		Instrumental: resp.Instrumental,
+		PlainLyrics:  resp.PlainLyrics,
+		Provider:     "LRCLIB",
+	}
+
+	if resp.SyncedLyrics != "" {
+		result.Lines = parseSyncedLyrics(resp.SyncedLyrics)
+		result.SyncType = "LINE_SYNCED"
+	} else if resp.PlainLyrics != "" {
+		result.SyncType = "UNSYNCED"
+		lines := strings.Split(resp.PlainLyrics, "\n")
+		for _, line := range lines {
+			if strings.TrimSpace(line) != "" {
+				result.Lines = append(result.Lines, LyricsLine{
+					StartTimeMs: 0,
+					Words:       line,
+					EndTimeMs:   0,
+				})
+			}
+		}
+	}
+
+	return result
+}
+
+func parseSyncedLyrics(syncedLyrics string) []LyricsLine {
+	var lines []LyricsLine
+	lrcPattern := regexp.MustCompile(`\[(\d{2}):(\d{2})\.(\d{2,3})\](.*)`)
+
+	for _, line := range strings.Split(syncedLyrics, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		matches := lrcPattern.FindStringSubmatch(line)
+		if len(matches) == 5 {
+			startMs := lrcTimestampToMs(matches[1], matches[2], matches[3])
+			words := strings.TrimSpace(matches[4])
+
+			lines = append(lines, LyricsLine{
+				StartTimeMs: startMs,
+				Words:       words,
+				EndTimeMs:   0,
+			})
+		}
+	}
+
+	for i := 0; i < len(lines)-1; i++ {
+		lines[i].EndTimeMs = lines[i+1].StartTimeMs
+	}
+
+	if len(lines) > 0 {
+		lines[len(lines)-1].EndTimeMs = lines[len(lines)-1].StartTimeMs + 5000
+	}
+
+	return lines
+}
+
+func lrcTimestampToMs(minutes, seconds, centiseconds string) int64 {
+	min, _ := strconv.ParseInt(minutes, 10, 64)
+	sec, _ := strconv.ParseInt(seconds, 10, 64)
+	cs, _ := strconv.ParseInt(centiseconds, 10, 64)
+
+	if len(centiseconds) == 2 {
+		cs *= 10
+	}
+
+	return min*60*1000 + sec*1000 + cs
+}
+
+func msToLRCTimestamp(ms int64) string {
+	totalSeconds := ms / 1000
+	minutes := totalSeconds / 60
+	seconds := totalSeconds % 60
+	centiseconds := (ms % 1000) / 10
+
+	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
+}
+
+func convertToLRC(lyrics *LyricsResponse) string {
+	if lyrics == nil || len(lyrics.Lines) == 0 {
+		return ""
+	}
+
+	var builder strings.Builder
+
+	if lyrics.SyncType == "LINE_SYNCED" {
+		for _, line := range lyrics.Lines {
+			timestamp := msToLRCTimestamp(line.StartTimeMs)
+			builder.WriteString(timestamp)
+			builder.WriteString(line.Words)
+			builder.WriteString("\n")
+		}
+	} else {
+		for _, line := range lyrics.Lines {
+			builder.WriteString(line.Words)
+			builder.WriteString("\n")
+		}
+	}
+
+	return builder.String()
+}
+
+func simplifyTrackName(name string) string {
+	patterns := []string{
+		`\s*\(feat\..*?\)`,
+		`\s*\(ft\..*?\)`,
+		`\s*\(featuring.*?\)`,
+		`\s*\(with.*?\)`,
+		`\s*-\s*Remaster(ed)?.*$`,
+		`\s*-\s*\d{4}\s*Remaster.*$`,
+		`\s*\(Remaster(ed)?.*?\)`,
+		`\s*\(Deluxe.*?\)`,
+		`\s*\(Bonus.*?\)`,
+		`\s*\(Live.*?\)`,
+		`\s*\(Acoustic.*?\)`,
+		`\s*\(Radio Edit\)`,
+		`\s*\(Single Version\)`,
+	}
+
+	result := name
+	for _, pattern := range patterns {
+		re := regexp.MustCompile("(?i)" + pattern)
+		result = re.ReplaceAllString(result, "")
+	}
+
+	return strings.TrimSpace(result)
+}
--- a/go_backend/metadata.go
+++ b/go_backend/metadata.go
@ -0,0 +1,337 @@
+package gobackend
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+
+	"github.com/go-flac/flacpicture"
+	"github.com/go-flac/flacvorbis"
+	"github.com/go-flac/go-flac"
+)
+
+// Metadata represents track metadata for embedding
+type Metadata struct {
+	Title       string
+	Artist      string
+	Album       string
+	AlbumArtist string
+	Date        string
+	TrackNumber int
+	TotalTracks int
+	DiscNumber  int
+	ISRC        string
+	Description string
+	Lyrics      string
+}
+
+// EmbedMetadata embeds metadata into a FLAC file
+func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	// Find or create vorbis comment block
+	var cmtIdx int = -1
+	var cmt *flacvorbis.MetaDataBlockVorbisComment
+
+	for idx, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmtIdx = idx
+			cmt, err = flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				return fmt.Errorf("failed to parse vorbis comment: %w", err)
+			}
+			break
+		}
+	}
+
+	if cmt == nil {
+		cmt = flacvorbis.New()
+	}
+
+	// Set metadata fields
+	setComment(cmt, "TITLE", metadata.Title)
+	setComment(cmt, "ARTIST", metadata.Artist)
+	setComment(cmt, "ALBUM", metadata.Album)
+	setComment(cmt, "ALBUMARTIST", metadata.AlbumArtist)
+	setComment(cmt, "DATE", metadata.Date)
+	
+	if metadata.TrackNumber > 0 {
+		if metadata.TotalTracks > 0 {
+			setComment(cmt, "TRACKNUMBER", fmt.Sprintf("%d/%d", metadata.TrackNumber, metadata.TotalTracks))
+		} else {
+			setComment(cmt, "TRACKNUMBER", strconv.Itoa(metadata.TrackNumber))
+		}
+	}
+	
+	if metadata.DiscNumber > 0 {
+		setComment(cmt, "DISCNUMBER", strconv.Itoa(metadata.DiscNumber))
+	}
+	
+	if metadata.ISRC != "" {
+		setComment(cmt, "ISRC", metadata.ISRC)
+	}
+	
+	if metadata.Description != "" {
+		setComment(cmt, "DESCRIPTION", metadata.Description)
+	}
+
+	if metadata.Lyrics != "" {
+		setComment(cmt, "LYRICS", metadata.Lyrics)
+		setComment(cmt, "UNSYNCEDLYRICS", metadata.Lyrics)
+	}
+
+	// Update or add vorbis comment block
+	cmtBlock := cmt.Marshal()
+	if cmtIdx >= 0 {
+		f.Meta[cmtIdx] = &cmtBlock
+	} else {
+		f.Meta = append(f.Meta, &cmtBlock)
+	}
+
+	// Add cover art if provided
+	if coverPath != "" {
+		if fileExists(coverPath) {
+			coverData, err := os.ReadFile(coverPath)
+			if err != nil {
+				fmt.Printf("[Metadata] Warning: Failed to read cover file %s: %v\n", coverPath, err)
+			} else {
+				// Remove existing picture blocks first (like PC version)
+				for i := len(f.Meta) - 1; i >= 0; i-- {
+					if f.Meta[i].Type == flac.Picture {
+						f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
+					}
+				}
+				
+				picture, err := flacpicture.NewFromImageData(
+					flacpicture.PictureTypeFrontCover,
+					"Front Cover",
+					coverData,
+					"image/jpeg",
+				)
+				if err != nil {
+					fmt.Printf("[Metadata] Warning: Failed to create picture block: %v\n", err)
+				} else {
+					picBlock := picture.Marshal()
+					f.Meta = append(f.Meta, &picBlock)
+					fmt.Printf("[Metadata] Cover art embedded successfully (%d bytes)\n", len(coverData))
+				}
+			}
+		} else {
+			fmt.Printf("[Metadata] Warning: Cover file does not exist: %s\n", coverPath)
+		}
+	}
+
+	// Save file
+	return f.Save(filePath)
+}
+
+// EmbedMetadataWithCoverData embeds metadata into a FLAC file with cover data as bytes
+// This avoids file permission issues on Android by not requiring a temp file
+func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []byte) error {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	// Find or create vorbis comment block
+	var cmtIdx int = -1
+	var cmt *flacvorbis.MetaDataBlockVorbisComment
+
+	for idx, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmtIdx = idx
+			cmt, err = flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				return fmt.Errorf("failed to parse vorbis comment: %w", err)
+			}
+			break
+		}
+	}
+
+	if cmt == nil {
+		cmt = flacvorbis.New()
+	}
+
+	// Set metadata fields
+	setComment(cmt, "TITLE", metadata.Title)
+	setComment(cmt, "ARTIST", metadata.Artist)
+	setComment(cmt, "ALBUM", metadata.Album)
+	setComment(cmt, "ALBUMARTIST", metadata.AlbumArtist)
+	setComment(cmt, "DATE", metadata.Date)
+	
+	if metadata.TrackNumber > 0 {
+		if metadata.TotalTracks > 0 {
+			setComment(cmt, "TRACKNUMBER", fmt.Sprintf("%d/%d", metadata.TrackNumber, metadata.TotalTracks))
+		} else {
+			setComment(cmt, "TRACKNUMBER", strconv.Itoa(metadata.TrackNumber))
+		}
+	}
+	
+	if metadata.DiscNumber > 0 {
+		setComment(cmt, "DISCNUMBER", strconv.Itoa(metadata.DiscNumber))
+	}
+	
+	if metadata.ISRC != "" {
+		setComment(cmt, "ISRC", metadata.ISRC)
+	}
+	
+	if metadata.Description != "" {
+		setComment(cmt, "DESCRIPTION", metadata.Description)
+	}
+
+	if metadata.Lyrics != "" {
+		setComment(cmt, "LYRICS", metadata.Lyrics)
+		setComment(cmt, "UNSYNCEDLYRICS", metadata.Lyrics)
+	}
+
+	// Update or add vorbis comment block
+	cmtBlock := cmt.Marshal()
+	if cmtIdx >= 0 {
+		f.Meta[cmtIdx] = &cmtBlock
+	} else {
+		f.Meta = append(f.Meta, &cmtBlock)
+	}
+
+	// Add cover art if provided
+	if len(coverData) > 0 {
+		// Remove existing picture blocks first
+		for i := len(f.Meta) - 1; i >= 0; i-- {
+			if f.Meta[i].Type == flac.Picture {
+				f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
+			}
+		}
+		
+		picture, err := flacpicture.NewFromImageData(
+			flacpicture.PictureTypeFrontCover,
+			"Front Cover",
+			coverData,
+			"image/jpeg",
+		)
+		if err != nil {
+			fmt.Printf("[Metadata] Warning: Failed to create picture block: %v\n", err)
+		} else {
+			picBlock := picture.Marshal()
+			f.Meta = append(f.Meta, &picBlock)
+			fmt.Printf("[Metadata] Cover art embedded successfully (%d bytes)\n", len(coverData))
+		}
+	}
+
+	// Save file
+	return f.Save(filePath)
+}
+
+// ReadMetadata reads metadata from a FLAC file
+func ReadMetadata(filePath string) (*Metadata, error) {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	metadata := &Metadata{}
+
+	for _, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmt, err := flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				continue
+			}
+
+			metadata.Title = getComment(cmt, "TITLE")
+			metadata.Artist = getComment(cmt, "ARTIST")
+			metadata.Album = getComment(cmt, "ALBUM")
+			metadata.AlbumArtist = getComment(cmt, "ALBUMARTIST")
+			metadata.Date = getComment(cmt, "DATE")
+			metadata.ISRC = getComment(cmt, "ISRC")
+			metadata.Description = getComment(cmt, "DESCRIPTION")
+
+			metadata.Lyrics = getComment(cmt, "LYRICS")
+			if metadata.Lyrics == "" {
+				metadata.Lyrics = getComment(cmt, "UNSYNCEDLYRICS")
+			}
+
+			trackNum := getComment(cmt, "TRACKNUMBER")
+			if trackNum != "" {
+				fmt.Sscanf(trackNum, "%d", &metadata.TrackNumber)
+			}
+
+			discNum := getComment(cmt, "DISCNUMBER")
+			if discNum != "" {
+				fmt.Sscanf(discNum, "%d", &metadata.DiscNumber)
+			}
+
+			break
+		}
+	}
+
+	return metadata, nil
+}
+
+func setComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key, value string) {
+	if value == "" {
+		return
+	}
+	// Remove existing
+	for i := len(cmt.Comments) - 1; i >= 0; i-- {
+		if len(cmt.Comments[i]) > len(key)+1 && cmt.Comments[i][:len(key)+1] == key+"=" {
+			cmt.Comments = append(cmt.Comments[:i], cmt.Comments[i+1:]...)
+		}
+	}
+	// Add new
+	cmt.Comments = append(cmt.Comments, key+"="+value)
+}
+
+func getComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key string) string {
+	for _, comment := range cmt.Comments {
+		if len(comment) > len(key)+1 && comment[:len(key)+1] == key+"=" {
+			return comment[len(key)+1:]
+		}
+	}
+	return ""
+}
+
+// fileExists checks if a file exists
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}
+
+// EmbedLyrics embeds lyrics into a FLAC file as a separate operation
+func EmbedLyrics(filePath string, lyrics string) error {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	var cmtIdx int = -1
+	var cmt *flacvorbis.MetaDataBlockVorbisComment
+
+	for idx, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmtIdx = idx
+			cmt, err = flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				return fmt.Errorf("failed to parse vorbis comment: %w", err)
+			}
+			break
+		}
+	}
+
+	if cmt == nil {
+		cmt = flacvorbis.New()
+	}
+
+	setComment(cmt, "LYRICS", lyrics)
+	setComment(cmt, "UNSYNCEDLYRICS", lyrics)
+
+	cmtBlock := cmt.Marshal()
+	if cmtIdx >= 0 {
+		f.Meta[cmtIdx] = &cmtBlock
+	} else {
+		f.Meta = append(f.Meta, &cmtBlock)
+	}
+
+	return f.Save(filePath)
+}
--- a/go_backend/progress.go
+++ b/go_backend/progress.go
@ -0,0 +1,137 @@
+package gobackend
+
+import (
+	"sync"
+)
+
+// DownloadProgress represents current download progress
+type DownloadProgress struct {
+	CurrentFile   string  `json:"current_file"`
+	Progress      float64 `json:"progress"`
+	Speed         float64 `json:"speed_mbps"`
+	BytesTotal    int64   `json:"bytes_total"`
+	BytesReceived int64   `json:"bytes_received"`
+	IsDownloading bool    `json:"is_downloading"`
+}
+
+var (
+	currentProgress DownloadProgress
+	progressMu      sync.RWMutex
+	downloadDir     string
+	downloadDirMu   sync.RWMutex
+)
+
+// getProgress returns current download progress
+func getProgress() DownloadProgress {
+	progressMu.RLock()
+	defer progressMu.RUnlock()
+	return currentProgress
+}
+
+// SetDownloadProgress sets the current download progress (MB downloaded)
+func SetDownloadProgress(mbDownloaded float64) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress.Progress = mbDownloaded
+	currentProgress.IsDownloading = true
+}
+
+// SetDownloadSpeed sets the current download speed
+func SetDownloadSpeed(speedMBps float64) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress.Speed = speedMBps
+}
+
+// SetCurrentFile sets the current file being downloaded and resets progress
+func SetCurrentFile(filename string) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	// Reset progress for new file
+	currentProgress.BytesReceived = 0
+	currentProgress.BytesTotal = 0
+	currentProgress.Progress = 0
+	currentProgress.CurrentFile = filename
+	currentProgress.IsDownloading = true
+}
+
+// ResetProgress resets the download progress
+func ResetProgress() {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress = DownloadProgress{}
+}
+
+// setDownloadDir sets the default download directory
+func setDownloadDir(path string) error {
+	downloadDirMu.Lock()
+	defer downloadDirMu.Unlock()
+	downloadDir = path
+	return nil
+}
+
+// getDownloadDir returns the default download directory
+func getDownloadDir() string {
+	downloadDirMu.RLock()
+	defer downloadDirMu.RUnlock()
+	return downloadDir
+}
+
+// SetDownloading sets the download status
+func SetDownloading(status bool) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress.IsDownloading = status
+}
+
+// SetBytesTotal sets total bytes to download
+func SetBytesTotal(total int64) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress.BytesTotal = total
+}
+
+// SetBytesReceived sets bytes received so far
+func SetBytesReceived(received int64) {
+	progressMu.Lock()
+	defer progressMu.Unlock()
+	currentProgress.BytesReceived = received
+	if currentProgress.BytesTotal > 0 {
+		currentProgress.Progress = float64(received) / float64(currentProgress.BytesTotal) * 100
+	}
+}
+
+// ProgressWriter wraps io.Writer to track download progress
+type ProgressWriter struct {
+	writer  interface{ Write([]byte) (int, error) }
+	total   int64
+	current int64
+}
+
+// NewProgressWriter creates a new progress writer wrapping an io.Writer
+func NewProgressWriter(w interface{ Write([]byte) (int, error) }) *ProgressWriter {
+	// Reset bytes received when starting new download
+	SetBytesReceived(0)
+	return &ProgressWriter{
+		writer:  w,
+		current: 0,
+		total:   0,
+	}
+}
+
+// Write implements io.Writer
+func (pw *ProgressWriter) Write(p []byte) (int, error) {
+	n, err := pw.writer.Write(p)
+	if err != nil {
+		return n, err
+	}
+	pw.current += int64(n)
+	pw.total += int64(n)
+	SetBytesReceived(pw.current)
+	return n, nil
+}
+
+// GetTotal returns total bytes written
+func (pw *ProgressWriter) GetTotal() int64 {
+	return pw.total
+}
--- a/go_backend/qobuz.go
+++ b/go_backend/qobuz.go
@ -0,0 +1,411 @@
+package gobackend
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+)
+
+// QobuzDownloader handles Qobuz downloads
+type QobuzDownloader struct {
+	client *http.Client
+	appID  string
+	apiURL string
+}
+
+// QobuzTrack represents a Qobuz track
+type QobuzTrack struct {
+	ID                  int64   `json:"id"`
+	Title               string  `json:"title"`
+	ISRC                string  `json:"isrc"`
+	Duration            int     `json:"duration"`
+	TrackNumber         int     `json:"track_number"`
+	MaximumBitDepth     int     `json:"maximum_bit_depth"`
+	MaximumSamplingRate float64 `json:"maximum_sampling_rate"`
+	Album               struct {
+		Title       string `json:"title"`
+		ReleaseDate string `json:"release_date_original"`
+		Image       struct {
+			Large string `json:"large"`
+		} `json:"image"`
+	} `json:"album"`
+	Performer struct {
+		Name string `json:"name"`
+	} `json:"performer"`
+}
+
+// NewQobuzDownloader creates a new Qobuz downloader
+func NewQobuzDownloader() *QobuzDownloader {
+	return &QobuzDownloader{
+		client: NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
+		appID:  "798273057",
+	}
+}
+
+// GetAvailableAPIs returns list of available Qobuz APIs
+// Uses same APIs as PC version for compatibility
+func (q *QobuzDownloader) GetAvailableAPIs() []string {
+	// Same APIs as PC version (referensi/backend/qobuz.go)
+	// Primary: dab.yeet.su, Fallback: dabmusic.xyz
+	encodedAPIs := []string{
+		"ZGFiLnllZXQuc3UvYXBpL3N0cmVhbT90cmFja0lkPQ==",     // dab.yeet.su/api/stream?trackId= (PRIMARY - same as PC)
+		"ZGFibXVzaWMueHl6L2FwaS9zdHJlYW0/dHJhY2tJZD0=",     // dabmusic.xyz/api/stream?trackId= (FALLBACK - same as PC)
+	}
+
+	var apis []string
+	for _, encoded := range encodedAPIs {
+		decoded, err := base64.StdEncoding.DecodeString(encoded)
+		if err != nil {
+			continue
+		}
+		apis = append(apis, "https://"+string(decoded))
+	}
+
+	return apis
+}
+
+// SearchTrackByISRC searches for a track by ISRC
+func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
+	searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(isrc), q.appID)
+
+	req, err := http.NewRequest("GET", searchURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := DoRequestWithUserAgent(q.client, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("search failed: HTTP %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Tracks struct {
+			Items []QobuzTrack `json:"items"`
+		} `json:"tracks"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Find exact ISRC match
+	for i := range result.Tracks.Items {
+		if result.Tracks.Items[i].ISRC == isrc {
+			return &result.Tracks.Items[i], nil
+		}
+	}
+
+	if len(result.Tracks.Items) == 0 {
+		return nil, fmt.Errorf("no tracks found for ISRC: %s", isrc)
+	}
+
+	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
+}
+
+// SearchTrackByMetadata searches for a track using artist name and track name
+func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*QobuzTrack, error) {
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
+
+	// Try multiple search strategies
+	queries := []string{}
+
+	// Strategy 1: Artist + Track name
+	if artistName != "" && trackName != "" {
+		queries = append(queries, artistName+" "+trackName)
+	}
+
+	// Strategy 2: Track name only
+	if trackName != "" {
+		queries = append(queries, trackName)
+	}
+
+	for _, query := range queries {
+		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(query), q.appID)
+
+		req, err := http.NewRequest("GET", searchURL, nil)
+		if err != nil {
+			continue
+		}
+
+		resp, err := DoRequestWithUserAgent(q.client, req)
+		if err != nil {
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			resp.Body.Close()
+			continue
+		}
+
+		var result struct {
+			Tracks struct {
+				Items []QobuzTrack `json:"items"`
+			} `json:"tracks"`
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			resp.Body.Close()
+			continue
+		}
+		resp.Body.Close()
+
+		if len(result.Tracks.Items) > 0 {
+			// Return first result with best quality
+			for i := range result.Tracks.Items {
+				track := &result.Tracks.Items[i]
+				if track.MaximumBitDepth >= 24 {
+					return track, nil
+				}
+			}
+			// Return first result if no hi-res found
+			return &result.Tracks.Items[0], nil
+		}
+	}
+
+	return nil, fmt.Errorf("no tracks found for: %s - %s", artistName, trackName)
+}
+
+// getQobuzDownloadURLSequential requests download URL from APIs sequentially
+// Uses same URL format as PC version: /api/stream?trackId={id}&quality={quality}
+func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string) (string, string, error) {
+	if len(apis) == 0 {
+		return "", "", fmt.Errorf("no APIs available")
+	}
+
+	client := NewHTTPClientWithTimeout(DefaultTimeout)
+	retryConfig := DefaultRetryConfig()
+	var errors []string
+
+	for _, apiURL := range apis {
+		// All APIs now use same format: https://domain/api/stream?trackId={id}&quality={quality}
+		// The apiURL already includes the path, just append trackID and quality
+		reqURL := fmt.Sprintf("%s%d&quality=%s", apiURL, trackID, quality)
+
+		fmt.Printf("[Qobuz] Trying: %s\n", reqURL)
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
+			continue
+		}
+
+		resp, err := DoRequestWithRetry(client, req, retryConfig)
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
+			continue
+		}
+
+		body, err := ReadResponseBody(resp)
+		resp.Body.Close()
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, err.Error()))
+			continue
+		}
+
+		// Check if response is HTML (error page)
+		if len(body) > 0 && body[0] == '<' {
+			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "received HTML instead of JSON"))
+			continue
+		}
+
+		// Check for error in JSON response
+		var errorResp struct {
+			Error string `json:"error"`
+		}
+		if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
+			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, errorResp.Error))
+			continue
+		}
+
+		var result struct {
+			URL string `json:"url"`
+		}
+		if err := json.Unmarshal(body, &result); err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "invalid JSON: "+err.Error()))
+			continue
+		}
+
+		if result.URL != "" {
+			fmt.Printf("[Qobuz] Got download URL from: %s\n", apiURL)
+			return apiURL, result.URL, nil
+		}
+
+		errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "no download URL in response"))
+	}
+
+	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
+}
+
+// GetDownloadURL gets download URL for a track - tries APIs sequentially
+func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
+	apis := q.GetAvailableAPIs()
+	if len(apis) == 0 {
+		return "", fmt.Errorf("no Qobuz API available")
+	}
+
+	_, downloadURL, err := getQobuzDownloadURLSequential(apis, trackID, quality)
+	if err != nil {
+		return "", err
+	}
+
+	return downloadURL, nil
+}
+
+// DownloadFile downloads a file from URL with User-Agent and progress tracking
+func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath string) error {
+	// Set current file being downloaded
+	SetCurrentFile(filepath.Base(outputPath))
+	SetDownloading(true)
+	defer SetDownloading(false)
+
+	req, err := http.NewRequest("GET", downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := DoRequestWithUserAgent(q.client, req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+	}
+
+	// Set total bytes if available
+	if resp.ContentLength > 0 {
+		SetBytesTotal(resp.ContentLength)
+	}
+
+	out, err := os.Create(outputPath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Use ProgressWriter for tracking
+	progressWriter := NewProgressWriter(out)
+	_, err = io.Copy(progressWriter, resp.Body)
+	return err
+}
+
+// downloadFromQobuz downloads a track using the request parameters
+func downloadFromQobuz(req DownloadRequest) (string, error) {
+	downloader := NewQobuzDownloader()
+
+	// Check for existing file first
+	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+		return "EXISTS:" + existingFile, nil
+	}
+
+	var track *QobuzTrack
+	var err error
+
+	// Strategy 1: Search by ISRC
+	if req.ISRC != "" {
+		track, err = downloader.SearchTrackByISRC(req.ISRC)
+	}
+
+	// Strategy 2: Search by metadata
+	if track == nil {
+		track, err = downloader.SearchTrackByMetadata(req.TrackName, req.ArtistName)
+	}
+
+	if track == nil {
+		errMsg := "could not find track on Qobuz"
+		if err != nil {
+			errMsg = err.Error()
+		}
+		return "", fmt.Errorf("qobuz search failed: %s", errMsg)
+	}
+
+	// Build filename
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
+		"title":  req.TrackName,
+		"artist": req.ArtistName,
+		"album":  req.AlbumName,
+		"track":  req.TrackNumber,
+		"year":   extractYear(req.ReleaseDate),
+		"disc":   req.DiscNumber,
+	})
+	filename = sanitizeFilename(filename) + ".flac"
+	outputPath := filepath.Join(req.OutputDir, filename)
+
+	// Check if file already exists
+	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+		return "EXISTS:" + outputPath, nil
+	}
+
+	// Get download URL using parallel API requests
+	downloadURL, err := downloader.GetDownloadURL(track.ID, "27") // 27 = FLAC 24-bit
+	if err != nil {
+		return "", fmt.Errorf("failed to get download URL: %w", err)
+	}
+
+	// Download file
+	if err := downloader.DownloadFile(downloadURL, outputPath); err != nil {
+		return "", fmt.Errorf("download failed: %w", err)
+	}
+
+	// Embed metadata
+	metadata := Metadata{
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		AlbumArtist: req.AlbumArtist,
+		Date:        req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		TotalTracks: req.TotalTracks,
+		DiscNumber:  req.DiscNumber,
+		ISRC:        req.ISRC,
+	}
+
+	// Download cover to memory (avoids file permission issues on Android)
+	var coverData []byte
+	if req.CoverURL != "" {
+		fmt.Println("[Qobuz] Downloading cover to memory...")
+		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
+		if err == nil {
+			coverData = data
+			fmt.Printf("[Qobuz] Cover downloaded successfully (%d bytes)\n", len(coverData))
+		} else {
+			fmt.Printf("[Qobuz] Warning: failed to download cover: %v\n", err)
+		}
+	}
+
+	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+	}
+
+	// Embed lyrics if enabled
+	if req.EmbedLyrics {
+		fmt.Println("[Qobuz] Fetching lyrics...")
+		lyricsClient := NewLyricsClient()
+		lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
+		if lyricsErr != nil {
+			fmt.Printf("[Qobuz] Warning: lyrics fetch error: %v\n", lyricsErr)
+		} else if lyrics == nil || len(lyrics.Lines) == 0 {
+			fmt.Println("[Qobuz] No lyrics found for this track")
+		} else {
+			fmt.Printf("[Qobuz] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
+			lrcContent := convertToLRC(lyrics)
+			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
+				fmt.Printf("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
+			} else {
+				fmt.Println("[Qobuz] Lyrics embedded successfully")
+			}
+		}
+	}
+
+	return outputPath, nil
+}
--- a/go_backend/ratelimit.go
+++ b/go_backend/ratelimit.go
@ -0,0 +1,111 @@
+package gobackend
+
+import (
+	"sync"
+	"time"
+)
+
+// RateLimiter implements a sliding window rate limiter
+type RateLimiter struct {
+	mu          sync.Mutex
+	maxRequests int
+	window      time.Duration
+	timestamps  []time.Time
+}
+
+// NewRateLimiter creates a new rate limiter with specified max requests per window
+func NewRateLimiter(maxRequests int, window time.Duration) *RateLimiter {
+	return &RateLimiter{
+		maxRequests: maxRequests,
+		window:      window,
+		timestamps:  make([]time.Time, 0, maxRequests),
+	}
+}
+
+// WaitForSlot blocks until a request is allowed under the rate limit
+// Returns immediately if under the limit, otherwise waits until a slot is available
+func (r *RateLimiter) WaitForSlot() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	now := time.Now()
+
+	// Remove timestamps outside the window
+	r.cleanOldTimestamps(now)
+
+	// If under limit, record and return immediately
+	if len(r.timestamps) < r.maxRequests {
+		r.timestamps = append(r.timestamps, now)
+		return
+	}
+
+	// Calculate wait time until oldest timestamp expires
+	oldestTimestamp := r.timestamps[0]
+	waitUntil := oldestTimestamp.Add(r.window)
+	waitDuration := waitUntil.Sub(now)
+
+	if waitDuration > 0 {
+		// Release lock while waiting
+		r.mu.Unlock()
+		time.Sleep(waitDuration)
+		r.mu.Lock()
+
+		// Clean again after waiting
+		r.cleanOldTimestamps(time.Now())
+	}
+
+	// Record this request
+	r.timestamps = append(r.timestamps, time.Now())
+}
+
+// cleanOldTimestamps removes timestamps that are outside the current window
+func (r *RateLimiter) cleanOldTimestamps(now time.Time) {
+	cutoff := now.Add(-r.window)
+	validStart := 0
+
+	for i, ts := range r.timestamps {
+		if ts.After(cutoff) {
+			validStart = i
+			break
+		}
+		validStart = i + 1
+	}
+
+	if validStart > 0 {
+		r.timestamps = r.timestamps[validStart:]
+	}
+}
+
+// TryAcquire attempts to acquire a slot without blocking
+// Returns true if successful, false if rate limit would be exceeded
+func (r *RateLimiter) TryAcquire() bool {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	now := time.Now()
+	r.cleanOldTimestamps(now)
+
+	if len(r.timestamps) < r.maxRequests {
+		r.timestamps = append(r.timestamps, now)
+		return true
+	}
+
+	return false
+}
+
+// Available returns the number of requests available in the current window
+func (r *RateLimiter) Available() int {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	r.cleanOldTimestamps(time.Now())
+	return r.maxRequests - len(r.timestamps)
+}
+
+// Global SongLink rate limiter - 9 requests per minute (to be safe, limit is 10)
+var songLinkRateLimiter = NewRateLimiter(9, time.Minute)
+
+// GetSongLinkRateLimiter returns the global SongLink rate limiter
+func GetSongLinkRateLimiter() *RateLimiter {
+	return songLinkRateLimiter
+}
--- a/go_backend/romaji.go
+++ b/go_backend/romaji.go
@ -0,0 +1,276 @@
+package gobackend
+
+import (
+	"strings"
+	"unicode"
+)
+
+// Japanese character ranges
+const (
+	hiraganaStart = 0x3040
+	hiraganaEnd   = 0x309F
+	katakanaStart = 0x30A0
+	katakanaEnd   = 0x30FF
+	kanjiStart    = 0x4E00
+	kanjiEnd      = 0x9FFF
+)
+
+// hiraganaToRomaji maps hiragana characters to romaji
+var hiraganaToRomaji = map[rune]string{
+	// Basic vowels
+	'あ': "a", 'い': "i", 'う': "u", 'え': "e", 'お': "o",
+	// K-row
+	'か': "ka", 'き': "ki", 'く': "ku", 'け': "ke", 'こ': "ko",
+	// S-row
+	'さ': "sa", 'し': "shi", 'す': "su", 'せ': "se", 'そ': "so",
+	// T-row
+	'た': "ta", 'ち': "chi", 'つ': "tsu", 'て': "te", 'と': "to",
+	// N-row
+	'な': "na", 'に': "ni", 'ぬ': "nu", 'ね': "ne", 'の': "no",
+	// H-row
+	'は': "ha", 'ひ': "hi", 'ふ': "fu", 'へ': "he", 'ほ': "ho",
+	// M-row
+	'ま': "ma", 'み': "mi", 'む': "mu", 'め': "me", 'も': "mo",
+	// Y-row
+	'や': "ya", 'ゆ': "yu", 'よ': "yo",
+	// R-row
+	'ら': "ra", 'り': "ri", 'る': "ru", 'れ': "re", 'ろ': "ro",
+	// W-row
+	'わ': "wa", 'を': "wo",
+	// N
+	'ん': "n",
+	// Voiced (dakuten) - G-row
+	'が': "ga", 'ぎ': "gi", 'ぐ': "gu", 'げ': "ge", 'ご': "go",
+	// Z-row
+	'ざ': "za", 'じ': "ji", 'ず': "zu", 'ぜ': "ze", 'ぞ': "zo",
+	// D-row
+	'だ': "da", 'ぢ': "ji", 'づ': "zu", 'で': "de", 'ど': "do",
+	// B-row
+	'ば': "ba", 'び': "bi", 'ぶ': "bu", 'べ': "be", 'ぼ': "bo",
+	// P-row (handakuten)
+	'ぱ': "pa", 'ぴ': "pi", 'ぷ': "pu", 'ぺ': "pe", 'ぽ': "po",
+	// Small characters
+	'ゃ': "ya", 'ゅ': "yu", 'ょ': "yo",
+	'ぁ': "a", 'ぃ': "i", 'ぅ': "u", 'ぇ': "e", 'ぉ': "o",
+	'っ': "", // Small tsu - handled specially
+	// Long vowel mark
+	'ー': "",
+}
+
+// katakanaToRomaji maps katakana characters to romaji
+var katakanaToRomaji = map[rune]string{
+	// Basic vowels
+	'ア': "a", 'イ': "i", 'ウ': "u", 'エ': "e", 'オ': "o",
+	// K-row
+	'カ': "ka", 'キ': "ki", 'ク': "ku", 'ケ': "ke", 'コ': "ko",
+	// S-row
+	'サ': "sa", 'シ': "shi", 'ス': "su", 'セ': "se", 'ソ': "so",
+	// T-row
+	'タ': "ta", 'チ': "chi", 'ツ': "tsu", 'テ': "te", 'ト': "to",
+	// N-row
+	'ナ': "na", 'ニ': "ni", 'ヌ': "nu", 'ネ': "ne", 'ノ': "no",
+	// H-row
+	'ハ': "ha", 'ヒ': "hi", 'フ': "fu", 'ヘ': "he", 'ホ': "ho",
+	// M-row
+	'マ': "ma", 'ミ': "mi", 'ム': "mu", 'メ': "me", 'モ': "mo",
+	// Y-row
+	'ヤ': "ya", 'ユ': "yu", 'ヨ': "yo",
+	// R-row
+	'ラ': "ra", 'リ': "ri", 'ル': "ru", 'レ': "re", 'ロ': "ro",
+	// W-row
+	'ワ': "wa", 'ヲ': "wo",
+	// N
+	'ン': "n",
+	// Voiced (dakuten) - G-row
+	'ガ': "ga", 'ギ': "gi", 'グ': "gu", 'ゲ': "ge", 'ゴ': "go",
+	// Z-row
+	'ザ': "za", 'ジ': "ji", 'ズ': "zu", 'ゼ': "ze", 'ゾ': "zo",
+	// D-row
+	'ダ': "da", 'ヂ': "ji", 'ヅ': "zu", 'デ': "de", 'ド': "do",
+	// B-row
+	'バ': "ba", 'ビ': "bi", 'ブ': "bu", 'ベ': "be", 'ボ': "bo",
+	// P-row (handakuten)
+	'パ': "pa", 'ピ': "pi", 'プ': "pu", 'ペ': "pe", 'ポ': "po",
+	// Small characters
+	'ャ': "ya", 'ュ': "yu", 'ョ': "yo",
+	'ァ': "a", 'ィ': "i", 'ゥ': "u", 'ェ': "e", 'ォ': "o",
+	'ッ': "", // Small tsu - handled specially
+	// Extended katakana
+	'ヴ': "vu",
+	// Long vowel mark
+	'ー': "",
+}
+
+// Extended katakana combinations (multi-character)
+var katakanaExtended = map[string]string{
+	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
+}
+
+// Combination mappings for small ya/yu/yo
+var hiraganaCombo = map[string]string{
+	"きゃ": "kya", "きゅ": "kyu", "きょ": "kyo",
+	"しゃ": "sha", "しゅ": "shu", "しょ": "sho",
+	"ちゃ": "cha", "ちゅ": "chu", "ちょ": "cho",
+	"にゃ": "nya", "にゅ": "nyu", "にょ": "nyo",
+	"ひゃ": "hya", "ひゅ": "hyu", "ひょ": "hyo",
+	"みゃ": "mya", "みゅ": "myu", "みょ": "myo",
+	"りゃ": "rya", "りゅ": "ryu", "りょ": "ryo",
+	"ぎゃ": "gya", "ぎゅ": "gyu", "ぎょ": "gyo",
+	"じゃ": "ja", "じゅ": "ju", "じょ": "jo",
+	"びゃ": "bya", "びゅ": "byu", "びょ": "byo",
+	"ぴゃ": "pya", "ぴゅ": "pyu", "ぴょ": "pyo",
+}
+
+var katakanaCombo = map[string]string{
+	"キャ": "kya", "キュ": "kyu", "キョ": "kyo",
+	"シャ": "sha", "シュ": "shu", "ショ": "sho",
+	"チャ": "cha", "チュ": "chu", "チョ": "cho",
+	"ニャ": "nya", "ニュ": "nyu", "ニョ": "nyo",
+	"ヒャ": "hya", "ヒュ": "hyu", "ヒョ": "hyo",
+	"ミャ": "mya", "ミュ": "myu", "ミョ": "myo",
+	"リャ": "rya", "リュ": "ryu", "リョ": "ryo",
+	"ギャ": "gya", "ギュ": "gyu", "ギョ": "gyo",
+	"ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
+	"ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
+	"ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
+	// Extended katakana combinations
+	"ティ": "ti", "ディ": "di",
+	"トゥ": "tu", "ドゥ": "du",
+	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
+	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
+	"ヴァ": "va", "ヴィ": "vi", "ヴェ": "ve", "ヴォ": "vo",
+}
+
+// ContainsJapanese checks if a string contains Japanese characters (Hiragana, Katakana, or Kanji)
+func ContainsJapanese(s string) bool {
+	for _, r := range s {
+		if isHiragana(r) || isKatakana(r) || isKanji(r) {
+			return true
+		}
+	}
+	return false
+}
+
+// ContainsKana checks if a string contains Hiragana or Katakana (convertible to romaji)
+func ContainsKana(s string) bool {
+	for _, r := range s {
+		if isHiragana(r) || isKatakana(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func isHiragana(r rune) bool {
+	return r >= hiraganaStart && r <= hiraganaEnd
+}
+
+func isKatakana(r rune) bool {
+	return r >= katakanaStart && r <= katakanaEnd
+}
+
+func isKanji(r rune) bool {
+	return r >= kanjiStart && r <= kanjiEnd
+}
+
+// ToRomaji converts Japanese kana (Hiragana/Katakana) to romaji
+// Kanji characters are preserved as-is since they require dictionary lookup
+func ToRomaji(s string) string {
+	if !ContainsKana(s) {
+		return s
+	}
+
+	runes := []rune(s)
+	var result strings.Builder
+	result.Grow(len(s) * 2) // Romaji is typically longer
+
+	i := 0
+	for i < len(runes) {
+		r := runes[i]
+
+		// Check for two-character combinations first
+		if i+1 < len(runes) {
+			combo := string(runes[i : i+2])
+			if romaji, ok := hiraganaCombo[combo]; ok {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+			if romaji, ok := katakanaCombo[combo]; ok {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+		}
+
+		// Handle small tsu (っ/ッ) - doubles the next consonant
+		if r == 'っ' || r == 'ッ' {
+			if i+1 < len(runes) {
+				nextRune := runes[i+1]
+				var nextRomaji string
+				if romaji, ok := hiraganaToRomaji[nextRune]; ok {
+					nextRomaji = romaji
+				} else if romaji, ok := katakanaToRomaji[nextRune]; ok {
+					nextRomaji = romaji
+				}
+				if len(nextRomaji) > 0 {
+					result.WriteByte(nextRomaji[0]) // Double the consonant
+				}
+			}
+			i++
+			continue
+		}
+
+		// Handle long vowel mark (ー)
+		if r == 'ー' {
+			// Extend the previous vowel
+			resultStr := result.String()
+			if len(resultStr) > 0 {
+				lastChar := resultStr[len(resultStr)-1]
+				if lastChar == 'a' || lastChar == 'i' || lastChar == 'u' || lastChar == 'e' || lastChar == 'o' {
+					result.WriteByte(lastChar)
+				}
+			}
+			i++
+			continue
+		}
+
+		// Single character conversion
+		if romaji, ok := hiraganaToRomaji[r]; ok {
+			result.WriteString(romaji)
+			i++
+			continue
+		}
+
+		if romaji, ok := katakanaToRomaji[r]; ok {
+			result.WriteString(romaji)
+			i++
+			continue
+		}
+
+		// Keep non-Japanese characters as-is
+		if unicode.IsSpace(r) {
+			result.WriteRune(' ')
+		} else {
+			result.WriteRune(r)
+		}
+		i++
+	}
+
+	return result.String()
+}
+
+// GetRomajiVariants returns search variants for Japanese text
+// Returns the original string plus romaji version if applicable
+func GetRomajiVariants(s string) []string {
+	variants := []string{s}
+
+	if ContainsKana(s) {
+		romaji := ToRomaji(s)
+		if romaji != s && strings.TrimSpace(romaji) != "" {
+			variants = append(variants, romaji)
+		}
+	}
+
+	return variants
+}
--- a/go_backend/songlink.go
+++ b/go_backend/songlink.go
@ -0,0 +1,153 @@
+package gobackend
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// SongLinkClient handles song.link API interactions
+type SongLinkClient struct {
+	client *http.Client
+}
+
+// TrackAvailability represents track availability on different platforms
+type TrackAvailability struct {
+	SpotifyID string `json:"spotify_id"`
+	Tidal     bool   `json:"tidal"`
+	Amazon    bool   `json:"amazon"`
+	Qobuz     bool   `json:"qobuz"`
+	TidalURL  string `json:"tidal_url,omitempty"`
+	AmazonURL string `json:"amazon_url,omitempty"`
+	QobuzURL  string `json:"qobuz_url,omitempty"`
+}
+
+// NewSongLinkClient creates a new SongLink client
+func NewSongLinkClient() *SongLinkClient {
+	return &SongLinkClient{
+		client: NewHTTPClientWithTimeout(SongLinkTimeout), // 30s timeout
+	}
+}
+
+// CheckTrackAvailability checks track availability on streaming platforms
+func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
+	// Use global rate limiter - blocks until request is allowed
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build API URL
+	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
+	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
+
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Use retry logic with User-Agent
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{
+		SpotifyID: spotifyTrackID,
+	}
+
+	// Check Tidal
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+	}
+
+	// Check Amazon
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+
+	// Check Qobuz using ISRC
+	if isrc != "" {
+		availability.Qobuz = checkQobuzAvailability(isrc)
+	}
+
+	return availability, nil
+}
+
+// GetStreamingURLs gets streaming URLs for a Spotify track
+func (s *SongLinkClient) GetStreamingURLs(spotifyTrackID string) (map[string]string, error) {
+	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
+	if err != nil {
+		return nil, err
+	}
+
+	urls := make(map[string]string)
+	if availability.TidalURL != "" {
+		urls["tidal"] = availability.TidalURL
+	}
+	if availability.AmazonURL != "" {
+		urls["amazon"] = availability.AmazonURL
+	}
+
+	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
+}
--- a/go_backend/spotify.go
+++ b/go_backend/spotify.go
@ -0,0 +1,616 @@
+package gobackend
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	spotifyTokenURL     = "https://accounts.spotify.com/api/token"
+	playlistBaseURL     = "https://api.spotify.com/v1/playlists/%s"
+	albumBaseURL        = "https://api.spotify.com/v1/albums/%s"
+	trackBaseURL        = "https://api.spotify.com/v1/tracks/%s"
+	searchBaseURL       = "https://api.spotify.com/v1/search"
+)
+
+var errInvalidSpotifyURL = errors.New("invalid or unsupported Spotify URL")
+
+// SpotifyMetadataClient handles Spotify API interactions
+type SpotifyMetadataClient struct {
+	httpClient     *http.Client
+	clientID       string
+	clientSecret   string
+	cachedToken    string
+	tokenExpiresAt time.Time
+	rng            *rand.Rand
+	rngMu          sync.Mutex
+	userAgent      string
+}
+
+// NewSpotifyMetadataClient creates a new Spotify client
+func NewSpotifyMetadataClient() *SpotifyMetadataClient {
+	src := rand.NewSource(time.Now().UnixNano())
+
+	// Decode credentials from base64
+	clientID := ""
+	if decoded, err := base64.StdEncoding.DecodeString("NWY1NzNjOTYyMDQ5NGJhZTg3ODkwYzBmMDhhNjAyOTM="); err == nil {
+		clientID = string(decoded)
+	}
+
+	clientSecret := ""
+	if decoded, err := base64.StdEncoding.DecodeString("MjEyNDc2ZDliMGYzNDcyZWFhNzYyZDkwYjE5YjBiYTg="); err == nil {
+		clientSecret = string(decoded)
+	}
+
+	c := &SpotifyMetadataClient{
+		httpClient:   &http.Client{Timeout: 15 * time.Second},
+		clientID:     clientID,
+		clientSecret: clientSecret,
+		rng:          rand.New(src),
+	}
+	c.userAgent = c.randomUserAgent()
+	return c
+}
+
+// TrackMetadata represents track information
+type TrackMetadata struct {
+	SpotifyID   string `json:"spotify_id,omitempty"`
+	Artists     string `json:"artists"`
+	Name        string `json:"name"`
+	AlbumName   string `json:"album_name"`
+	AlbumArtist string `json:"album_artist,omitempty"`
+	DurationMS  int    `json:"duration_ms"`
+	Images      string `json:"images"`
+	ReleaseDate string `json:"release_date"`
+	TrackNumber int    `json:"track_number"`
+	TotalTracks int    `json:"total_tracks,omitempty"`
+	DiscNumber  int    `json:"disc_number,omitempty"`
+	ExternalURL string `json:"external_urls"`
+	ISRC        string `json:"isrc"`
+}
+
+// AlbumTrackMetadata holds per-track info for album/playlist
+type AlbumTrackMetadata struct {
+	SpotifyID   string `json:"spotify_id,omitempty"`
+	Artists     string `json:"artists"`
+	Name        string `json:"name"`
+	AlbumName   string `json:"album_name"`
+	AlbumArtist string `json:"album_artist,omitempty"`
+	DurationMS  int    `json:"duration_ms"`
+	Images      string `json:"images"`
+	ReleaseDate string `json:"release_date"`
+	TrackNumber int    `json:"track_number"`
+	TotalTracks int    `json:"total_tracks,omitempty"`
+	DiscNumber  int    `json:"disc_number,omitempty"`
+	ExternalURL string `json:"external_urls"`
+	ISRC        string `json:"isrc"`
+	AlbumID     string `json:"album_id,omitempty"`
+	AlbumURL    string `json:"album_url,omitempty"`
+}
+
+// AlbumInfoMetadata holds album information
+type AlbumInfoMetadata struct {
+	TotalTracks int    `json:"total_tracks"`
+	Name        string `json:"name"`
+	ReleaseDate string `json:"release_date"`
+	Artists     string `json:"artists"`
+	Images      string `json:"images"`
+}
+
+// AlbumResponsePayload is the response for album requests
+type AlbumResponsePayload struct {
+	AlbumInfo AlbumInfoMetadata    `json:"album_info"`
+	TrackList []AlbumTrackMetadata `json:"track_list"`
+}
+
+// PlaylistInfoMetadata holds playlist information
+type PlaylistInfoMetadata struct {
+	Tracks struct {
+		Total int `json:"total"`
+	} `json:"tracks"`
+	Owner struct {
+		DisplayName string `json:"display_name"`
+		Name        string `json:"name"`
+		Images      string `json:"images"`
+	} `json:"owner"`
+}
+
+// PlaylistResponsePayload is the response for playlist requests
+type PlaylistResponsePayload struct {
+	PlaylistInfo PlaylistInfoMetadata `json:"playlist_info"`
+	TrackList    []AlbumTrackMetadata `json:"track_list"`
+}
+
+// TrackResponse is the response for single track requests
+type TrackResponse struct {
+	Track TrackMetadata `json:"track"`
+}
+
+// SearchResult represents search results
+type SearchResult struct {
+	Tracks []TrackMetadata `json:"tracks"`
+	Total  int             `json:"total"`
+}
+
+type spotifyURI struct {
+	Type string
+	ID   string
+}
+
+type accessTokenResponse struct {
+	AccessToken string      `json:"access_token"`
+	ExpiresIn   interface{} `json:"expires_in"`
+	TokenType   string      `json:"token_type"`
+}
+
+// Internal API response types
+type image struct {
+	URL string `json:"url"`
+}
+
+type externalURL struct {
+	Spotify string `json:"spotify"`
+}
+
+type externalID struct {
+	ISRC string `json:"isrc"`
+}
+
+type artist struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+type albumSimplified struct {
+	ID          string      `json:"id"`
+	Name        string      `json:"name"`
+	ReleaseDate string      `json:"release_date"`
+	TotalTracks int         `json:"total_tracks"`
+	Images      []image     `json:"images"`
+	ExternalURL externalURL `json:"external_urls"`
+	Artists     []artist    `json:"artists"`
+}
+
+type trackFull struct {
+	ID          string          `json:"id"`
+	Name        string          `json:"name"`
+	DurationMS  int             `json:"duration_ms"`
+	TrackNumber int             `json:"track_number"`
+	DiscNumber  int             `json:"disc_number"`
+	ExternalURL externalURL     `json:"external_urls"`
+	ExternalID  externalID      `json:"external_ids"`
+	Album       albumSimplified `json:"album"`
+	Artists     []artist        `json:"artists"`
+}
+
+// GetFilteredData fetches and formats Spotify data
+func (c *SpotifyMetadataClient) GetFilteredData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration) (interface{}, error) {
+	parsed, err := parseSpotifyURI(spotifyURL)
+	if err != nil {
+		return nil, err
+	}
+
+	token, err := c.getAccessToken(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	switch parsed.Type {
+	case "track":
+		return c.fetchTrack(ctx, parsed.ID, token)
+	case "album":
+		return c.fetchAlbum(ctx, parsed.ID, token)
+	case "playlist":
+		return c.fetchPlaylist(ctx, parsed.ID, token)
+	default:
+		return nil, fmt.Errorf("unsupported Spotify type: %s", parsed.Type)
+	}
+}
+
+// SearchTracks searches for tracks on Spotify
+func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string, limit int) (*SearchResult, error) {
+	token, err := c.getAccessToken(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	searchURL := fmt.Sprintf("%s?q=%s&type=track&limit=%d", searchBaseURL, url.QueryEscape(query), limit)
+	
+	var response struct {
+		Tracks struct {
+			Items []trackFull `json:"items"`
+			Total int         `json:"total"`
+		} `json:"tracks"`
+	}
+	
+	if err := c.getJSON(ctx, searchURL, token, &response); err != nil {
+		return nil, err
+	}
+
+	result := &SearchResult{
+		Tracks: make([]TrackMetadata, 0, len(response.Tracks.Items)),
+		Total:  response.Tracks.Total,
+	}
+
+	for _, track := range response.Tracks.Items {
+		result.Tracks = append(result.Tracks, TrackMetadata{
+			SpotifyID:   track.ID,
+			Artists:     joinArtists(track.Artists),
+			Name:        track.Name,
+			AlbumName:   track.Album.Name,
+			AlbumArtist: joinArtists(track.Album.Artists),
+			DurationMS:  track.DurationMS,
+			Images:      firstImageURL(track.Album.Images),
+			ReleaseDate: track.Album.ReleaseDate,
+			TrackNumber: track.TrackNumber,
+			TotalTracks: track.Album.TotalTracks,
+			DiscNumber:  track.DiscNumber,
+			ExternalURL: track.ExternalURL.Spotify,
+			ISRC:        track.ExternalID.ISRC,
+		})
+	}
+
+	return result, nil
+}
+
+func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID, token string) (*TrackResponse, error) {
+	var data trackFull
+	if err := c.getJSON(ctx, fmt.Sprintf(trackBaseURL, trackID), token, &data); err != nil {
+		return nil, err
+	}
+
+	return &TrackResponse{
+		Track: TrackMetadata{
+			SpotifyID:   data.ID,
+			Artists:     joinArtists(data.Artists),
+			Name:        data.Name,
+			AlbumName:   data.Album.Name,
+			AlbumArtist: joinArtists(data.Album.Artists),
+			DurationMS:  data.DurationMS,
+			Images:      firstImageURL(data.Album.Images),
+			ReleaseDate: data.Album.ReleaseDate,
+			TrackNumber: data.TrackNumber,
+			TotalTracks: data.Album.TotalTracks,
+			DiscNumber:  data.DiscNumber,
+			ExternalURL: data.ExternalURL.Spotify,
+			ISRC:        data.ExternalID.ISRC,
+		},
+	}, nil
+}
+
+func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token string) (*AlbumResponsePayload, error) {
+	var data struct {
+		Name        string   `json:"name"`
+		ReleaseDate string   `json:"release_date"`
+		TotalTracks int      `json:"total_tracks"`
+		Images      []image  `json:"images"`
+		Artists     []artist `json:"artists"`
+		Tracks      struct {
+			Items []struct {
+				ID          string      `json:"id"`
+				Name        string      `json:"name"`
+				DurationMS  int         `json:"duration_ms"`
+				TrackNumber int         `json:"track_number"`
+				DiscNumber  int         `json:"disc_number"`
+				ExternalURL externalURL `json:"external_urls"`
+				Artists     []artist    `json:"artists"`
+			} `json:"items"`
+		} `json:"tracks"`
+	}
+
+	if err := c.getJSON(ctx, fmt.Sprintf(albumBaseURL, albumID), token, &data); err != nil {
+		return nil, err
+	}
+
+	albumImage := firstImageURL(data.Images)
+	info := AlbumInfoMetadata{
+		TotalTracks: data.TotalTracks,
+		Name:        data.Name,
+		ReleaseDate: data.ReleaseDate,
+		Artists:     joinArtists(data.Artists),
+		Images:      albumImage,
+	}
+
+	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
+	for _, item := range data.Tracks.Items {
+		// Fetch ISRC for each track
+		isrc := c.fetchTrackISRC(ctx, item.ID, token)
+		
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   item.ID,
+			Artists:     joinArtists(item.Artists),
+			Name:        item.Name,
+			AlbumName:   data.Name,
+			AlbumArtist: joinArtists(data.Artists),
+			DurationMS:  item.DurationMS,
+			Images:      albumImage,
+			ReleaseDate: data.ReleaseDate,
+			TrackNumber: item.TrackNumber,
+			TotalTracks: data.TotalTracks,
+			DiscNumber:  item.DiscNumber,
+			ExternalURL: item.ExternalURL.Spotify,
+			ISRC:        isrc,
+			AlbumID:     albumID,
+		})
+	}
+
+	return &AlbumResponsePayload{
+		AlbumInfo: info,
+		TrackList: tracks,
+	}, nil
+}
+
+func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, token string) (*PlaylistResponsePayload, error) {
+	var data struct {
+		Name   string  `json:"name"`
+		Images []image `json:"images"`
+		Owner  struct {
+			DisplayName string `json:"display_name"`
+		} `json:"owner"`
+		Tracks struct {
+			Items []struct {
+				Track *trackFull `json:"track"`
+			} `json:"items"`
+			Total int `json:"total"`
+		} `json:"tracks"`
+	}
+
+	if err := c.getJSON(ctx, fmt.Sprintf(playlistBaseURL, playlistID), token, &data); err != nil {
+		return nil, err
+	}
+
+	var info PlaylistInfoMetadata
+	info.Tracks.Total = data.Tracks.Total
+	info.Owner.DisplayName = data.Owner.DisplayName
+	info.Owner.Name = data.Name
+	info.Owner.Images = firstImageURL(data.Images)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
+	for _, item := range data.Tracks.Items {
+		if item.Track == nil {
+			continue
+		}
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   item.Track.ID,
+			Artists:     joinArtists(item.Track.Artists),
+			Name:        item.Track.Name,
+			AlbumName:   item.Track.Album.Name,
+			AlbumArtist: joinArtists(item.Track.Album.Artists),
+			DurationMS:  item.Track.DurationMS,
+			Images:      firstImageURL(item.Track.Album.Images),
+			ReleaseDate: item.Track.Album.ReleaseDate,
+			TrackNumber: item.Track.TrackNumber,
+			TotalTracks: item.Track.Album.TotalTracks,
+			DiscNumber:  item.Track.DiscNumber,
+			ExternalURL: item.Track.ExternalURL.Spotify,
+			ISRC:        item.Track.ExternalID.ISRC,
+			AlbumID:     item.Track.Album.ID,
+			AlbumURL:    item.Track.Album.ExternalURL.Spotify,
+		})
+	}
+
+	return &PlaylistResponsePayload{
+		PlaylistInfo: info,
+		TrackList:    tracks,
+	}, nil
+}
+
+func (c *SpotifyMetadataClient) fetchTrackISRC(ctx context.Context, trackID, token string) string {
+	var data struct {
+		ExternalID externalID `json:"external_ids"`
+	}
+	if err := c.getJSON(ctx, fmt.Sprintf(trackBaseURL, trackID), token, &data); err != nil {
+		return ""
+	}
+	return data.ExternalID.ISRC
+}
+
+func (c *SpotifyMetadataClient) getAccessToken(ctx context.Context) (string, error) {
+	if c.cachedToken != "" && time.Now().Before(c.tokenExpiresAt) {
+		return c.cachedToken, nil
+	}
+
+	data := url.Values{}
+	data.Set("grant_type", "client_credentials")
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, spotifyTokenURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return "", err
+	}
+
+	req.SetBasicAuth(c.clientID, c.clientSecret)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("failed to get access token: %d", resp.StatusCode)
+	}
+
+	var token accessTokenResponse
+	if err := json.Unmarshal(body, &token); err != nil {
+		return "", err
+	}
+
+	c.cachedToken = token.AccessToken
+	if expiresIn, ok := token.ExpiresIn.(float64); ok {
+		c.tokenExpiresAt = time.Now().Add(time.Duration(expiresIn-60) * time.Second)
+	}
+
+	return token.AccessToken, nil
+}
+
+func (c *SpotifyMetadataClient) getJSON(ctx context.Context, endpoint, token string, dst interface{}) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("User-Agent", c.userAgent)
+	req.Header.Set("Accept", "application/json")
+	if token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("spotify API returned status %d", resp.StatusCode)
+	}
+
+	return json.Unmarshal(body, dst)
+}
+
+func (c *SpotifyMetadataClient) randomUserAgent() string {
+	c.rngMu.Lock()
+	defer c.rngMu.Unlock()
+
+	chromeMajor := 80 + c.rng.Intn(25)
+	chromeBuild := 3000 + c.rng.Intn(1500)
+	chromePatch := 60 + c.rng.Intn(65)
+
+	return fmt.Sprintf(
+		"Mozilla/5.0 (Linux; Android 12) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+		chromeMajor, chromeBuild, chromePatch,
+	)
+}
+
+func parseSpotifyURI(input string) (spotifyURI, error) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return spotifyURI{}, errInvalidSpotifyURL
+	}
+
+	// Handle spotify: URI format
+	if strings.HasPrefix(trimmed, "spotify:") {
+		parts := strings.Split(trimmed, ":")
+		if len(parts) == 3 {
+			switch parts[1] {
+			case "album", "track", "playlist", "artist":
+				return spotifyURI{Type: parts[1], ID: parts[2]}, nil
+			}
+		}
+	}
+
+	// Handle URL format
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return spotifyURI{}, err
+	}
+
+	// Handle embed.spotify.com URLs
+	if parsed.Host == "embed.spotify.com" {
+		if parsed.RawQuery == "" {
+			return spotifyURI{}, errInvalidSpotifyURL
+		}
+		qs, _ := url.ParseQuery(parsed.RawQuery)
+		embedded := qs.Get("uri")
+		if embedded == "" {
+			return spotifyURI{}, errInvalidSpotifyURL
+		}
+		return parseSpotifyURI(embedded)
+	}
+
+	// Handle plain ID (no scheme/host) - defaults to playlist
+	if parsed.Scheme == "" && parsed.Host == "" {
+		id := strings.Trim(strings.TrimSpace(parsed.Path), "/")
+		if id == "" {
+			return spotifyURI{}, errInvalidSpotifyURL
+		}
+		return spotifyURI{Type: "playlist", ID: id}, nil
+	}
+
+	if parsed.Host != "open.spotify.com" && parsed.Host != "play.spotify.com" {
+		return spotifyURI{}, errInvalidSpotifyURL
+	}
+
+	parts := cleanPathParts(parsed.Path)
+	if len(parts) == 0 {
+		return spotifyURI{}, errInvalidSpotifyURL
+	}
+
+	// Skip embed prefix if present
+	if parts[0] == "embed" {
+		parts = parts[1:]
+	}
+	if len(parts) == 0 {
+		return spotifyURI{}, errInvalidSpotifyURL
+	}
+
+	// Skip intl- prefix if present
+	if strings.HasPrefix(parts[0], "intl-") {
+		parts = parts[1:]
+	}
+	if len(parts) == 0 {
+		return spotifyURI{}, errInvalidSpotifyURL
+	}
+
+	// Handle standard URLs: /album/{id}, /track/{id}, /playlist/{id}, /artist/{id}
+	if len(parts) == 2 {
+		switch parts[0] {
+		case "album", "track", "playlist", "artist":
+			return spotifyURI{Type: parts[0], ID: parts[1]}, nil
+		}
+	}
+
+	// Handle nested playlist URLs: /user/{user}/playlist/{id}
+	if len(parts) == 4 && parts[2] == "playlist" {
+		return spotifyURI{Type: "playlist", ID: parts[3]}, nil
+	}
+
+	return spotifyURI{}, errInvalidSpotifyURL
+}
+
+func cleanPathParts(path string) []string {
+	raw := strings.Split(path, "/")
+	parts := make([]string, 0, len(raw))
+	for _, part := range raw {
+		if part != "" {
+			parts = append(parts, part)
+		}
+	}
+	return parts
+}
+
+func joinArtists(artists []artist) string {
+	names := make([]string, len(artists))
+	for i, a := range artists {
+		names[i] = a.Name
+	}
+	return strings.Join(names, ", ")
+}
+
+func firstImageURL(images []image) string {
+	if len(images) > 0 {
+		return images[0].URL
+	}
+	return ""
+}
--- a/go_backend/tidal.go
+++ b/go_backend/tidal.go
@ -0,0 +1,925 @@
+package gobackend
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// TidalDownloader handles Tidal downloads
+type TidalDownloader struct {
+	client       *http.Client
+	clientID     string
+	clientSecret string
+	apiURL       string
+}
+
+// TidalTrack represents a Tidal track
+type TidalTrack struct {
+	ID           int64  `json:"id"`
+	Title        string `json:"title"`
+	ISRC         string `json:"isrc"`
+	AudioQuality string `json:"audioQuality"`
+	TrackNumber  int    `json:"trackNumber"`
+	VolumeNumber int    `json:"volumeNumber"`
+	Duration     int    `json:"duration"`
+	Album        struct {
+		Title       string `json:"title"`
+		Cover       string `json:"cover"`
+		ReleaseDate string `json:"releaseDate"`
+	} `json:"album"`
+	Artists []struct {
+		Name string `json:"name"`
+	} `json:"artists"`
+	Artist struct {
+		Name string `json:"name"`
+	} `json:"artist"`
+	MediaMetadata struct {
+		Tags []string `json:"tags"`
+	} `json:"mediaMetadata"`
+}
+
+// TidalAPIResponseV2 is the new API response format (version 2.0)
+type TidalAPIResponseV2 struct {
+	Version string `json:"version"`
+	Data    struct {
+		TrackID           int64  `json:"trackId"`
+		AssetPresentation string `json:"assetPresentation"`
+		AudioMode         string `json:"audioMode"`
+		AudioQuality      string `json:"audioQuality"`
+		ManifestMimeType  string `json:"manifestMimeType"`
+		ManifestHash      string `json:"manifestHash"`
+		Manifest          string `json:"manifest"`
+		BitDepth          int    `json:"bitDepth"`
+		SampleRate        int    `json:"sampleRate"`
+	} `json:"data"`
+}
+
+// TidalBTSManifest is the BTS (application/vnd.tidal.bts) manifest format
+type TidalBTSManifest struct {
+	MimeType       string   `json:"mimeType"`
+	Codecs         string   `json:"codecs"`
+	EncryptionType string   `json:"encryptionType"`
+	URLs           []string `json:"urls"`
+}
+
+// MPD represents DASH manifest structure
+type MPD struct {
+	XMLName xml.Name `xml:"MPD"`
+	Period  struct {
+		AdaptationSet struct {
+			Representation struct {
+				SegmentTemplate struct {
+					Initialization string `xml:"initialization,attr"`
+					Media          string `xml:"media,attr"`
+					Timeline       struct {
+						Segments []struct {
+							Duration int `xml:"d,attr"`
+							Repeat   int `xml:"r,attr"`
+						} `xml:"S"`
+					} `xml:"SegmentTimeline"`
+				} `xml:"SegmentTemplate"`
+			} `xml:"Representation"`
+		} `xml:"AdaptationSet"`
+	} `xml:"Period"`
+}
+
+// NewTidalDownloader creates a new Tidal downloader
+func NewTidalDownloader() *TidalDownloader {
+	clientID, _ := base64.StdEncoding.DecodeString("NkJEU1JkcEs5aHFFQlRnVQ==")
+	clientSecret, _ := base64.StdEncoding.DecodeString("eGV1UG1ZN25icFo5SUliTEFjUTkzc2hrYTFWTmhlVUFxTjZJY3N6alRHOD0=")
+
+	downloader := &TidalDownloader{
+		client:       NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
+		clientID:     string(clientID),
+		clientSecret: string(clientSecret),
+	}
+
+	// Get first available API
+	apis := downloader.GetAvailableAPIs()
+	if len(apis) > 0 {
+		downloader.apiURL = apis[0]
+	}
+
+	return downloader
+}
+
+// GetAvailableAPIs returns list of available Tidal APIs
+func (t *TidalDownloader) GetAvailableAPIs() []string {
+	encodedAPIs := []string{
+		"dm9nZWwucXFkbC5zaXRl",         // API 1 - vogel.qqdl.site
+		"bWF1cy5xcWRsLnNpdGU=",         // API 2 - maus.qqdl.site
+		"aHVuZC5xcWRsLnNpdGU=",         // API 3 - hund.qqdl.site
+		"a2F0emUucXFkbC5zaXRl",         // API 4 - katze.qqdl.site
+		"d29sZi5xcWRsLnNpdGU=",         // API 5 - wolf.qqdl.site
+		"dGlkYWwua2lub3BsdXMub25saW5l", // API 6 - tidal.kinoplus.online
+		"dGlkYWwtYXBpLmJpbmltdW0ub3Jn", // API 7 - tidal-api.binimum.org
+		"dHJpdG9uLnNxdWlkLnd0Zg==",     // API 8 - triton.squid.wtf
+	}
+
+	var apis []string
+	for _, encoded := range encodedAPIs {
+		decoded, err := base64.StdEncoding.DecodeString(encoded)
+		if err != nil {
+			continue
+		}
+		apis = append(apis, "https://"+string(decoded))
+	}
+
+	return apis
+}
+
+// GetAccessToken gets Tidal access token
+func (t *TidalDownloader) GetAccessToken() (string, error) {
+	data := fmt.Sprintf("client_id=%s&grant_type=client_credentials", t.clientID)
+
+	authURL, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hdXRoLnRpZGFsLmNvbS92MS9vYXV0aDIvdG9rZW4=")
+	req, err := http.NewRequest("POST", string(authURL), strings.NewReader(data))
+	if err != nil {
+		return "", err
+	}
+
+	req.SetBasicAuth(t.clientID, t.clientSecret)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := DoRequestWithUserAgent(t.client, req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("failed to get access token: HTTP %d", resp.StatusCode)
+	}
+
+	var result struct {
+		AccessToken string `json:"access_token"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", err
+	}
+
+	return result.AccessToken, nil
+}
+
+// GetTidalURLFromSpotify gets Tidal URL from Spotify track ID using SongLink
+func (t *TidalDownloader) GetTidalURLFromSpotify(spotifyTrackID string) (string, error) {
+	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
+	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
+
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := DoRequestWithUserAgent(t.client, req)
+	if err != nil {
+		return "", fmt.Errorf("failed to get Tidal URL: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `json:"linksByPlatform"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&songLinkResp); err != nil {
+		return "", fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]
+	if !ok || tidalLink.URL == "" {
+		return "", fmt.Errorf("tidal link not found in SongLink")
+	}
+
+	return tidalLink.URL, nil
+}
+
+// GetTrackIDFromURL extracts track ID from Tidal URL
+func (t *TidalDownloader) GetTrackIDFromURL(tidalURL string) (int64, error) {
+	parts := strings.Split(tidalURL, "/track/")
+	if len(parts) < 2 {
+		return 0, fmt.Errorf("invalid tidal URL format")
+	}
+
+	trackIDStr := strings.Split(parts[1], "?")[0]
+	trackIDStr = strings.TrimSpace(trackIDStr)
+
+	var trackID int64
+	_, err := fmt.Sscanf(trackIDStr, "%d", &trackID)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse track ID: %w", err)
+	}
+
+	return trackID, nil
+}
+
+// GetTrackInfoByID gets track info by Tidal track ID
+func (t *TidalDownloader) GetTrackInfoByID(trackID int64) (*TidalTrack, error) {
+	token, err := t.GetAccessToken()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get access token: %w", err)
+	}
+
+	trackBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkudGlkYWwuY29tL3YxL3RyYWNrcy8=")
+	trackURL := fmt.Sprintf("%s%d?countryCode=US", string(trackBase), trackID)
+
+	req, err := http.NewRequest("GET", trackURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	resp, err := DoRequestWithUserAgent(t.client, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("failed to get track info: HTTP %d", resp.StatusCode)
+	}
+
+	var trackInfo TidalTrack
+	if err := json.NewDecoder(resp.Body).Decode(&trackInfo); err != nil {
+		return nil, err
+	}
+
+	return &trackInfo, nil
+}
+
+
+// SearchTrackByISRC searches for a track by ISRC
+func (t *TidalDownloader) SearchTrackByISRC(isrc string) (*TidalTrack, error) {
+	token, err := t.GetAccessToken()
+	if err != nil {
+		return nil, err
+	}
+
+	searchBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkudGlkYWwuY29tL3YxL3NlYXJjaC90cmFja3M/cXVlcnk9")
+	searchURL := fmt.Sprintf("%s%s&limit=50&countryCode=US", string(searchBase), url.QueryEscape(isrc))
+
+	req, err := http.NewRequest("GET", searchURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	resp, err := DoRequestWithUserAgent(t.client, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("search failed: HTTP %d", resp.StatusCode)
+	}
+
+	var result struct {
+		Items []TidalTrack `json:"items"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Find exact ISRC match
+	for i := range result.Items {
+		if result.Items[i].ISRC == isrc {
+			return &result.Items[i], nil
+		}
+	}
+
+	if len(result.Items) == 0 {
+		return nil, fmt.Errorf("no tracks found for ISRC: %s", isrc)
+	}
+
+	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
+}
+
+// SearchTrackByMetadataWithISRC searches for a track with ISRC matching priority
+func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, spotifyISRC string, expectedDuration int) (*TidalTrack, error) {
+	token, err := t.GetAccessToken()
+	if err != nil {
+		return nil, err
+	}
+
+	// Build search queries - multiple strategies
+	queries := []string{}
+
+	// Strategy 1: Artist + Track name (original)
+	if artistName != "" && trackName != "" {
+		queries = append(queries, artistName+" "+trackName)
+	}
+
+	// Strategy 2: Track name only
+	if trackName != "" {
+		queries = append(queries, trackName)
+	}
+
+	// Strategy 3: Romaji versions if Japanese detected
+	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
+		// Try romaji version of track name
+		if ContainsKana(trackName) {
+			romajiTrack := ToRomaji(trackName)
+			if romajiTrack != trackName {
+				if artistName != "" {
+					queries = append(queries, artistName+" "+romajiTrack)
+				}
+				queries = append(queries, romajiTrack)
+			}
+		}
+		// Try romaji version of artist name
+		if ContainsKana(artistName) {
+			romajiArtist := ToRomaji(artistName)
+			if romajiArtist != artistName {
+				queries = append(queries, romajiArtist+" "+trackName)
+				// Try both romaji
+				if ContainsKana(trackName) {
+					romajiTrack := ToRomaji(trackName)
+					queries = append(queries, romajiArtist+" "+romajiTrack)
+				}
+			}
+		}
+	}
+
+	// Strategy 4: Artist only as last resort
+	if artistName != "" {
+		queries = append(queries, artistName)
+	}
+
+	searchBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkudGlkYWwuY29tL3YxL3NlYXJjaC90cmFja3M/cXVlcnk9")
+
+	// Collect all search results from all queries
+	var allTracks []TidalTrack
+	searchedQueries := make(map[string]bool)
+
+	for _, query := range queries {
+		cleanQuery := strings.TrimSpace(query)
+		if cleanQuery == "" || searchedQueries[cleanQuery] {
+			continue
+		}
+		searchedQueries[cleanQuery] = true
+
+		searchURL := fmt.Sprintf("%s%s&limit=100&countryCode=US", string(searchBase), url.QueryEscape(cleanQuery))
+
+		req, err := http.NewRequest("GET", searchURL, nil)
+		if err != nil {
+			continue
+		}
+
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		resp, err := DoRequestWithUserAgent(t.client, req)
+		if err != nil {
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			resp.Body.Close()
+			continue
+		}
+
+		var result struct {
+			Items []TidalTrack `json:"items"`
+		}
+		if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+			resp.Body.Close()
+			continue
+		}
+		resp.Body.Close()
+
+		if len(result.Items) > 0 {
+			allTracks = append(allTracks, result.Items...)
+		}
+	}
+
+	if len(allTracks) == 0 {
+		return nil, fmt.Errorf("no tracks found for any search query")
+	}
+
+	// Priority 1: Match by ISRC (exact match)
+	if spotifyISRC != "" {
+		for i := range allTracks {
+			track := &allTracks[i]
+			if track.ISRC == spotifyISRC {
+				return track, nil
+			}
+		}
+		// If ISRC was provided but no match found, return error
+		return nil, fmt.Errorf("ISRC mismatch: no track found with ISRC %s on Tidal", spotifyISRC)
+	}
+
+	// Priority 2: Match by duration (within tolerance) + prefer best quality
+	if expectedDuration > 0 {
+		tolerance := 3 // 3 seconds tolerance
+		var durationMatches []*TidalTrack
+
+		for i := range allTracks {
+			track := &allTracks[i]
+			durationDiff := track.Duration - expectedDuration
+			if durationDiff < 0 {
+				durationDiff = -durationDiff
+			}
+			if durationDiff <= tolerance {
+				durationMatches = append(durationMatches, track)
+			}
+		}
+
+		if len(durationMatches) > 0 {
+			// Find best quality among duration matches
+			bestMatch := durationMatches[0]
+			for _, track := range durationMatches {
+				for _, tag := range track.MediaMetadata.Tags {
+					if tag == "HIRES_LOSSLESS" {
+						bestMatch = track
+						break
+					}
+				}
+			}
+			return bestMatch, nil
+		}
+	}
+
+	// Priority 3: Just take the best quality from first results
+	bestMatch := &allTracks[0]
+	for i := range allTracks {
+		track := &allTracks[i]
+		for _, tag := range track.MediaMetadata.Tags {
+			if tag == "HIRES_LOSSLESS" {
+				bestMatch = track
+				break
+			}
+		}
+		if bestMatch != &allTracks[0] {
+			break
+		}
+	}
+
+	return bestMatch, nil
+}
+
+// SearchTrackByMetadata searches for a track using artist name and track name
+func (t *TidalDownloader) SearchTrackByMetadata(trackName, artistName string) (*TidalTrack, error) {
+	return t.SearchTrackByMetadataWithISRC(trackName, artistName, "", 0)
+}
+
+
+// getDownloadURLSequential requests download URL from APIs sequentially
+// Returns the first successful result (supports both v1 and v2 API formats)
+func getDownloadURLSequential(apis []string, trackID int64, quality string) (string, string, error) {
+	if len(apis) == 0 {
+		return "", "", fmt.Errorf("no APIs available")
+	}
+
+	client := NewHTTPClientWithTimeout(DefaultTimeout)
+	retryConfig := DefaultRetryConfig()
+	var errors []string
+
+	for _, apiURL := range apis {
+		reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", apiURL, trackID, quality)
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
+			continue
+		}
+
+		resp, err := DoRequestWithRetry(client, req, retryConfig)
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
+			continue
+		}
+
+		body, err := ReadResponseBody(resp)
+		resp.Body.Close()
+		if err != nil {
+			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, err.Error()))
+			continue
+		}
+
+		// Try v2 format first (object with manifest)
+		var v2Response TidalAPIResponseV2
+		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
+			return apiURL, "MANIFEST:" + v2Response.Data.Manifest, nil
+		}
+
+		// Fallback to v1 format (array with OriginalTrackUrl)
+		var v1Responses []struct {
+			OriginalTrackURL string `json:"OriginalTrackUrl"`
+		}
+		if err := json.Unmarshal(body, &v1Responses); err == nil {
+			for _, item := range v1Responses {
+				if item.OriginalTrackURL != "" {
+					return apiURL, item.OriginalTrackURL, nil
+				}
+			}
+		}
+
+		errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "no download URL or manifest in response"))
+	}
+
+	return "", "", fmt.Errorf("all %d Tidal APIs failed. Errors: %v", len(apis), errors)
+}
+
+// GetDownloadURL gets download URL for a track - tries APIs sequentially
+func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
+	apis := t.GetAvailableAPIs()
+	if len(apis) == 0 {
+		return "", fmt.Errorf("no API URL configured")
+	}
+
+	_, downloadURL, err := getDownloadURLSequential(apis, trackID, quality)
+	if err != nil {
+		return "", fmt.Errorf("failed to get download URL: %w", err)
+	}
+
+	return downloadURL, nil
+}
+
+// parseManifest parses Tidal manifest (supports both BTS and DASH formats)
+func parseManifest(manifestB64 string) (directURL string, initURL string, mediaURLs []string, err error) {
+	manifestBytes, err := base64.StdEncoding.DecodeString(manifestB64)
+	if err != nil {
+		return "", "", nil, fmt.Errorf("failed to decode manifest: %w", err)
+	}
+
+	manifestStr := string(manifestBytes)
+
+	// Check if it's BTS format (JSON) or DASH format (XML)
+	if strings.HasPrefix(manifestStr, "{") {
+		// BTS format - JSON with direct URLs
+		var btsManifest TidalBTSManifest
+		if err := json.Unmarshal(manifestBytes, &btsManifest); err != nil {
+			return "", "", nil, fmt.Errorf("failed to parse BTS manifest: %w", err)
+		}
+
+		if len(btsManifest.URLs) == 0 {
+			return "", "", nil, fmt.Errorf("no URLs in BTS manifest")
+		}
+
+		return btsManifest.URLs[0], "", nil, nil
+	}
+
+	// DASH format - XML with segments
+	var mpd MPD
+	if err := xml.Unmarshal(manifestBytes, &mpd); err != nil {
+		return "", "", nil, fmt.Errorf("failed to parse manifest XML: %w", err)
+	}
+
+	segTemplate := mpd.Period.AdaptationSet.Representation.SegmentTemplate
+	initURL = segTemplate.Initialization
+	mediaTemplate := segTemplate.Media
+
+	if initURL == "" || mediaTemplate == "" {
+		// Fallback: try regex extraction
+		initRe := regexp.MustCompile(`initialization="([^"]+)"`)
+		mediaRe := regexp.MustCompile(`media="([^"]+)"`)
+
+		if match := initRe.FindStringSubmatch(manifestStr); len(match) > 1 {
+			initURL = match[1]
+		}
+		if match := mediaRe.FindStringSubmatch(manifestStr); len(match) > 1 {
+			mediaTemplate = match[1]
+		}
+	}
+
+	if initURL == "" {
+		return "", "", nil, fmt.Errorf("no initialization URL found in manifest")
+	}
+
+	// Unescape HTML entities in URLs
+	initURL = strings.ReplaceAll(initURL, "&amp;", "&")
+	mediaTemplate = strings.ReplaceAll(mediaTemplate, "&amp;", "&")
+
+	// Calculate segment count from timeline
+	segmentCount := 0
+	for _, seg := range segTemplate.Timeline.Segments {
+		segmentCount += seg.Repeat + 1
+	}
+
+	// If no segments found via XML, try regex
+	if segmentCount == 0 {
+		segRe := regexp.MustCompile(`<S d="\d+"(?: r="(\d+)")?`)
+		matches := segRe.FindAllStringSubmatch(manifestStr, -1)
+		for _, match := range matches {
+			repeat := 0
+			if len(match) > 1 && match[1] != "" {
+				fmt.Sscanf(match[1], "%d", &repeat)
+			}
+			segmentCount += repeat + 1
+		}
+	}
+
+	// Generate media URLs for each segment
+	for i := 1; i <= segmentCount; i++ {
+		mediaURL := strings.ReplaceAll(mediaTemplate, "$Number$", fmt.Sprintf("%d", i))
+		mediaURLs = append(mediaURLs, mediaURL)
+	}
+
+	return "", initURL, mediaURLs, nil
+}
+
+
+// DownloadFile downloads a file from URL with progress tracking
+func (t *TidalDownloader) DownloadFile(downloadURL, outputPath string) error {
+	// Handle manifest-based download
+	if strings.HasPrefix(downloadURL, "MANIFEST:") {
+		return t.downloadFromManifest(strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath)
+	}
+
+	// Set current file being downloaded
+	SetCurrentFile(filepath.Base(outputPath))
+	SetDownloading(true)
+	defer SetDownloading(false)
+
+	req, err := http.NewRequest("GET", downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := DoRequestWithUserAgent(t.client, req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+	}
+
+	// Set total bytes if available
+	if resp.ContentLength > 0 {
+		SetBytesTotal(resp.ContentLength)
+	}
+
+	out, err := os.Create(outputPath)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+
+	// Use ProgressWriter for tracking
+	progressWriter := NewProgressWriter(out)
+	_, err = io.Copy(progressWriter, resp.Body)
+	return err
+}
+
+func (t *TidalDownloader) downloadFromManifest(manifestB64, outputPath string) error {
+	directURL, initURL, mediaURLs, err := parseManifest(manifestB64)
+	if err != nil {
+		return fmt.Errorf("failed to parse manifest: %w", err)
+	}
+
+	client := &http.Client{
+		Timeout: 120 * time.Second,
+	}
+
+	// If we have a direct URL (BTS format), download directly
+	if directURL != "" {
+		resp, err := client.Get(directURL)
+		if err != nil {
+			return fmt.Errorf("failed to download file: %w", err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != 200 {
+			return fmt.Errorf("download failed with status %d", resp.StatusCode)
+		}
+
+		out, err := os.Create(outputPath)
+		if err != nil {
+			return fmt.Errorf("failed to create file: %w", err)
+		}
+		defer out.Close()
+
+		_, err = io.Copy(out, resp.Body)
+		return err
+	}
+
+	// DASH format - download segments to temporary file
+	// Note: On Android, we can't use ffmpeg, so we'll try to download as M4A
+	// and hope the player can handle it, or we save as .m4a instead of .flac
+	tempPath := outputPath + ".m4a.tmp"
+	out, err := os.Create(tempPath)
+	if err != nil {
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+
+	// Download initialization segment
+	resp, err := client.Get(initURL)
+	if err != nil {
+		out.Close()
+		os.Remove(tempPath)
+		return fmt.Errorf("failed to download init segment: %w", err)
+	}
+	if resp.StatusCode != 200 {
+		resp.Body.Close()
+		out.Close()
+		os.Remove(tempPath)
+		return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
+	}
+	_, err = io.Copy(out, resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		out.Close()
+		os.Remove(tempPath)
+		return fmt.Errorf("failed to write init segment: %w", err)
+	}
+
+	// Download media segments
+	for i, mediaURL := range mediaURLs {
+		resp, err := client.Get(mediaURL)
+		if err != nil {
+			out.Close()
+			os.Remove(tempPath)
+			return fmt.Errorf("failed to download segment %d: %w", i+1, err)
+		}
+		if resp.StatusCode != 200 {
+			resp.Body.Close()
+			out.Close()
+			os.Remove(tempPath)
+			return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
+		}
+		_, err = io.Copy(out, resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			out.Close()
+			os.Remove(tempPath)
+			return fmt.Errorf("failed to write segment %d: %w", i+1, err)
+		}
+	}
+
+	out.Close()
+
+	// For Android, we'll save as M4A since we can't use ffmpeg
+	// Rename temp file to final output (change extension to .m4a if needed)
+	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	if err := os.Rename(tempPath, m4aPath); err != nil {
+		os.Remove(tempPath)
+		return fmt.Errorf("failed to rename temp file: %w", err)
+	}
+
+	// If the original output was .flac, we need to indicate this is actually m4a
+	// For now, we'll just keep it as m4a
+	return nil
+}
+
+// downloadFromTidal downloads a track using the request parameters
+func downloadFromTidal(req DownloadRequest) (string, error) {
+	downloader := NewTidalDownloader()
+
+	// Check for existing file first
+	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+		return "EXISTS:" + existingFile, nil
+	}
+
+	var track *TidalTrack
+	var err error
+
+	// Strategy 1: Try to get Tidal URL from SongLink (using Spotify ID)
+	if req.SpotifyID != "" {
+		tidalURL, slErr := downloader.GetTidalURLFromSpotify(req.SpotifyID)
+		if slErr == nil && tidalURL != "" {
+			// Extract track ID and get track info
+			trackID, idErr := downloader.GetTrackIDFromURL(tidalURL)
+			if idErr == nil {
+				track, err = downloader.GetTrackInfoByID(trackID)
+			}
+		}
+	}
+
+	// Strategy 2: Search by ISRC with multi-strategy fallback
+	if track == nil && req.ISRC != "" {
+		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, 0)
+	}
+
+	// Strategy 3: Search by metadata only (no ISRC requirement)
+	if track == nil {
+		track, err = downloader.SearchTrackByMetadata(req.TrackName, req.ArtistName)
+	}
+
+	if track == nil {
+		errMsg := "could not find track on Tidal"
+		if err != nil {
+			errMsg = err.Error()
+		}
+		return "", fmt.Errorf("tidal search failed: %s", errMsg)
+	}
+
+	// Build filename
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
+		"title":  req.TrackName,
+		"artist": req.ArtistName,
+		"album":  req.AlbumName,
+		"track":  req.TrackNumber,
+		"year":   extractYear(req.ReleaseDate),
+		"disc":   req.DiscNumber,
+	})
+	filename = sanitizeFilename(filename) + ".flac"
+	outputPath := filepath.Join(req.OutputDir, filename)
+
+	// Check if file already exists
+	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+		return "EXISTS:" + outputPath, nil
+	}
+
+	// Get download URL using parallel API requests
+	downloadURL, err := downloader.GetDownloadURL(track.ID, "LOSSLESS")
+	if err != nil {
+		return "", fmt.Errorf("failed to get download URL: %w", err)
+	}
+
+	// Download file
+	if err := downloader.DownloadFile(downloadURL, outputPath); err != nil {
+		return "", fmt.Errorf("download failed: %w", err)
+	}
+
+	// Check if file was saved as M4A (DASH stream) instead of FLAC
+	// downloadFromManifest saves DASH streams as .m4a
+	actualOutputPath := outputPath
+	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	if _, err := os.Stat(m4aPath); err == nil {
+		// File was saved as M4A, use that path
+		actualOutputPath = m4aPath
+		fmt.Printf("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
+	} else if _, err := os.Stat(outputPath); err != nil {
+		// Neither FLAC nor M4A exists
+		return "", fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+	}
+
+	// Embed metadata
+	metadata := Metadata{
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		AlbumArtist: req.AlbumArtist,
+		Date:        req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		TotalTracks: req.TotalTracks,
+		DiscNumber:  req.DiscNumber,
+		ISRC:        req.ISRC,
+	}
+
+	// Download cover to memory (avoids file permission issues on Android)
+	var coverData []byte
+	if req.CoverURL != "" {
+		fmt.Println("[Tidal] Downloading cover to memory...")
+		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
+		if err == nil {
+			coverData = data
+			fmt.Printf("[Tidal] Cover downloaded successfully (%d bytes)\n", len(coverData))
+		} else {
+			fmt.Printf("[Tidal] Warning: failed to download cover: %v\n", err)
+		}
+	}
+
+	// Only embed metadata to FLAC files (M4A will be converted by Flutter)
+	if strings.HasSuffix(actualOutputPath, ".flac") {
+		if err := EmbedMetadataWithCoverData(actualOutputPath, metadata, coverData); err != nil {
+			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+		}
+
+		// Embed lyrics if enabled
+		if req.EmbedLyrics {
+			fmt.Println("[Tidal] Fetching lyrics...")
+			lyricsClient := NewLyricsClient()
+			lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
+			if lyricsErr != nil {
+				fmt.Printf("[Tidal] Warning: lyrics fetch error: %v\n", lyricsErr)
+			} else if lyrics == nil || len(lyrics.Lines) == 0 {
+				fmt.Println("[Tidal] No lyrics found for this track")
+			} else {
+				fmt.Printf("[Tidal] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
+				lrcContent := convertToLRC(lyrics)
+				if embedErr := EmbedLyrics(actualOutputPath, lrcContent); embedErr != nil {
+					fmt.Printf("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					fmt.Println("[Tidal] Lyrics embedded successfully")
+				}
+			}
+		}
+	} else {
+		fmt.Printf("[Tidal] Skipping metadata embed for M4A file (will be handled after conversion): %s\n", actualOutputPath)
+	}
+
+	return actualOutputPath, nil
+}
--- a/icon.png
+++ b/icon.png
--- a/ios/.gitignore
+++ b/ios/.gitignore
@ -0,0 +1,34 @@
+**/dgph
+*.mode1v3
+*.mode2v3
+*.moved-aside
+*.pbxuser
+*.perspectivev3
+**/*sync/
+.sconsign.dblite
+.tags*
+**/.vagrant/
+**/DerivedData/
+Icon?
+**/Pods/
+**/.symlinks/
+profile
+xcuserdata
+**/.generated/
+Flutter/App.framework
+Flutter/Flutter.framework
+Flutter/Flutter.podspec
+Flutter/Generated.xcconfig
+Flutter/ephemeral/
+Flutter/app.flx
+Flutter/app.zip
+Flutter/flutter_assets/
+Flutter/flutter_export_environment.sh
+ServiceDefinitions.json
+Runner/GeneratedPluginRegistrant.*
+
+# Exceptions to above rules.
+!default.mode1v3
+!default.mode2v3
+!default.pbxuser
+!default.perspectivev3
--- a/ios/Flutter/AppFrameworkInfo.plist
+++ b/ios/Flutter/AppFrameworkInfo.plist
@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>App</string>
+  <key>CFBundleIdentifier</key>
+  <string>io.flutter.flutter.app</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>App</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>MinimumOSVersion</key>
+  <string>13.0</string>
+</dict>
+</plist>
--- a/ios/Flutter/Debug.xcconfig
+++ b/ios/Flutter/Debug.xcconfig
@ -0,0 +1 @@
+#include "Generated.xcconfig"
--- a/ios/Flutter/Release.xcconfig
+++ b/ios/Flutter/Release.xcconfig
@ -0,0 +1 @@
+#include "Generated.xcconfig"
--- a/ios/Podfile
+++ b/ios/Podfile
@ -0,0 +1,51 @@
+# Uncomment this line to define a global platform for your project
+platform :ios, '14.0'
+
+# CocoaPods analytics sends network stats synchronously affecting flutter build latency.
+ENV['COCOAPODS_DISABLE_STATS'] = 'true'
+
+project 'Runner', {
+  'Debug' => :debug,
+  'Profile' => :release,
+  'Release' => :release,
+}
+
+def flutter_root
+  generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__)
+  unless File.exist?(generated_xcode_build_settings_path)
+    raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first"
+  end
+
+  File.foreach(generated_xcode_build_settings_path) do |line|
+    matches = line.match(/FLUTTER_ROOT\=(.*)/)
+    return matches[1].strip if matches
+  end
+  raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get"
+end
+
+require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)
+
+flutter_ios_podfile_setup
+
+target 'Runner' do
+  use_frameworks!
+  use_modular_headers!
+
+  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
+  
+  # FFmpeg for audio conversion (full version with all codecs)
+  # Note: ffmpeg-kit-flutter-new already includes this, but we specify for clarity
+end
+
+target 'RunnerTests' do
+  inherit! :search_paths
+end
+
+post_install do |installer|
+  installer.pods_project.targets.each do |target|
+    flutter_additional_ios_build_settings(target)
+    target.build_configurations.each do |config|
+      config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '14.0'
+    end
+  end
+end
--- a/ios/Runner.xcodeproj/project.pbxproj
+++ b/ios/Runner.xcodeproj/project.pbxproj
@ -0,0 +1,616 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 54;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
+		331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; };
+		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
+		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
+		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
+		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 97C146E61CF9000F007C117D /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 97C146ED1CF9000F007C117D;
+			remoteInfo = Runner;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		9705A1C41CF9048500538489 /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
+		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
+		331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
+		331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
+		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
+		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
+		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
+		9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = "<group>"; };
+		97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		97C146EB1CF9000F007C117D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		331C8082294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXGroup;
+			children = (
+				331C807B294A618700263BE5 /* RunnerTests.swift */,
+			);
+			path = RunnerTests;
+			sourceTree = "<group>";
+		};
+		9740EEB11CF90186004384FC /* Flutter */ = {
+			isa = PBXGroup;
+			children = (
+				3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */,
+				9740EEB21CF90195004384FC /* Debug.xcconfig */,
+				7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
+				9740EEB31CF90195004384FC /* Generated.xcconfig */,
+			);
+			name = Flutter;
+			sourceTree = "<group>";
+		};
+		97C146E51CF9000F007C117D = {
+			isa = PBXGroup;
+			children = (
+				9740EEB11CF90186004384FC /* Flutter */,
+				97C146F01CF9000F007C117D /* Runner */,
+				97C146EF1CF9000F007C117D /* Products */,
+				331C8082294A63A400263BE5 /* RunnerTests */,
+			);
+			sourceTree = "<group>";
+		};
+		97C146EF1CF9000F007C117D /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				97C146EE1CF9000F007C117D /* Runner.app */,
+				331C8081294A63A400263BE5 /* RunnerTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		97C146F01CF9000F007C117D /* Runner */ = {
+			isa = PBXGroup;
+			children = (
+				97C146FA1CF9000F007C117D /* Main.storyboard */,
+				97C146FD1CF9000F007C117D /* Assets.xcassets */,
+				97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */,
+				97C147021CF9000F007C117D /* Info.plist */,
+				1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */,
+				1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */,
+				74858FAE1ED2DC5600515810 /* AppDelegate.swift */,
+				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
+			);
+			path = Runner;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		331C8080294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
+			buildPhases = (
+				331C807D294A63A400263BE5 /* Sources */,
+				331C807F294A63A400263BE5 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				331C8086294A63A400263BE5 /* PBXTargetDependency */,
+			);
+			name = RunnerTests;
+			productName = RunnerTests;
+			productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+		97C146ED1CF9000F007C117D /* Runner */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
+			buildPhases = (
+				9740EEB61CF901F6004384FC /* Run Script */,
+				97C146EA1CF9000F007C117D /* Sources */,
+				97C146EB1CF9000F007C117D /* Frameworks */,
+				97C146EC1CF9000F007C117D /* Resources */,
+				9705A1C41CF9048500538489 /* Embed Frameworks */,
+				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Runner;
+			productName = Runner;
+			productReference = 97C146EE1CF9000F007C117D /* Runner.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		97C146E61CF9000F007C117D /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1510;
+				ORGANIZATIONNAME = "";
+				TargetAttributes = {
+					331C8080294A63A400263BE5 = {
+						CreatedOnToolsVersion = 14.0;
+						TestTargetID = 97C146ED1CF9000F007C117D;
+					};
+					97C146ED1CF9000F007C117D = {
+						CreatedOnToolsVersion = 7.3.1;
+						LastSwiftMigration = 1100;
+					};
+				};
+			};
+			buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 97C146E51CF9000F007C117D;
+			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				97C146ED1CF9000F007C117D /* Runner */,
+				331C8080294A63A400263BE5 /* RunnerTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		331C807F294A63A400263BE5 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EC1CF9000F007C117D /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */,
+				3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */,
+				97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */,
+				97C146FC1CF9000F007C117D /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"${TARGET_BUILD_DIR}/${INFOPLIST_PATH}",
+			);
+			name = "Thin Binary";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
+		};
+		9740EEB61CF901F6004384FC /* Run Script */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Run Script";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		331C807D294A63A400263BE5 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EA1CF9000F007C117D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,
+				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		331C8086294A63A400263BE5 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 97C146ED1CF9000F007C117D /* Runner */;
+			targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		97C146FA1CF9000F007C117D /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C146FB1CF9000F007C117D /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C147001CF9000F007C117D /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		249021D3217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Profile;
+		};
+		249021D4217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Profile;
+		};
+		331C8088294A63A400263BE5 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Debug;
+		};
+		331C8089294A63A400263BE5 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Release;
+		};
+		331C808A294A63A400263BE5 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Profile;
+		};
+		97C147031CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		97C147041CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		97C147061CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		97C147071CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.zarz.spotiflacAndroid;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				331C8088294A63A400263BE5 /* Debug */,
+				331C8089294A63A400263BE5 /* Release */,
+				331C808A294A63A400263BE5 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147031CF9000F007C117D /* Debug */,
+				97C147041CF9000F007C117D /* Release */,
+				249021D3217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147061CF9000F007C117D /* Debug */,
+				97C147071CF9000F007C117D /* Release */,
+				249021D4217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 97C146E61CF9000F007C117D /* Project object */;
+}
--- a/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata
+++ b/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
--- a/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
+++ b/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
--- a/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings
+++ b/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>
--- a/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme
+++ b/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme
@ -0,0 +1,101 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+               BuildableName = "Runner.app"
+               BlueprintName = "Runner"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      customLLDBInitFile = "$(SRCROOT)/Flutter/ephemeral/flutter_lldbinit"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "331C8080294A63A400263BE5"
+               BuildableName = "RunnerTests.xctest"
+               BlueprintName = "RunnerTests"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      customLLDBInitFile = "$(SRCROOT)/Flutter/ephemeral/flutter_lldbinit"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      enableGPUValidationMode = "1"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Profile"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
--- a/ios/Runner.xcworkspace/contents.xcworkspacedata
+++ b/ios/Runner.xcworkspace/contents.xcworkspacedata
@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:Runner.xcodeproj">
+   </FileRef>
+</Workspace>
--- a/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
+++ b/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
--- a/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings
+++ b/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings
@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>
--- a/ios/Runner/AppDelegate.swift
+++ b/ios/Runner/AppDelegate.swift
@ -0,0 +1,155 @@
+import Flutter
+import UIKit
+import Gobackend  // Import Go framework
+
+@main
+@objc class AppDelegate: FlutterAppDelegate {
+    private let CHANNEL = "com.zarz.spotiflac/backend"
+    
+    override func application(
+        _ application: UIApplication,
+        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+    ) -> Bool {
+        
+        let controller = window?.rootViewController as! FlutterViewController
+        let channel = FlutterMethodChannel(
+            name: CHANNEL,
+            binaryMessenger: controller.binaryMessenger
+        )
+        
+        channel.setMethodCallHandler { [weak self] call, result in
+            self?.handleMethodCall(call: call, result: result)
+        }
+        
+        GeneratedPluginRegistrant.register(with: self)
+        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+    }
+    
+    private func handleMethodCall(call: FlutterMethodCall, result: @escaping FlutterResult) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                let response = try self.invokeGoMethod(call: call)
+                DispatchQueue.main.async {
+                    result(response)
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    result(FlutterError(code: "ERROR", message: error.localizedDescription, details: nil))
+                }
+            }
+        }
+    }
+    
+    private func invokeGoMethod(call: FlutterMethodCall) throws -> Any? {
+        var error: NSError?
+        
+        switch call.method {
+        case "parseSpotifyUrl":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendParseSpotifyURL(url, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getSpotifyMetadata":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendGetSpotifyMetadata(url, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "searchSpotify":
+            let args = call.arguments as! [String: Any]
+            let query = args["query"] as! String
+            let limit = args["limit"] as? Int ?? 10
+            let response = GobackendSearchSpotify(query, Int(limit), &error)
+            if let error = error { throw error }
+            return response
+            
+        case "checkAvailability":
+            let args = call.arguments as! [String: Any]
+            let spotifyId = args["spotify_id"] as! String
+            let isrc = args["isrc"] as! String
+            let response = GobackendCheckAvailability(spotifyId, isrc, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "downloadTrack":
+            let requestJson = call.arguments as! String
+            let response = GobackendDownloadTrack(requestJson, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "downloadWithFallback":
+            let requestJson = call.arguments as! String
+            let response = GobackendDownloadWithFallback(requestJson, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getDownloadProgress":
+            let response = GobackendGetDownloadProgress()
+            return response
+            
+        case "setDownloadDirectory":
+            let args = call.arguments as! [String: Any]
+            let path = args["path"] as! String
+            try GobackendSetDownloadDirectory(path)
+            return nil
+            
+        case "checkDuplicate":
+            let args = call.arguments as! [String: Any]
+            let outputDir = args["output_dir"] as! String
+            let isrc = args["isrc"] as! String
+            let response = GobackendCheckDuplicate(outputDir, isrc, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "buildFilename":
+            let args = call.arguments as! [String: Any]
+            let template = args["template"] as! String
+            let metadata = args["metadata"] as! String
+            let response = GobackendBuildFilename(template, metadata, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "sanitizeFilename":
+            let args = call.arguments as! [String: Any]
+            let filename = args["filename"] as! String
+            let response = GobackendSanitizeFilename(filename)
+            return response
+            
+        case "fetchLyrics":
+            let args = call.arguments as! [String: Any]
+            let spotifyId = args["spotify_id"] as! String
+            let trackName = args["track_name"] as! String
+            let artistName = args["artist_name"] as! String
+            let response = GobackendFetchLyrics(spotifyId, trackName, artistName, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getLyricsLRC":
+            let args = call.arguments as! [String: Any]
+            let spotifyId = args["spotify_id"] as! String
+            let trackName = args["track_name"] as! String
+            let artistName = args["artist_name"] as! String
+            let response = GobackendGetLyricsLRC(spotifyId, trackName, artistName, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "embedLyricsToFile":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let lyrics = args["lyrics"] as! String
+            let response = GobackendEmbedLyricsToFile(filePath, lyrics, &error)
+            if let error = error { throw error }
+            return response
+            
+        default:
+            throw NSError(
+                domain: "SpotiFLAC",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "Method not implemented: \(call.method)"]
+            )
+        }
+    }
+}
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json
@ -0,0 +1,122 @@
+{
+  "images" : [
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-20x20@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-20x20@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-40x40@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-40x40@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-60x60@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-60x60@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-20x20@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-20x20@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-29x29@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-29x29@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-40x40@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-40x40@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-76x76@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-76x76@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "83.5x83.5",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-83.5x83.5@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "1024x1024",
+      "idiom" : "ios-marketing",
+      "filename" : "Icon-App-1024x1024@1x.png",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png
--- a/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png
+++ b/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png
--- a/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json
+++ b/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json
@ -0,0 +1,23 @@
+{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage.png",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage@3x.png",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}
--- a/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png
+++ b/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png
--- a/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png
+++ b/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png
--- a/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png
+++ b/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png
--- a/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md
+++ b/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md
@ -0,0 +1,5 @@
+# Launch Screen Assets
+
+You can customize the launch screen with your own desired assets by replacing the image files in this directory.
+
+You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images.
--- a/ios/Runner/Base.lproj/LaunchScreen.storyboard
+++ b/ios/Runner/Base.lproj/LaunchScreen.storyboard
@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="12121" systemVersion="16G29" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="12089"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="Ydg-fD-yQy"/>
+                        <viewControllerLayoutGuide type="bottom" id="xbc-2k-c8Z"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <imageView opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="scaleAspectFit" image="LaunchImage" translatesAutoresizingMaskIntoConstraints="NO" id="YRO-k0-Ey4">
+                                <rect key="frame" x="147" y="383" width="120" height="120"/>
+                                <constraints>
+                                    <constraint firstAttribute="width" constant="120" id="W1h-8b-9pT"/>
+                                    <constraint firstAttribute="height" constant="120" id="H2i-9c-0qU"/>
+                                </constraints>
+                            </imageView>
+                        </subviews>
+                        <!-- Dark theme background color #1a1a2e -->
+                        <color key="backgroundColor" red="0.10196078431" green="0.10196078431" blue="0.18039215686" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        <constraints>
+                            <constraint firstItem="YRO-k0-Ey4" firstAttribute="centerX" secondItem="Ze5-6b-2t3" secondAttribute="centerX" id="1a2-6s-vTC"/>
+                            <constraint firstItem="YRO-k0-Ey4" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="centerY" id="4X2-HB-R7a"/>
+                        </constraints>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+    <resources>
+        <image name="LaunchImage" width="120" height="120"/>
+    </resources>
+</document>
--- a/ios/Runner/Base.lproj/Main.storyboard
+++ b/ios/Runner/Base.lproj/Main.storyboard
@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="10117" systemVersion="15F34" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" initialViewController="BYZ-38-t0r">
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="10085"/>
+    </dependencies>
+    <scenes>
+        <!--Flutter View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="FlutterViewController" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="y3c-jy-aDJ"/>
+                        <viewControllerLayoutGuide type="bottom" id="wfy-db-euE"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="600" height="600"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+        </scene>
+    </scenes>
+</document>
--- a/ios/Runner/Info.plist
+++ b/ios/Runner/Info.plist
@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleDisplayName</key>
+	<string>SpotiFLAC</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>SpotiFLAC</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(FLUTTER_BUILD_NAME)</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>$(FLUTTER_BUILD_NUMBER)</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>CADisableMinimumFrameDurationOnPhone</key>
+	<true/>
+	<key>UIApplicationSupportsIndirectInputEvents</key>
+	<true/>
+	
+	<!-- Network Access -->
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsArbitraryLoads</key>
+		<true/>
+	</dict>
+	
+	<!-- File Sharing - Allow access via Files app -->
+	<key>UIFileSharingEnabled</key>
+	<true/>
+	<key>LSSupportsOpeningDocumentsInPlace</key>
+	<true/>
+	<key>UISupportsDocumentBrowser</key>
+	<true/>
+	
+	<!-- Photo Library (for cover art if needed) -->
+	<key>NSPhotoLibraryUsageDescription</key>
+	<string>SpotiFLAC needs access to save album artwork</string>
+</dict>
+</plist>
--- a/ios/Runner/Runner-Bridging-Header.h
+++ b/ios/Runner/Runner-Bridging-Header.h
@ -0,0 +1 @@
+#import "GeneratedPluginRegistrant.h"
--- a/ios/RunnerTests/RunnerTests.swift
+++ b/ios/RunnerTests/RunnerTests.swift
@ -0,0 +1,12 @@
+import Flutter
+import UIKit
+import XCTest
+
+class RunnerTests: XCTestCase {
+
+  func testExample() {
+    // If you add code to the Runner application, consider adding tests here.
+    // See https://developer.apple.com/documentation/xctest for more information about using XCTest.
+  }
+
+}
--- a/lib/app.dart
+++ b/lib/app.dart
@ -0,0 +1,49 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:go_router/go_router.dart';
+import 'package:spotiflac_android/screens/main_shell.dart';
+import 'package:spotiflac_android/screens/setup_screen.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/theme/dynamic_color_wrapper.dart';
+
+final _routerProvider = Provider<GoRouter>((ref) {
+  final settings = ref.watch(settingsProvider);
+  
+  return GoRouter(
+    initialLocation: settings.isFirstLaunch ? '/setup' : '/',
+    routes: [
+      GoRoute(
+        path: '/',
+        builder: (context, state) => const MainShell(),
+      ),
+      GoRoute(
+        path: '/setup',
+        builder: (context, state) => const SetupScreen(),
+      ),
+    ],
+  );
+});
+
+class SpotiFLACApp extends ConsumerWidget {
+  const SpotiFLACApp({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final router = ref.watch(_routerProvider);
+    
+    return DynamicColorWrapper(
+      builder: (lightTheme, darkTheme, themeMode) {
+        return MaterialApp.router(
+          title: 'SpotiFLAC',
+          debugShowCheckedModeBanner: false,
+          theme: lightTheme,
+          darkTheme: darkTheme,
+          themeMode: themeMode,
+          themeAnimationDuration: const Duration(milliseconds: 300),
+          themeAnimationCurve: Curves.easeInOut,
+          routerConfig: router,
+        );
+      },
+    );
+  }
+}
--- a/lib/main.dart
+++ b/lib/main.dart
@ -0,0 +1,12 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/app.dart';
+
+void main() {
+  WidgetsFlutterBinding.ensureInitialized();
+  runApp(
+    const ProviderScope(
+      child: SpotiFLACApp(),
+    ),
+  );
+}
--- a/lib/models/download_item.dart
+++ b/lib/models/download_item.dart
@ -0,0 +1,62 @@
+import 'package:json_annotation/json_annotation.dart';
+import 'package:spotiflac_android/models/track.dart';
+
+part 'download_item.g.dart';
+
+/// Download status enum
+enum DownloadStatus {
+  queued,
+  downloading,
+  completed,
+  failed,
+  skipped,
+}
+
+@JsonSerializable()
+class DownloadItem {
+  final String id;
+  final Track track;
+  final String service;
+  final DownloadStatus status;
+  final double progress;
+  final String? filePath;
+  final String? error;
+  final DateTime createdAt;
+
+  const DownloadItem({
+    required this.id,
+    required this.track,
+    required this.service,
+    this.status = DownloadStatus.queued,
+    this.progress = 0.0,
+    this.filePath,
+    this.error,
+    required this.createdAt,
+  });
+
+  DownloadItem copyWith({
+    String? id,
+    Track? track,
+    String? service,
+    DownloadStatus? status,
+    double? progress,
+    String? filePath,
+    String? error,
+    DateTime? createdAt,
+  }) {
+    return DownloadItem(
+      id: id ?? this.id,
+      track: track ?? this.track,
+      service: service ?? this.service,
+      status: status ?? this.status,
+      progress: progress ?? this.progress,
+      filePath: filePath ?? this.filePath,
+      error: error ?? this.error,
+      createdAt: createdAt ?? this.createdAt,
+    );
+  }
+
+  factory DownloadItem.fromJson(Map<String, dynamic> json) =>
+      _$DownloadItemFromJson(json);
+  Map<String, dynamic> toJson() => _$DownloadItemToJson(this);
+}
--- a/lib/models/download_item.g.dart
+++ b/lib/models/download_item.g.dart
@ -0,0 +1,58 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'download_item.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+DownloadItem _$DownloadItemFromJson(Map<String, dynamic> json) => DownloadItem(
+      id: json['id'] as String,
+      track: Track.fromJson(json['track'] as Map<String, dynamic>),
+      service: json['service'] as String,
+      status: $enumDecodeNullable(_$DownloadStatusEnumMap, json['status']) ??
+          DownloadStatus.queued,
+      progress: (json['progress'] as num?)?.toDouble() ?? 0.0,
+      filePath: json['filePath'] as String?,
+      error: json['error'] as String?,
+      createdAt: DateTime.parse(json['createdAt'] as String),
+    );
+
+Map<String, dynamic> _$DownloadItemToJson(DownloadItem instance) =>
+    <String, dynamic>{
+      'id': instance.id,
+      'track': instance.track.toJson(),
+      'service': instance.service,
+      'status': _$DownloadStatusEnumMap[instance.status]!,
+      'progress': instance.progress,
+      'filePath': instance.filePath,
+      'error': instance.error,
+      'createdAt': instance.createdAt.toIso8601String(),
+    };
+
+const _$DownloadStatusEnumMap = {
+  DownloadStatus.queued: 'queued',
+  DownloadStatus.downloading: 'downloading',
+  DownloadStatus.completed: 'completed',
+  DownloadStatus.failed: 'failed',
+  DownloadStatus.skipped: 'skipped',
+};
+
+K? $enumDecodeNullable<K, V>(
+  Map<K, V> enumValues,
+  Object? source, {
+  K? unknownValue,
+}) {
+  if (source == null) {
+    return null;
+  }
+  return enumValues.entries
+      .singleWhere(
+        (e) => e.value == source,
+        orElse: () => throw ArgumentError(
+          '`$source` is not one of the supported values: '
+          '${enumValues.values.join(', ')}',
+        ),
+      )
+      .key;
+}
--- a/lib/models/settings.dart
+++ b/lib/models/settings.dart
@ -0,0 +1,52 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'settings.g.dart';
+
+@JsonSerializable()
+class AppSettings {
+  final String defaultService;
+  final String audioQuality;
+  final String filenameFormat;
+  final String downloadDirectory;
+  final bool autoFallback;
+  final bool embedLyrics;
+  final bool maxQualityCover;
+  final bool isFirstLaunch;
+
+  const AppSettings({
+    this.defaultService = 'tidal',
+    this.audioQuality = 'LOSSLESS',
+    this.filenameFormat = '{title} - {artist}',
+    this.downloadDirectory = '',
+    this.autoFallback = true,
+    this.embedLyrics = true,
+    this.maxQualityCover = true,
+    this.isFirstLaunch = true,
+  });
+
+  AppSettings copyWith({
+    String? defaultService,
+    String? audioQuality,
+    String? filenameFormat,
+    String? downloadDirectory,
+    bool? autoFallback,
+    bool? embedLyrics,
+    bool? maxQualityCover,
+    bool? isFirstLaunch,
+  }) {
+    return AppSettings(
+      defaultService: defaultService ?? this.defaultService,
+      audioQuality: audioQuality ?? this.audioQuality,
+      filenameFormat: filenameFormat ?? this.filenameFormat,
+      downloadDirectory: downloadDirectory ?? this.downloadDirectory,
+      autoFallback: autoFallback ?? this.autoFallback,
+      embedLyrics: embedLyrics ?? this.embedLyrics,
+      maxQualityCover: maxQualityCover ?? this.maxQualityCover,
+      isFirstLaunch: isFirstLaunch ?? this.isFirstLaunch,
+    );
+  }
+
+  factory AppSettings.fromJson(Map<String, dynamic> json) =>
+      _$AppSettingsFromJson(json);
+  Map<String, dynamic> toJson() => _$AppSettingsToJson(this);
+}
--- a/lib/models/settings.g.dart
+++ b/lib/models/settings.g.dart
@ -0,0 +1,30 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'settings.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
+      defaultService: json['defaultService'] as String? ?? 'tidal',
+      audioQuality: json['audioQuality'] as String? ?? 'LOSSLESS',
+      filenameFormat: json['filenameFormat'] as String? ?? '{title} - {artist}',
+      downloadDirectory: json['downloadDirectory'] as String? ?? '',
+      autoFallback: json['autoFallback'] as bool? ?? true,
+      embedLyrics: json['embedLyrics'] as bool? ?? true,
+      maxQualityCover: json['maxQualityCover'] as bool? ?? true,
+      isFirstLaunch: json['isFirstLaunch'] as bool? ?? true,
+    );
+
+Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
+    <String, dynamic>{
+      'defaultService': instance.defaultService,
+      'audioQuality': instance.audioQuality,
+      'filenameFormat': instance.filenameFormat,
+      'downloadDirectory': instance.downloadDirectory,
+      'autoFallback': instance.autoFallback,
+      'embedLyrics': instance.embedLyrics,
+      'maxQualityCover': instance.maxQualityCover,
+      'isFirstLaunch': instance.isFirstLaunch,
+    };
--- a/Show more
+++ b/Show more