Initial commit: SpotiFLAC Android/iOS app

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,
+        );
+      },
+    );
+  }
+}

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(),
+    ),
+  );
+}

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);
+}

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;
+}

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);
+}

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,
+    };

lib/models/theme_settings.dart

@@ -0,0 +1,76 @@
+import 'package:flutter/material.dart';
+
+/// Storage keys for theme settings persistence
+const String kThemeModeKey = 'theme_mode';
+const String kUseDynamicColorKey = 'use_dynamic_color';
+const String kSeedColorKey = 'seed_color';
+
+/// Default Spotify green color for fallback
+const int kDefaultSeedColor = 0xFF1DB954;
+
+/// Theme settings model for Material Expressive 3
+class ThemeSettings {
+  final ThemeMode themeMode;
+  final bool useDynamicColor;
+  final int seedColorValue;
+
+  const ThemeSettings({
+    this.themeMode = ThemeMode.system,
+    this.useDynamicColor = true,
+    this.seedColorValue = kDefaultSeedColor,
+  });
+
+  /// Get seed color as Color object
+  Color get seedColor => Color(seedColorValue);
+
+  /// Create a copy with updated values
+  ThemeSettings copyWith({
+    ThemeMode? themeMode,
+    bool? useDynamicColor,
+    int? seedColorValue,
+  }) {
+    return ThemeSettings(
+      themeMode: themeMode ?? this.themeMode,
+      useDynamicColor: useDynamicColor ?? this.useDynamicColor,
+      seedColorValue: seedColorValue ?? this.seedColorValue,
+    );
+  }
+
+  /// Convert to JSON map for persistence
+  Map<String, dynamic> toJson() => {
+        kThemeModeKey: themeMode.name,
+        kUseDynamicColorKey: useDynamicColor,
+        kSeedColorKey: seedColorValue,
+      };
+
+  /// Create from JSON map
+  factory ThemeSettings.fromJson(Map<String, dynamic> json) {
+    return ThemeSettings(
+      themeMode: _themeModeFromString(json[kThemeModeKey] as String?),
+      useDynamicColor: json[kUseDynamicColorKey] as bool? ?? true,
+      seedColorValue: json[kSeedColorKey] as int? ?? kDefaultSeedColor,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is ThemeSettings &&
+        other.themeMode == themeMode &&
+        other.useDynamicColor == useDynamicColor &&
+        other.seedColorValue == seedColorValue;
+  }
+
+  @override
+  int get hashCode =>
+      themeMode.hashCode ^ useDynamicColor.hashCode ^ seedColorValue.hashCode;
+}
+
+/// Helper to convert string to ThemeMode
+ThemeMode _themeModeFromString(String? value) {
+  if (value == null) return ThemeMode.system;
+  return ThemeMode.values.firstWhere(
+    (e) => e.name == value,
+    orElse: () => ThemeMode.system,
+  );
+}

lib/models/track.dart

@@ -0,0 +1,61 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'track.g.dart';
+
+/// Track model representing a music track
+@JsonSerializable()
+class Track {
+  final String id;
+  final String name;
+  final String artistName;
+  final String albumName;
+  final String? albumArtist;
+  final String? coverUrl;
+  final String? isrc;
+  final int duration;
+  final int? trackNumber;
+  final int? discNumber;
+  final String? releaseDate;
+  final ServiceAvailability? availability;
+
+  const Track({
+    required this.id,
+    required this.name,
+    required this.artistName,
+    required this.albumName,
+    this.albumArtist,
+    this.coverUrl,
+    this.isrc,
+    required this.duration,
+    this.trackNumber,
+    this.discNumber,
+    this.releaseDate,
+    this.availability,
+  });
+
+  factory Track.fromJson(Map<String, dynamic> json) => _$TrackFromJson(json);
+  Map<String, dynamic> toJson() => _$TrackToJson(this);
+}
+
+@JsonSerializable()
+class ServiceAvailability {
+  final bool tidal;
+  final bool qobuz;
+  final bool amazon;
+  final String? tidalUrl;
+  final String? qobuzUrl;
+  final String? amazonUrl;
+
+  const ServiceAvailability({
+    this.tidal = false,
+    this.qobuz = false,
+    this.amazon = false,
+    this.tidalUrl,
+    this.qobuzUrl,
+    this.amazonUrl,
+  });
+
+  factory ServiceAvailability.fromJson(Map<String, dynamic> json) =>
+      _$ServiceAvailabilityFromJson(json);
+  Map<String, dynamic> toJson() => _$ServiceAvailabilityToJson(this);
+}

lib/models/track.g.dart

@@ -0,0 +1,61 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'track.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+Track _$TrackFromJson(Map<String, dynamic> json) => Track(
+      id: json['id'] as String,
+      name: json['name'] as String,
+      artistName: json['artistName'] as String,
+      albumName: json['albumName'] as String,
+      albumArtist: json['albumArtist'] as String?,
+      coverUrl: json['coverUrl'] as String?,
+      isrc: json['isrc'] as String?,
+      duration: (json['duration'] as num).toInt(),
+      trackNumber: (json['trackNumber'] as num?)?.toInt(),
+      discNumber: (json['discNumber'] as num?)?.toInt(),
+      releaseDate: json['releaseDate'] as String?,
+      availability: json['availability'] == null
+          ? null
+          : ServiceAvailability.fromJson(
+              json['availability'] as Map<String, dynamic>),
+    );
+
+Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
+      'id': instance.id,
+      'name': instance.name,
+      'artistName': instance.artistName,
+      'albumName': instance.albumName,
+      'albumArtist': instance.albumArtist,
+      'coverUrl': instance.coverUrl,
+      'isrc': instance.isrc,
+      'duration': instance.duration,
+      'trackNumber': instance.trackNumber,
+      'discNumber': instance.discNumber,
+      'releaseDate': instance.releaseDate,
+      'availability': instance.availability?.toJson(),
+    };
+
+ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>
+    ServiceAvailability(
+      tidal: json['tidal'] as bool? ?? false,
+      qobuz: json['qobuz'] as bool? ?? false,
+      amazon: json['amazon'] as bool? ?? false,
+      tidalUrl: json['tidalUrl'] as String?,
+      qobuzUrl: json['qobuzUrl'] as String?,
+      amazonUrl: json['amazonUrl'] as String?,
+    );
+
+Map<String, dynamic> _$ServiceAvailabilityToJson(
+        ServiceAvailability instance) =>
+    <String, dynamic>{
+      'tidal': instance.tidal,
+      'qobuz': instance.qobuz,
+      'amazon': instance.amazon,
+      'tidalUrl': instance.tidalUrl,
+      'qobuzUrl': instance.qobuzUrl,
+      'amazonUrl': instance.amazonUrl,
+    };

lib/providers/download_queue_provider.dart

@@ -0,0 +1,520 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:ffmpeg_kit_flutter_new/ffmpeg_kit.dart';
+import 'package:ffmpeg_kit_flutter_new/return_code.dart';
+import 'package:spotiflac_android/models/download_item.dart';
+import 'package:spotiflac_android/models/settings.dart';
+import 'package:spotiflac_android/models/track.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/services/ffmpeg_service.dart';
+
+// Download History Item model
+class DownloadHistoryItem {
+  final String id;
+  final String trackName;
+  final String artistName;
+  final String albumName;
+  final String? coverUrl;
+  final String filePath;
+  final String service;
+  final DateTime downloadedAt;
+
+  const DownloadHistoryItem({
+    required this.id,
+    required this.trackName,
+    required this.artistName,
+    required this.albumName,
+    this.coverUrl,
+    required this.filePath,
+    required this.service,
+    required this.downloadedAt,
+  });
+}
+
+// Download History State
+class DownloadHistoryState {
+  final List<DownloadHistoryItem> items;
+
+  const DownloadHistoryState({this.items = const []});
+
+  DownloadHistoryState copyWith({List<DownloadHistoryItem>? items}) {
+    return DownloadHistoryState(items: items ?? this.items);
+  }
+}
+
+// Download History Notifier (Riverpod 3.x)
+class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
+  @override
+  DownloadHistoryState build() {
+    return const DownloadHistoryState();
+  }
+
+  void addToHistory(DownloadHistoryItem item) {
+    state = state.copyWith(items: [item, ...state.items]);
+  }
+
+  void removeFromHistory(String id) {
+    state = state.copyWith(
+      items: state.items.where((item) => item.id != id).toList(),
+    );
+  }
+
+  void clearHistory() {
+    state = const DownloadHistoryState();
+  }
+}
+
+// Download History Provider
+final downloadHistoryProvider = NotifierProvider<DownloadHistoryNotifier, DownloadHistoryState>(
+  DownloadHistoryNotifier.new,
+);
+
+class DownloadQueueState {
+  final List<DownloadItem> items;
+  final DownloadItem? currentDownload;
+  final bool isProcessing;
+  final String outputDir;
+  final String filenameFormat;
+  final bool autoFallback;
+
+  const DownloadQueueState({
+    this.items = const [],
+    this.currentDownload,
+    this.isProcessing = false,
+    this.outputDir = '',
+    this.filenameFormat = '{artist} - {title}',
+    this.autoFallback = true,
+  });
+
+  DownloadQueueState copyWith({
+    List<DownloadItem>? items,
+    DownloadItem? currentDownload,
+    bool? isProcessing,
+    String? outputDir,
+    String? filenameFormat,
+    bool? autoFallback,
+  }) {
+    return DownloadQueueState(
+      items: items ?? this.items,
+      currentDownload: currentDownload ?? this.currentDownload,
+      isProcessing: isProcessing ?? this.isProcessing,
+      outputDir: outputDir ?? this.outputDir,
+      filenameFormat: filenameFormat ?? this.filenameFormat,
+      autoFallback: autoFallback ?? this.autoFallback,
+    );
+  }
+
+  int get queuedCount => items.where((i) => i.status == DownloadStatus.queued || i.status == DownloadStatus.downloading).length;
+  int get completedCount => items.where((i) => i.status == DownloadStatus.completed).length;
+  int get failedCount => items.where((i) => i.status == DownloadStatus.failed).length;
+}
+
+// Download Queue Notifier (Riverpod 3.x)
+class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
+  Timer? _progressTimer;
+
+  @override
+  DownloadQueueState build() {
+    // Initialize output directory asynchronously
+    Future.microtask(() async {
+      await _initOutputDir();
+    });
+    return const DownloadQueueState();
+  }
+
+  void _startProgressPolling(String itemId) {
+    _progressTimer?.cancel();
+    _progressTimer = Timer.periodic(const Duration(milliseconds: 500), (timer) async {
+      try {
+        final progress = await PlatformBridge.getDownloadProgress();
+        final bytesReceived = progress['bytes_received'] as int? ?? 0;
+        final bytesTotal = progress['bytes_total'] as int? ?? 0;
+        final isDownloading = progress['is_downloading'] as bool? ?? false;
+        
+        if (isDownloading && bytesTotal > 0) {
+          final percentage = bytesReceived / bytesTotal;
+          updateProgress(itemId, percentage);
+          
+          // Log progress
+          final mbReceived = bytesReceived / (1024 * 1024);
+          final mbTotal = bytesTotal / (1024 * 1024);
+          print('[DownloadQueue] Progress: ${(percentage * 100).toStringAsFixed(1)}% (${mbReceived.toStringAsFixed(2)}/${mbTotal.toStringAsFixed(2)} MB)');
+        }
+      } catch (e) {
+        // Ignore polling errors
+      }
+    });
+  }
+
+  void _stopProgressPolling() {
+    _progressTimer?.cancel();
+    _progressTimer = null;
+  }
+
+  Future<void> _initOutputDir() async {
+    if (state.outputDir.isEmpty) {
+      try {
+        if (Platform.isIOS) {
+          // iOS: Use Documents directory (accessible via Files app)
+          final dir = await getApplicationDocumentsDirectory();
+          final musicDir = Directory('${dir.path}/SpotiFLAC');
+          if (!await musicDir.exists()) {
+            await musicDir.create(recursive: true);
+          }
+          state = state.copyWith(outputDir: musicDir.path);
+        } else {
+          // Android: Use external storage Music folder
+          final dir = await getExternalStorageDirectory();
+          if (dir != null) {
+            final musicDir = Directory('${dir.parent.parent.parent.parent.path}/Music/SpotiFLAC');
+            if (!await musicDir.exists()) {
+              await musicDir.create(recursive: true);
+            }
+            state = state.copyWith(outputDir: musicDir.path);
+          } else {
+            // Fallback to documents directory
+            final docDir = await getApplicationDocumentsDirectory();
+            final musicDir = Directory('${docDir.path}/SpotiFLAC');
+            if (!await musicDir.exists()) {
+              await musicDir.create(recursive: true);
+            }
+            state = state.copyWith(outputDir: musicDir.path);
+          }
+        }
+      } catch (e) {
+        // Fallback for any platform
+        final dir = await getApplicationDocumentsDirectory();
+        final musicDir = Directory('${dir.path}/SpotiFLAC');
+        if (!await musicDir.exists()) {
+          await musicDir.create(recursive: true);
+        }
+        state = state.copyWith(outputDir: musicDir.path);
+      }
+    }
+  }
+
+  void setOutputDir(String dir) {
+    state = state.copyWith(outputDir: dir);
+  }
+
+  void updateSettings(AppSettings settings) {
+    state = state.copyWith(
+      outputDir: settings.downloadDirectory.isNotEmpty ? settings.downloadDirectory : state.outputDir,
+      filenameFormat: settings.filenameFormat,
+      autoFallback: settings.autoFallback,
+    );
+  }
+
+  String addToQueue(Track track, String service) {
+    final id = '${track.isrc ?? track.id}-${DateTime.now().millisecondsSinceEpoch}';
+    final item = DownloadItem(
+      id: id,
+      track: track,
+      service: service,
+      createdAt: DateTime.now(),
+    );
+
+    state = state.copyWith(items: [...state.items, item]);
+
+    if (!state.isProcessing) {
+      // Run in microtask to not block UI
+      Future.microtask(() => _processQueue());
+    }
+
+    return id;
+  }
+
+  void addMultipleToQueue(List<Track> tracks, String service) {
+    final newItems = tracks.map((track) {
+      final id = '${track.isrc ?? track.id}-${DateTime.now().millisecondsSinceEpoch}';
+      return DownloadItem(
+        id: id,
+        track: track,
+        service: service,
+        createdAt: DateTime.now(),
+      );
+    }).toList();
+
+    state = state.copyWith(items: [...state.items, ...newItems]);
+
+    if (!state.isProcessing) {
+      // Run in microtask to not block UI
+      Future.microtask(() => _processQueue());
+    }
+  }
+
+  void updateItemStatus(String id, DownloadStatus status, {double? progress, String? filePath, String? error}) {
+    final items = state.items.map((item) {
+      if (item.id == id) {
+        return item.copyWith(
+          status: status,
+          progress: progress ?? item.progress,
+          filePath: filePath,
+          error: error,
+        );
+      }
+      return item;
+    }).toList();
+
+    state = state.copyWith(items: items);
+  }
+
+  void updateProgress(String id, double progress) {
+    updateItemStatus(id, DownloadStatus.downloading, progress: progress);
+  }
+
+  void cancelItem(String id) {
+    updateItemStatus(id, DownloadStatus.skipped);
+  }
+
+  void clearCompleted() {
+    final items = state.items.where((item) =>
+      item.status != DownloadStatus.completed &&
+      item.status != DownloadStatus.failed &&
+      item.status != DownloadStatus.skipped
+    ).toList();
+
+    state = state.copyWith(items: items);
+  }
+
+  void clearAll() {
+    state = const DownloadQueueState();
+  }
+
+  /// Embed metadata and cover to a FLAC file after M4A conversion
+  Future<void> _embedMetadataAndCover(String flacPath, Track track) async {
+    // Download cover first
+    String? coverPath;
+    if (track.coverUrl != null && track.coverUrl!.isNotEmpty) {
+      coverPath = '$flacPath.cover.jpg';
+      try {
+        // Download cover using HTTP
+        final httpClient = HttpClient();
+        final request = await httpClient.getUrl(Uri.parse(track.coverUrl!));
+        final response = await request.close();
+        if (response.statusCode == 200) {
+          final file = File(coverPath);
+          final sink = file.openWrite();
+          await response.pipe(sink);
+          await sink.close();
+          print('[DownloadQueue] Cover downloaded to: $coverPath');
+        } else {
+          print('[DownloadQueue] Failed to download cover: HTTP ${response.statusCode}');
+          coverPath = null;
+        }
+        httpClient.close();
+      } catch (e) {
+        print('[DownloadQueue] Failed to download cover: $e');
+        coverPath = null;
+      }
+    }
+
+    // Use Go backend to embed metadata
+    try {
+      // For now, we'll use FFmpeg to embed cover since Go backend expects to download the file
+      // FFmpeg can embed cover art to FLAC
+      if (coverPath != null && await File(coverPath).exists()) {
+        final tempOutput = '$flacPath.tmp';
+        final command = '-i "$flacPath" -i "$coverPath" -map 0:a -map 1:0 -c copy -metadata:s:v title="Album cover" -metadata:s:v comment="Cover (front)" -disposition:v attached_pic "$tempOutput" -y';
+        
+        final session = await FFmpegKit.execute(command);
+        final returnCode = await session.getReturnCode();
+        
+        if (ReturnCode.isSuccess(returnCode)) {
+          // Replace original with temp
+          await File(flacPath).delete();
+          await File(tempOutput).rename(flacPath);
+          print('[DownloadQueue] Cover embedded via FFmpeg');
+        } else {
+          // Try alternative method using metaflac-style embedding
+          print('[DownloadQueue] FFmpeg cover embed failed, trying alternative...');
+          // Clean up temp file if exists
+          final tempFile = File(tempOutput);
+          if (await tempFile.exists()) {
+            await tempFile.delete();
+          }
+        }
+        
+        // Clean up cover file
+        try {
+          await File(coverPath).delete();
+        } catch (_) {}
+      }
+    } catch (e) {
+      print('[DownloadQueue] Failed to embed metadata: $e');
+    }
+  }
+
+  Future<void> _processQueue() async {
+    if (state.isProcessing) return; // Prevent multiple concurrent processing
+    
+    state = state.copyWith(isProcessing: true);
+    print('[DownloadQueue] Starting queue processing...');
+
+    // Ensure output directory is initialized before processing
+    if (state.outputDir.isEmpty) {
+      print('[DownloadQueue] Output dir empty, initializing...');
+      await _initOutputDir();
+    }
+    
+    // If still empty, use fallback
+    if (state.outputDir.isEmpty) {
+      print('[DownloadQueue] Using fallback directory...');
+      final dir = await getApplicationDocumentsDirectory();
+      final musicDir = Directory('${dir.path}/SpotiFLAC');
+      if (!await musicDir.exists()) {
+        await musicDir.create(recursive: true);
+      }
+      state = state.copyWith(outputDir: musicDir.path);
+    }
+    
+    print('[DownloadQueue] Output directory: ${state.outputDir}');
+
+    while (true) {
+      final nextItem = state.items.firstWhere(
+        (item) => item.status == DownloadStatus.queued,
+        orElse: () => DownloadItem(
+          id: '',
+          track: const Track(id: '', name: '', artistName: '', albumName: '', duration: 0),
+          service: '',
+          createdAt: DateTime.now(),
+        ),
+      );
+
+      if (nextItem.id.isEmpty) {
+        print('[DownloadQueue] No more items to process');
+        break;
+      }
+
+      print('[DownloadQueue] Processing: ${nextItem.track.name} by ${nextItem.track.artistName}');
+      print('[DownloadQueue] Cover URL: ${nextItem.track.coverUrl}');
+      
+      state = state.copyWith(currentDownload: nextItem);
+      updateItemStatus(nextItem.id, DownloadStatus.downloading);
+      
+      // Start progress polling
+      _startProgressPolling(nextItem.id);
+
+      try {
+        Map<String, dynamic> result;
+
+        if (state.autoFallback) {
+          print('[DownloadQueue] Using auto-fallback mode');
+          result = await PlatformBridge.downloadWithFallback(
+            isrc: nextItem.track.isrc ?? '',
+            spotifyId: nextItem.track.id,
+            trackName: nextItem.track.name,
+            artistName: nextItem.track.artistName,
+            albumName: nextItem.track.albumName,
+            albumArtist: nextItem.track.albumArtist,
+            coverUrl: nextItem.track.coverUrl,
+            outputDir: state.outputDir,
+            filenameFormat: state.filenameFormat,
+            trackNumber: nextItem.track.trackNumber ?? 1,
+            discNumber: nextItem.track.discNumber ?? 1,
+            releaseDate: nextItem.track.releaseDate,
+            preferredService: nextItem.service,
+          );
+        } else {
+          result = await PlatformBridge.downloadTrack(
+            isrc: nextItem.track.isrc ?? '',
+            service: nextItem.service,
+            spotifyId: nextItem.track.id,
+            trackName: nextItem.track.name,
+            artistName: nextItem.track.artistName,
+            albumName: nextItem.track.albumName,
+            albumArtist: nextItem.track.albumArtist,
+            coverUrl: nextItem.track.coverUrl,
+            outputDir: state.outputDir,
+            filenameFormat: state.filenameFormat,
+            trackNumber: nextItem.track.trackNumber ?? 1,
+            discNumber: nextItem.track.discNumber ?? 1,
+            releaseDate: nextItem.track.releaseDate,
+          );
+        }
+
+        // Stop progress polling for this item
+        _stopProgressPolling();
+        
+        print('[DownloadQueue] Result: $result');
+        
+        if (result['success'] == true) {
+          var filePath = result['file_path'] as String?;
+          print('[DownloadQueue] Download success, file: $filePath');
+          
+          // Check if file is M4A (DASH stream from Tidal) and needs remuxing to FLAC
+          if (filePath != null && filePath.endsWith('.m4a')) {
+            print('[DownloadQueue] Converting M4A to FLAC...');
+            updateItemStatus(nextItem.id, DownloadStatus.downloading, progress: 0.9);
+            final flacPath = await FFmpegService.convertM4aToFlac(filePath);
+            if (flacPath != null) {
+              filePath = flacPath;
+              print('[DownloadQueue] Converted to: $flacPath');
+              
+              // After conversion, embed metadata and cover to the new FLAC file
+              print('[DownloadQueue] Embedding metadata and cover to converted FLAC...');
+              try {
+                await _embedMetadataAndCover(
+                  flacPath,
+                  nextItem.track,
+                );
+                print('[DownloadQueue] Metadata and cover embedded successfully');
+              } catch (e) {
+                print('[DownloadQueue] Warning: Failed to embed metadata/cover: $e');
+              }
+            }
+          }
+          
+          updateItemStatus(
+            nextItem.id,
+            DownloadStatus.completed,
+            progress: 1.0,
+            filePath: filePath,
+          );
+
+          if (filePath != null) {
+            ref.read(downloadHistoryProvider.notifier).addToHistory(
+              DownloadHistoryItem(
+                id: nextItem.id,
+                trackName: nextItem.track.name,
+                artistName: nextItem.track.artistName,
+                albumName: nextItem.track.albumName,
+                coverUrl: nextItem.track.coverUrl,
+                filePath: filePath,
+                service: result['service'] as String? ?? nextItem.service,
+                downloadedAt: DateTime.now(),
+              ),
+            );
+          }
+        } else {
+          final errorMsg = result['error'] as String? ?? 'Download failed';
+          print('[DownloadQueue] Download failed: $errorMsg');
+          updateItemStatus(
+            nextItem.id,
+            DownloadStatus.failed,
+            error: errorMsg,
+          );
+        }
+      } catch (e, stackTrace) {
+        _stopProgressPolling();
+        print('[DownloadQueue] Exception: $e');
+        print('[DownloadQueue] StackTrace: $stackTrace');
+        updateItemStatus(
+          nextItem.id,
+          DownloadStatus.failed,
+          error: e.toString(),
+        );
+      }
+    }
+
+    _stopProgressPolling();
+    print('[DownloadQueue] Queue processing finished');
+    state = state.copyWith(isProcessing: false, currentDownload: null);
+  }
+}
+
+final downloadQueueProvider = NotifierProvider<DownloadQueueNotifier, DownloadQueueState>(
+  DownloadQueueNotifier.new,
+);

lib/providers/settings_provider.dart

@@ -0,0 +1,71 @@
+import 'dart:convert';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:spotiflac_android/models/settings.dart';
+
+const _settingsKey = 'app_settings';
+
+class SettingsNotifier extends Notifier<AppSettings> {
+  @override
+  AppSettings build() {
+    _loadSettings();
+    return const AppSettings();
+  }
+
+  Future<void> _loadSettings() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_settingsKey);
+    if (json != null) {
+      state = AppSettings.fromJson(jsonDecode(json));
+    }
+  }
+
+  Future<void> _saveSettings() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setString(_settingsKey, jsonEncode(state.toJson()));
+  }
+
+  void setDefaultService(String service) {
+    state = state.copyWith(defaultService: service);
+    _saveSettings();
+  }
+
+  void setAudioQuality(String quality) {
+    state = state.copyWith(audioQuality: quality);
+    _saveSettings();
+  }
+
+  void setFilenameFormat(String format) {
+    state = state.copyWith(filenameFormat: format);
+    _saveSettings();
+  }
+
+  void setDownloadDirectory(String directory) {
+    state = state.copyWith(downloadDirectory: directory);
+    _saveSettings();
+  }
+
+  void setAutoFallback(bool enabled) {
+    state = state.copyWith(autoFallback: enabled);
+    _saveSettings();
+  }
+
+  void setEmbedLyrics(bool enabled) {
+    state = state.copyWith(embedLyrics: enabled);
+    _saveSettings();
+  }
+
+  void setMaxQualityCover(bool enabled) {
+    state = state.copyWith(maxQualityCover: enabled);
+    _saveSettings();
+  }
+
+  void setFirstLaunchComplete() {
+    state = state.copyWith(isFirstLaunch: false);
+    _saveSettings();
+  }
+}
+
+final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(
+  SettingsNotifier.new,
+);

lib/providers/theme_provider.dart

@@ -0,0 +1,83 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:spotiflac_android/models/theme_settings.dart';
+
+/// Provider for theme settings state management
+final themeProvider = NotifierProvider<ThemeNotifier, ThemeSettings>(() {
+  return ThemeNotifier();
+});
+
+/// Notifier for managing theme settings with persistence
+class ThemeNotifier extends Notifier<ThemeSettings> {
+  @override
+  ThemeSettings build() {
+    // Load settings asynchronously on first access
+    _loadFromStorage();
+    return const ThemeSettings();
+  }
+
+  /// Load theme settings from SharedPreferences
+  Future<void> _loadFromStorage() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final modeString = prefs.getString(kThemeModeKey);
+      final useDynamic = prefs.getBool(kUseDynamicColorKey);
+      final seedColor = prefs.getInt(kSeedColorKey);
+
+      state = ThemeSettings(
+        themeMode: _themeModeFromString(modeString),
+        useDynamicColor: useDynamic ?? true,
+        seedColorValue: seedColor ?? kDefaultSeedColor,
+      );
+    } catch (e) {
+      debugPrint('Error loading theme settings: $e');
+      // Keep default state on error
+    }
+  }
+
+  /// Save current settings to SharedPreferences
+  Future<void> _saveToStorage() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setString(kThemeModeKey, state.themeMode.name);
+      await prefs.setBool(kUseDynamicColorKey, state.useDynamicColor);
+      await prefs.setInt(kSeedColorKey, state.seedColorValue);
+    } catch (e) {
+      debugPrint('Error saving theme settings: $e');
+    }
+  }
+
+  /// Set theme mode (light, dark, or system)
+  Future<void> setThemeMode(ThemeMode mode) async {
+    state = state.copyWith(themeMode: mode);
+    await _saveToStorage();
+  }
+
+  /// Enable or disable dynamic color from wallpaper
+  Future<void> setUseDynamicColor(bool value) async {
+    state = state.copyWith(useDynamicColor: value);
+    await _saveToStorage();
+  }
+
+  /// Set custom seed color (used when dynamic color is disabled)
+  Future<void> setSeedColor(Color color) async {
+    state = state.copyWith(seedColorValue: color.toARGB32());
+    await _saveToStorage();
+  }
+
+  /// Set seed color from int value
+  Future<void> setSeedColorValue(int colorValue) async {
+    state = state.copyWith(seedColorValue: colorValue);
+    await _saveToStorage();
+  }
+
+  /// Helper to convert string to ThemeMode
+  ThemeMode _themeModeFromString(String? value) {
+    if (value == null) return ThemeMode.system;
+    return ThemeMode.values.firstWhere(
+      (e) => e.name == value,
+      orElse: () => ThemeMode.system,
+    );
+  }
+}

lib/providers/track_provider.dart

@@ -0,0 +1,190 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/models/track.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
+
+class TrackState {
+  final List<Track> tracks;
+  final bool isLoading;
+  final String? error;
+  final String? albumName;
+  final String? playlistName;
+  final String? coverUrl;
+
+  const TrackState({
+    this.tracks = const [],
+    this.isLoading = false,
+    this.error,
+    this.albumName,
+    this.playlistName,
+    this.coverUrl,
+  });
+
+  TrackState copyWith({
+    List<Track>? tracks,
+    bool? isLoading,
+    String? error,
+    String? albumName,
+    String? playlistName,
+    String? coverUrl,
+  }) {
+    return TrackState(
+      tracks: tracks ?? this.tracks,
+      isLoading: isLoading ?? this.isLoading,
+      error: error,
+      albumName: albumName ?? this.albumName,
+      playlistName: playlistName ?? this.playlistName,
+      coverUrl: coverUrl ?? this.coverUrl,
+    );
+  }
+}
+
+class TrackNotifier extends Notifier<TrackState> {
+  @override
+  TrackState build() {
+    return const TrackState();
+  }
+
+  Future<void> fetchFromUrl(String url) async {
+    state = state.copyWith(isLoading: true, error: null);
+
+    try {
+      final parsed = await PlatformBridge.parseSpotifyUrl(url);
+      final type = parsed['type'] as String;
+
+      final metadata = await PlatformBridge.getSpotifyMetadata(url);
+
+      if (type == 'track') {
+        final trackData = metadata['track'] as Map<String, dynamic>;
+        final track = _parseTrack(trackData);
+        state = state.copyWith(
+          tracks: [track],
+          isLoading: false,
+          albumName: null,
+          playlistName: null,
+          coverUrl: track.coverUrl,
+        );
+      } else if (type == 'album') {
+        final albumInfo = metadata['album_info'] as Map<String, dynamic>;
+        final trackList = metadata['track_list'] as List<dynamic>;
+        final tracks = trackList.map((t) => _parseTrack(t as Map<String, dynamic>)).toList();
+        state = state.copyWith(
+          tracks: tracks,
+          isLoading: false,
+          albumName: albumInfo['name'] as String?,
+          playlistName: null,
+          coverUrl: albumInfo['images'] as String?,
+        );
+      } else if (type == 'playlist') {
+        final playlistInfo = metadata['playlist_info'] as Map<String, dynamic>;
+        final trackList = metadata['track_list'] as List<dynamic>;
+        final tracks = trackList.map((t) => _parseTrack(t as Map<String, dynamic>)).toList();
+        final owner = playlistInfo['owner'] as Map<String, dynamic>?;
+        state = state.copyWith(
+          tracks: tracks,
+          isLoading: false,
+          albumName: null,
+          playlistName: owner?['name'] as String?,
+          coverUrl: owner?['images'] as String?,
+        );
+      }
+    } catch (e) {
+      state = state.copyWith(isLoading: false, error: e.toString());
+    }
+  }
+
+  Future<void> search(String query) async {
+    state = state.copyWith(isLoading: true, error: null);
+
+    try {
+      final results = await PlatformBridge.searchSpotify(query, limit: 20);
+      final trackList = results['tracks'] as List<dynamic>? ?? [];
+      final tracks = trackList.map((t) => _parseSearchTrack(t as Map<String, dynamic>)).toList();
+      state = state.copyWith(
+        tracks: tracks,
+        isLoading: false,
+        albumName: null,
+        playlistName: null,
+      );
+    } catch (e) {
+      state = state.copyWith(isLoading: false, error: e.toString());
+    }
+  }
+
+  Future<void> checkAvailability(int index) async {
+    if (index < 0 || index >= state.tracks.length) return;
+
+    final track = state.tracks[index];
+    if (track.isrc == null || track.isrc!.isEmpty) return;
+
+    try {
+      final availability = await PlatformBridge.checkAvailability(track.id, track.isrc!);
+      final updatedTrack = Track(
+        id: track.id,
+        name: track.name,
+        artistName: track.artistName,
+        albumName: track.albumName,
+        albumArtist: track.albumArtist,
+        coverUrl: track.coverUrl,
+        isrc: track.isrc,
+        duration: track.duration,
+        trackNumber: track.trackNumber,
+        discNumber: track.discNumber,
+        releaseDate: track.releaseDate,
+        availability: ServiceAvailability(
+          tidal: availability['tidal'] as bool? ?? false,
+          qobuz: availability['qobuz'] as bool? ?? false,
+          amazon: availability['amazon'] as bool? ?? false,
+          tidalUrl: availability['tidal_url'] as String?,
+          qobuzUrl: availability['qobuz_url'] as String?,
+          amazonUrl: availability['amazon_url'] as String?,
+        ),
+      );
+
+      final tracks = List<Track>.from(state.tracks);
+      tracks[index] = updatedTrack;
+      state = state.copyWith(tracks: tracks);
+    } catch (e) {
+      // Silently fail availability check
+    }
+  }
+
+  void clear() {
+    state = const TrackState();
+  }
+
+  Track _parseTrack(Map<String, dynamic> data) {
+    return Track(
+      id: data['spotify_id'] as String? ?? '',
+      name: data['name'] as String? ?? '',
+      artistName: data['artists'] as String? ?? '',
+      albumName: data['album_name'] as String? ?? '',
+      albumArtist: data['album_artist'] as String?,
+      coverUrl: data['images'] as String?,
+      isrc: data['isrc'] as String?,
+      duration: data['duration_ms'] as int? ?? 0,
+      trackNumber: data['track_number'] as int?,
+      discNumber: data['disc_number'] as int?,
+      releaseDate: data['release_date'] as String?,
+    );
+  }
+
+  Track _parseSearchTrack(Map<String, dynamic> data) {
+    return Track(
+      id: data['spotify_id'] as String? ?? '',
+      name: data['name'] as String? ?? '',
+      artistName: data['artists'] as String? ?? '',
+      albumName: data['album_name'] as String? ?? '',
+      albumArtist: data['album_artist'] as String?,
+      coverUrl: data['images'] as String?,
+      isrc: data['isrc'] as String?,
+      duration: data['duration_ms'] as int? ?? 0,
+      trackNumber: data['track_number'] as int?,
+      discNumber: data['disc_number'] as int?,
+      releaseDate: data['release_date'] as String?,
+    );
+  }
+}
+
+final trackProvider = NotifierProvider<TrackNotifier, TrackState>(
+  TrackNotifier.new,
+);

lib/screens/history_screen.dart

@@ -0,0 +1,372 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+
+class HistoryScreen extends ConsumerWidget {
+  const HistoryScreen({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final historyState = ref.watch(downloadHistoryProvider);
+    final history = historyState.items;
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Download History'),
+        actions: [
+          if (history.isNotEmpty)
+            IconButton(
+              icon: const Icon(Icons.delete_sweep),
+              onPressed: () => _showClearHistoryDialog(context, ref),
+              tooltip: 'Clear history',
+            ),
+        ],
+      ),
+      body: history.isEmpty
+          ? _buildEmptyState(context, colorScheme)
+          : ListView.builder(
+              itemCount: history.length,
+              itemBuilder: (context, index) {
+                final item = history[index];
+                return _buildHistoryItem(context, ref, item, colorScheme);
+              },
+            ),
+    );
+  }
+
+  Widget _buildEmptyState(BuildContext context, ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.history, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'No download history',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Text(
+            'Downloaded tracks will appear here',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+              color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildHistoryItem(BuildContext context, WidgetRef ref, DownloadHistoryItem item, ColorScheme colorScheme) {
+    final fileExists = File(item.filePath).existsSync();
+    
+    return Dismissible(
+      key: Key(item.id),
+      direction: DismissDirection.endToStart,
+      background: Container(
+        alignment: Alignment.centerRight,
+        padding: const EdgeInsets.only(right: 16),
+        color: colorScheme.error,
+        child: Icon(Icons.delete, color: colorScheme.onError),
+      ),
+      onDismissed: (_) {
+        ref.read(downloadHistoryProvider.notifier).removeFromHistory(item.id);
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Removed "${item.trackName}" from history')),
+        );
+      },
+      child: ListTile(
+        leading: item.coverUrl != null
+            ? ClipRRect(
+                borderRadius: BorderRadius.circular(8),
+                child: CachedNetworkImage(
+                  imageUrl: item.coverUrl!,
+                  width: 48,
+                  height: 48,
+                  fit: BoxFit.cover,
+                  placeholder: (_, __) => Container(
+                    width: 48,
+                    height: 48,
+                    decoration: BoxDecoration(
+                      color: colorScheme.surfaceContainerHighest,
+                      borderRadius: BorderRadius.circular(8),
+                    ),
+                  ),
+                ),
+              )
+            : Container(
+                width: 48,
+                height: 48,
+                decoration: BoxDecoration(
+                  color: colorScheme.surfaceContainerHighest,
+                  borderRadius: BorderRadius.circular(8),
+                ),
+                child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+              ),
+        title: Text(
+          item.trackName,
+          maxLines: 1,
+          overflow: TextOverflow.ellipsis,
+        ),
+        subtitle: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              item.artistName,
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              style: TextStyle(color: colorScheme.onSurfaceVariant),
+            ),
+            Row(
+              children: [
+                Icon(
+                  _getServiceIcon(item.service),
+                  size: 12,
+                  color: colorScheme.onSurfaceVariant,
+                ),
+                const SizedBox(width: 4),
+                Text(
+                  _formatDate(item.downloadedAt),
+                  style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                if (!fileExists) ...[
+                  const SizedBox(width: 8),
+                  Icon(
+                    Icons.warning,
+                    size: 12,
+                    color: colorScheme.error,
+                  ),
+                  const SizedBox(width: 2),
+                  Text(
+                    'File missing',
+                    style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                      color: colorScheme.error,
+                    ),
+                  ),
+                ],
+              ],
+            ),
+          ],
+        ),
+        trailing: fileExists
+            ? IconButton(
+                icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+                onPressed: () => _openFile(context, item.filePath),
+              )
+            : Icon(Icons.error_outline, color: colorScheme.onSurfaceVariant),
+        onTap: fileExists ? () => _openFile(context, item.filePath) : null,
+        onLongPress: () => _showItemDetails(context, ref, item, colorScheme),
+      ),
+    );
+  }
+
+  IconData _getServiceIcon(String service) {
+    switch (service.toLowerCase()) {
+      case 'tidal':
+        return Icons.waves;
+      case 'qobuz':
+        return Icons.album;
+      case 'amazon':
+        return Icons.shopping_cart;
+      default:
+        return Icons.cloud_download;
+    }
+  }
+
+  String _formatDate(DateTime date) {
+    final now = DateTime.now();
+    final diff = now.difference(date);
+    
+    if (diff.inDays == 0) {
+      if (diff.inHours == 0) {
+        return '${diff.inMinutes}m ago';
+      }
+      return '${diff.inHours}h ago';
+    } else if (diff.inDays == 1) {
+      return 'Yesterday';
+    } else if (diff.inDays < 7) {
+      return '${diff.inDays}d ago';
+    } else {
+      return '${date.day}/${date.month}/${date.year}';
+    }
+  }
+
+  Future<void> _openFile(BuildContext context, String filePath) async {
+    try {
+      final result = await OpenFilex.open(filePath);
+      
+      if (result.type != ResultType.done) {
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text('Cannot open: ${result.message}'),
+              action: SnackBarAction(
+                label: 'Copy Path',
+                onPressed: () {
+                  Clipboard.setData(ClipboardData(text: filePath));
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    const SnackBar(content: Text('Path copied to clipboard')),
+                  );
+                },
+              ),
+            ),
+          );
+        }
+      }
+    } catch (e) {
+      if (context.mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Cannot open file: $e')),
+        );
+      }
+    }
+  }
+
+  void _showItemDetails(BuildContext context, WidgetRef ref, DownloadHistoryItem item, ColorScheme colorScheme) {
+    showModalBottomSheet(
+      context: context,
+      builder: (context) => Container(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                if (item.coverUrl != null)
+                  ClipRRect(
+                    borderRadius: BorderRadius.circular(12),
+                    child: CachedNetworkImage(
+                      imageUrl: item.coverUrl!,
+                      width: 64,
+                      height: 64,
+                      fit: BoxFit.cover,
+                    ),
+                  ),
+                const SizedBox(width: 16),
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(
+                        item.trackName,
+                        style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                          fontWeight: FontWeight.bold,
+                        ),
+                      ),
+                      Text(
+                        item.artistName,
+                        style: TextStyle(color: colorScheme.onSurfaceVariant),
+                      ),
+                      Text(
+                        item.albumName,
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                          color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 16),
+            const Divider(),
+            _buildDetailRow(context, 'Service', item.service.toUpperCase(), colorScheme),
+            _buildDetailRow(context, 'Downloaded', _formatDate(item.downloadedAt), colorScheme),
+            _buildDetailRow(context, 'File', item.filePath, colorScheme, isPath: true),
+            const SizedBox(height: 16),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+              children: [
+                TextButton.icon(
+                  onPressed: () {
+                    ref.read(downloadHistoryProvider.notifier).removeFromHistory(item.id);
+                    Navigator.pop(context);
+                  },
+                  icon: Icon(Icons.delete, color: colorScheme.error),
+                  label: Text('Remove', style: TextStyle(color: colorScheme.error)),
+                ),
+                if (File(item.filePath).existsSync())
+                  TextButton.icon(
+                    onPressed: () {
+                      Navigator.pop(context);
+                      _openFile(context, item.filePath);
+                    },
+                    icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+                    label: Text('Play', style: TextStyle(color: colorScheme.primary)),
+                  ),
+              ],
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildDetailRow(BuildContext context, String label, String value, ColorScheme colorScheme, {bool isPath = false}) {
+    return Padding(
+      padding: const EdgeInsets.symmetric(vertical: 4),
+      child: Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          SizedBox(
+            width: 80,
+            child: Text(
+              label,
+              style: TextStyle(color: colorScheme.onSurfaceVariant),
+            ),
+          ),
+          Expanded(
+            child: Text(
+              value,
+              style: TextStyle(
+                fontSize: isPath ? 12 : 14,
+                fontFamily: isPath ? 'monospace' : null,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showClearHistoryDialog(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Clear History'),
+        content: const Text(
+          'Are you sure you want to clear all download history? '
+          'This will not delete the downloaded files.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              ref.read(downloadHistoryProvider.notifier).clearHistory();
+              Navigator.pop(context);
+            },
+            child: Text('Clear', style: TextStyle(color: colorScheme.error)),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/history_tab.dart

@@ -0,0 +1,388 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+
+class HistoryTab extends ConsumerWidget {
+  const HistoryTab({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final historyState = ref.watch(downloadHistoryProvider);
+    final history = historyState.items;
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Column(
+      children: [
+        // Header with clear action
+        if (history.isNotEmpty)
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+            child: Row(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
+                Text(
+                  '${history.length} downloads',
+                  style: Theme.of(context).textTheme.titleSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                TextButton.icon(
+                  onPressed: () => _showClearHistoryDialog(context, ref),
+                  icon: Icon(Icons.delete_sweep, size: 18, color: colorScheme.error),
+                  label: Text('Clear history', style: TextStyle(color: colorScheme.error)),
+                ),
+              ],
+            ),
+          ),
+        
+        // History list
+        Expanded(
+          child: history.isEmpty
+              ? _buildEmptyState(context, colorScheme)
+              : ListView.builder(
+                  itemCount: history.length,
+                  itemBuilder: (context, index) {
+                    final item = history[index];
+                    return _buildHistoryItem(context, ref, item, colorScheme);
+                  },
+                ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildEmptyState(BuildContext context, ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.history, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'No download history',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Text(
+            'Downloaded tracks will appear here',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+              color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildHistoryItem(BuildContext context, WidgetRef ref, DownloadHistoryItem item, ColorScheme colorScheme) {
+    final fileExists = File(item.filePath).existsSync();
+    
+    return Dismissible(
+      key: Key(item.id),
+      direction: DismissDirection.endToStart,
+      background: Container(
+        alignment: Alignment.centerRight,
+        padding: const EdgeInsets.only(right: 16),
+        color: colorScheme.error,
+        child: Icon(Icons.delete, color: colorScheme.onError),
+      ),
+      onDismissed: (_) {
+        ref.read(downloadHistoryProvider.notifier).removeFromHistory(item.id);
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Removed "${item.trackName}" from history')),
+        );
+      },
+      child: ListTile(
+        leading: item.coverUrl != null
+            ? ClipRRect(
+                borderRadius: BorderRadius.circular(8),
+                child: CachedNetworkImage(
+                  imageUrl: item.coverUrl!,
+                  width: 48,
+                  height: 48,
+                  fit: BoxFit.cover,
+                  placeholder: (_, __) => Container(
+                    width: 48,
+                    height: 48,
+                    decoration: BoxDecoration(
+                      color: colorScheme.surfaceContainerHighest,
+                      borderRadius: BorderRadius.circular(8),
+                    ),
+                  ),
+                ),
+              )
+            : Container(
+                width: 48,
+                height: 48,
+                decoration: BoxDecoration(
+                  color: colorScheme.surfaceContainerHighest,
+                  borderRadius: BorderRadius.circular(8),
+                ),
+                child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+              ),
+        title: Text(
+          item.trackName,
+          maxLines: 1,
+          overflow: TextOverflow.ellipsis,
+        ),
+        subtitle: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Text(
+              item.artistName,
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              style: TextStyle(color: colorScheme.onSurfaceVariant),
+            ),
+            Row(
+              children: [
+                Icon(
+                  _getServiceIcon(item.service),
+                  size: 12,
+                  color: colorScheme.onSurfaceVariant,
+                ),
+                const SizedBox(width: 4),
+                Text(
+                  _formatDate(item.downloadedAt),
+                  style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                if (!fileExists) ...[
+                  const SizedBox(width: 8),
+                  Icon(
+                    Icons.warning,
+                    size: 12,
+                    color: colorScheme.error,
+                  ),
+                  const SizedBox(width: 2),
+                  Text(
+                    'File missing',
+                    style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                      color: colorScheme.error,
+                    ),
+                  ),
+                ],
+              ],
+            ),
+          ],
+        ),
+        trailing: fileExists
+            ? IconButton(
+                icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+                onPressed: () => _openFile(context, item.filePath),
+              )
+            : Icon(Icons.error_outline, color: colorScheme.onSurfaceVariant),
+        onTap: fileExists ? () => _openFile(context, item.filePath) : null,
+        onLongPress: () => _showItemDetails(context, ref, item, colorScheme),
+      ),
+    );
+  }
+
+  IconData _getServiceIcon(String service) {
+    switch (service.toLowerCase()) {
+      case 'tidal':
+        return Icons.waves;
+      case 'qobuz':
+        return Icons.album;
+      case 'amazon':
+        return Icons.shopping_cart;
+      default:
+        return Icons.cloud_download;
+    }
+  }
+
+  String _formatDate(DateTime date) {
+    final now = DateTime.now();
+    final diff = now.difference(date);
+    
+    if (diff.inDays == 0) {
+      if (diff.inHours == 0) {
+        return '${diff.inMinutes}m ago';
+      }
+      return '${diff.inHours}h ago';
+    } else if (diff.inDays == 1) {
+      return 'Yesterday';
+    } else if (diff.inDays < 7) {
+      return '${diff.inDays}d ago';
+    } else {
+      return '${date.day}/${date.month}/${date.year}';
+    }
+  }
+
+  Future<void> _openFile(BuildContext context, String filePath) async {
+    try {
+      final result = await OpenFilex.open(filePath);
+      
+      if (result.type != ResultType.done) {
+        if (context.mounted) {
+          ScaffoldMessenger.of(context).showSnackBar(
+            SnackBar(
+              content: Text('Cannot open: ${result.message}'),
+              action: SnackBarAction(
+                label: 'Copy Path',
+                onPressed: () {
+                  Clipboard.setData(ClipboardData(text: filePath));
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    const SnackBar(content: Text('Path copied to clipboard')),
+                  );
+                },
+              ),
+            ),
+          );
+        }
+      }
+    } catch (e) {
+      if (context.mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Cannot open file: $e')),
+        );
+      }
+    }
+  }
+
+  void _showItemDetails(BuildContext context, WidgetRef ref, DownloadHistoryItem item, ColorScheme colorScheme) {
+    showModalBottomSheet(
+      context: context,
+      builder: (context) => Container(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                if (item.coverUrl != null)
+                  ClipRRect(
+                    borderRadius: BorderRadius.circular(12),
+                    child: CachedNetworkImage(
+                      imageUrl: item.coverUrl!,
+                      width: 64,
+                      height: 64,
+                      fit: BoxFit.cover,
+                    ),
+                  ),
+                const SizedBox(width: 16),
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(
+                        item.trackName,
+                        style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                          fontWeight: FontWeight.bold,
+                        ),
+                      ),
+                      Text(
+                        item.artistName,
+                        style: TextStyle(color: colorScheme.onSurfaceVariant),
+                      ),
+                      Text(
+                        item.albumName,
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                          color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: 16),
+            const Divider(),
+            _buildDetailRow(context, 'Service', item.service.toUpperCase(), colorScheme),
+            _buildDetailRow(context, 'Downloaded', _formatDate(item.downloadedAt), colorScheme),
+            _buildDetailRow(context, 'File', item.filePath, colorScheme, isPath: true),
+            const SizedBox(height: 16),
+            Row(
+              mainAxisAlignment: MainAxisAlignment.spaceEvenly,
+              children: [
+                TextButton.icon(
+                  onPressed: () {
+                    ref.read(downloadHistoryProvider.notifier).removeFromHistory(item.id);
+                    Navigator.pop(context);
+                  },
+                  icon: Icon(Icons.delete, color: colorScheme.error),
+                  label: Text('Remove', style: TextStyle(color: colorScheme.error)),
+                ),
+                if (File(item.filePath).existsSync())
+                  TextButton.icon(
+                    onPressed: () {
+                      Navigator.pop(context);
+                      _openFile(context, item.filePath);
+                    },
+                    icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+                    label: Text('Play', style: TextStyle(color: colorScheme.primary)),
+                  ),
+              ],
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildDetailRow(BuildContext context, String label, String value, ColorScheme colorScheme, {bool isPath = false}) {
+    return Padding(
+      padding: const EdgeInsets.symmetric(vertical: 4),
+      child: Row(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          SizedBox(
+            width: 80,
+            child: Text(
+              label,
+              style: TextStyle(color: colorScheme.onSurfaceVariant),
+            ),
+          ),
+          Expanded(
+            child: Text(
+              value,
+              style: TextStyle(
+                fontSize: isPath ? 12 : 14,
+                fontFamily: isPath ? 'monospace' : null,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showClearHistoryDialog(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Clear History'),
+        content: const Text(
+          'Are you sure you want to clear all download history? '
+          'This will not delete the downloaded files.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              ref.read(downloadHistoryProvider.notifier).clearHistory();
+              Navigator.pop(context);
+            },
+            child: Text('Clear', style: TextStyle(color: colorScheme.error)),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/home_screen.dart

@@ -0,0 +1,335 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:go_router/go_router.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/providers/track_provider.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+
+class HomeScreen extends ConsumerStatefulWidget {
+  const HomeScreen({super.key});
+
+  @override
+  ConsumerState<HomeScreen> createState() => _HomeScreenState();
+}
+
+class _HomeScreenState extends ConsumerState<HomeScreen> {
+  final _urlController = TextEditingController();
+  int _currentIndex = 0;
+
+  @override
+  void dispose() {
+    _urlController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _pasteFromClipboard() async {
+    final data = await Clipboard.getData(Clipboard.kTextPlain);
+    if (data?.text != null) {
+      _urlController.text = data!.text!;
+    }
+  }
+
+  Future<void> _fetchMetadata() async {
+    final url = _urlController.text.trim();
+    if (url.isEmpty) return;
+
+    if (url.startsWith('http') || url.startsWith('spotify:')) {
+      await ref.read(trackProvider.notifier).fetchFromUrl(url);
+    } else {
+      await ref.read(trackProvider.notifier).search(url);
+    }
+  }
+
+  void _downloadTrack(int index) {
+    final trackState = ref.read(trackProvider);
+    if (index >= 0 && index < trackState.tracks.length) {
+      final track = trackState.tracks[index];
+      final settings = ref.read(settingsProvider);
+      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Added "${track.name}" to queue')),
+      );
+    }
+  }
+
+  void _downloadAll() {
+    final trackState = ref.read(trackProvider);
+    if (trackState.tracks.isEmpty) return;
+    
+    final settings = ref.read(settingsProvider);
+    ref.read(downloadQueueProvider.notifier).addMultipleToQueue(
+      trackState.tracks,
+      settings.defaultService,
+    );
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text('Added ${trackState.tracks.length} tracks to queue')),
+    );
+  }
+
+  void _onNavTap(int index) {
+    setState(() => _currentIndex = index);
+    switch (index) {
+      case 0:
+        // Already on home
+        break;
+      case 1:
+        context.push('/queue');
+        break;
+      case 2:
+        context.push('/history');
+        break;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final trackState = ref.watch(trackProvider);
+    final queueState = ref.watch(downloadQueueProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(
+        leading: Padding(
+          padding: const EdgeInsets.all(8.0),
+          child: CircleAvatar(
+            backgroundColor: colorScheme.primaryContainer,
+            child: Icon(Icons.music_note, color: colorScheme.onPrimaryContainer, size: 20),
+          ),
+        ),
+        title: const Text('SpotiFLAC'),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.settings_outlined),
+            onPressed: () => context.push('/settings'),
+          ),
+        ],
+      ),
+      body: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          // URL Input
+          Padding(
+            padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
+            child: TextField(
+              controller: _urlController,
+              decoration: InputDecoration(
+                hintText: 'Paste Spotify URL or search...',
+                prefixIcon: const Icon(Icons.link),
+                suffixIcon: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    IconButton(icon: const Icon(Icons.paste), onPressed: _pasteFromClipboard),
+                    IconButton(icon: const Icon(Icons.search), onPressed: _fetchMetadata),
+                  ],
+                ),
+              ),
+              onSubmitted: (_) => _fetchMetadata(),
+            ),
+          ),
+
+          // Error message
+          if (trackState.error != null)
+            Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0),
+              child: Text(
+                trackState.error!, 
+                style: TextStyle(color: colorScheme.error),
+              ),
+            ),
+
+          // Loading indicator
+          if (trackState.isLoading)
+            LinearProgressIndicator(color: colorScheme.primary),
+
+          // Album/Playlist header
+          if (trackState.albumName != null || trackState.playlistName != null)
+            _buildHeader(trackState, colorScheme),
+
+          // Download All button
+          if (trackState.tracks.length > 1)
+            Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
+              child: FilledButton.icon(
+                onPressed: _downloadAll,
+                icon: const Icon(Icons.download),
+                label: Text('Download All (${trackState.tracks.length})'),
+                style: FilledButton.styleFrom(
+                  minimumSize: const Size.fromHeight(48),
+                ),
+              ),
+            ),
+
+          // Track list
+          Expanded(
+            child: trackState.tracks.isEmpty
+                ? _buildEmptyState(colorScheme)
+                : ListView.builder(
+                    itemCount: trackState.tracks.length,
+                    itemBuilder: (context, index) => _buildTrackTile(index, colorScheme),
+                  ),
+          ),
+        ],
+      ),
+      bottomNavigationBar: NavigationBar(
+        selectedIndex: _currentIndex,
+        onDestinationSelected: _onNavTap,
+        destinations: [
+          const NavigationDestination(
+            icon: Icon(Icons.home_outlined),
+            selectedIcon: Icon(Icons.home),
+            label: 'Home',
+          ),
+          NavigationDestination(
+            icon: Badge(
+              isLabelVisible: queueState.queuedCount > 0,
+              label: Text('${queueState.queuedCount}'),
+              child: const Icon(Icons.queue_music_outlined),
+            ),
+            selectedIcon: Badge(
+              isLabelVisible: queueState.queuedCount > 0,
+              label: Text('${queueState.queuedCount}'),
+              child: const Icon(Icons.queue_music),
+            ),
+            label: 'Queue',
+          ),
+          const NavigationDestination(
+            icon: Icon(Icons.history_outlined),
+            selectedIcon: Icon(Icons.history),
+            label: 'History',
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildHeader(TrackState state, ColorScheme colorScheme) {
+    return Card(
+      margin: const EdgeInsets.all(16),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            if (state.coverUrl != null)
+              ClipRRect(
+                borderRadius: BorderRadius.circular(8),
+                child: CachedNetworkImage(
+                  imageUrl: state.coverUrl!,
+                  width: 80,
+                  height: 80,
+                  fit: BoxFit.cover,
+                  placeholder: (_, __) => Container(
+                    width: 80,
+                    height: 80,
+                    color: colorScheme.surfaceContainerHighest,
+                  ),
+                ),
+              ),
+            const SizedBox(width: 16),
+            Expanded(
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    state.albumName ?? state.playlistName ?? '',
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                    maxLines: 2,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                  const SizedBox(height: 4),
+                  Text(
+                    '${state.tracks.length} tracks',
+                    style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            // Play all button
+            FilledButton.tonal(
+              onPressed: _downloadAll,
+              style: FilledButton.styleFrom(
+                shape: const CircleBorder(),
+                padding: const EdgeInsets.all(16),
+              ),
+              child: const Icon(Icons.download),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildTrackTile(int index, ColorScheme colorScheme) {
+    final track = ref.watch(trackProvider).tracks[index];
+    return ListTile(
+      leading: track.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: track.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(track.name, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Text(
+        track.artistName, 
+        maxLines: 1, 
+        overflow: TextOverflow.ellipsis,
+        style: TextStyle(color: colorScheme.onSurfaceVariant),
+      ),
+      trailing: Text(
+        _formatDuration(track.duration),
+        style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+          color: colorScheme.onSurfaceVariant,
+        ),
+      ),
+      onTap: () => _downloadTrack(index),
+    );
+  }
+
+  String _formatDuration(int ms) {
+    if (ms == 0) return '';
+    final duration = Duration(milliseconds: ms);
+    final minutes = duration.inMinutes;
+    final seconds = duration.inSeconds % 60;
+    return '$minutes:${seconds.toString().padLeft(2, '0')}';
+  }
+
+  Widget _buildEmptyState(ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.music_note, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'Paste a Spotify URL to get started',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/home_tab.dart

@@ -0,0 +1,457 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/providers/track_provider.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+
+class HomeTab extends ConsumerStatefulWidget {
+  const HomeTab({super.key});
+
+  @override
+  ConsumerState<HomeTab> createState() => _HomeTabState();
+}
+
+class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClientMixin {
+  final _urlController = TextEditingController();
+
+  @override
+  bool get wantKeepAlive => true;
+
+  @override
+  void dispose() {
+    _urlController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _pasteFromClipboard() async {
+    final data = await Clipboard.getData(Clipboard.kTextPlain);
+    if (data?.text != null) {
+      _urlController.text = data!.text!;
+    }
+  }
+
+  Future<void> _fetchMetadata() async {
+    final url = _urlController.text.trim();
+    if (url.isEmpty) return;
+
+    if (url.startsWith('http') || url.startsWith('spotify:')) {
+      await ref.read(trackProvider.notifier).fetchFromUrl(url);
+    } else {
+      await ref.read(trackProvider.notifier).search(url);
+    }
+  }
+
+  void _downloadTrack(int index) {
+    final trackState = ref.read(trackProvider);
+    if (index >= 0 && index < trackState.tracks.length) {
+      final track = trackState.tracks[index];
+      final settings = ref.read(settingsProvider);
+      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Added "${track.name}" to queue')),
+      );
+    }
+  }
+
+  void _downloadAll() {
+    final trackState = ref.read(trackProvider);
+    if (trackState.tracks.isEmpty) return;
+    
+    final settings = ref.read(settingsProvider);
+    ref.read(downloadQueueProvider.notifier).addMultipleToQueue(
+      trackState.tracks,
+      settings.defaultService,
+    );
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text('Added ${trackState.tracks.length} tracks to queue')),
+    );
+  }
+
+  Future<void> _openFile(String filePath) async {
+    try {
+      await OpenFilex.open(filePath);
+    } catch (e) {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Cannot open file: $e')),
+        );
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    super.build(context);
+    final trackState = ref.watch(trackProvider);
+    final historyState = ref.watch(downloadHistoryProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return CustomScrollView(
+      slivers: [
+        // Search bar
+        SliverToBoxAdapter(
+          child: Padding(
+            padding: const EdgeInsets.fromLTRB(16, 8, 16, 8),
+            child: TextField(
+              controller: _urlController,
+              decoration: InputDecoration(
+                hintText: 'Paste Spotify URL or search...',
+                prefixIcon: const Icon(Icons.link),
+                suffixIcon: Row(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    IconButton(icon: const Icon(Icons.paste), onPressed: _pasteFromClipboard),
+                    IconButton(icon: const Icon(Icons.search), onPressed: _fetchMetadata),
+                  ],
+                ),
+              ),
+              onSubmitted: (_) => _fetchMetadata(),
+            ),
+          ),
+        ),
+
+        // Error message
+        if (trackState.error != null)
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0),
+              child: Text(
+                trackState.error!, 
+                style: TextStyle(color: colorScheme.error),
+              ),
+            ),
+          ),
+
+        // Loading indicator
+        if (trackState.isLoading)
+          const SliverToBoxAdapter(
+            child: LinearProgressIndicator(),
+          ),
+
+        // Album/Playlist header
+        if (trackState.albumName != null || trackState.playlistName != null)
+          SliverToBoxAdapter(child: _buildHeader(trackState, colorScheme)),
+
+        // Download All button (when no header)
+        if (trackState.tracks.length > 1 && trackState.albumName == null && trackState.playlistName == null)
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
+              child: FilledButton.icon(
+                onPressed: _downloadAll,
+                icon: const Icon(Icons.download),
+                label: Text('Download All (${trackState.tracks.length})'),
+                style: FilledButton.styleFrom(
+                  minimumSize: const Size.fromHeight(48),
+                ),
+              ),
+            ),
+          ),
+
+        // Track list
+        if (trackState.tracks.isNotEmpty)
+          SliverList(
+            delegate: SliverChildBuilderDelegate(
+              (context, index) => _buildTrackTile(index, colorScheme),
+              childCount: trackState.tracks.length,
+            ),
+          ),
+
+        // Divider between search results and history
+        if (trackState.tracks.isNotEmpty && historyState.items.isNotEmpty)
+          const SliverToBoxAdapter(
+            child: Divider(height: 32),
+          ),
+
+        // Recent Downloads section header
+        if (historyState.items.isNotEmpty)
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.fromLTRB(16, 16, 16, 8),
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                children: [
+                  Text(
+                    'Recent Downloads',
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  TextButton(
+                    onPressed: () => _showClearHistoryDialog(colorScheme),
+                    child: const Text('Clear'),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+        // Recent Downloads list
+        if (historyState.items.isNotEmpty)
+          SliverList(
+            delegate: SliverChildBuilderDelegate(
+              (context, index) => _buildHistoryTile(historyState.items[index], colorScheme),
+              childCount: historyState.items.length > 5 ? 5 : historyState.items.length,
+            ),
+          ),
+
+        // Show more history button
+        if (historyState.items.length > 5)
+          SliverToBoxAdapter(
+            child: Padding(
+              padding: const EdgeInsets.all(16),
+              child: OutlinedButton(
+                onPressed: () => _showAllHistory(colorScheme),
+                child: Text('Show all ${historyState.items.length} downloads'),
+              ),
+            ),
+          ),
+
+        // Empty state (when no tracks and no history)
+        if (trackState.tracks.isEmpty && historyState.items.isEmpty)
+          SliverFillRemaining(
+            child: _buildEmptyState(colorScheme),
+          ),
+
+        // Bottom padding
+        const SliverToBoxAdapter(
+          child: SizedBox(height: 16),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildHeader(TrackState state, ColorScheme colorScheme) {
+    return Card(
+      margin: const EdgeInsets.all(16),
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Row(
+          children: [
+            if (state.coverUrl != null)
+              ClipRRect(
+                borderRadius: BorderRadius.circular(8),
+                child: CachedNetworkImage(
+                  imageUrl: state.coverUrl!,
+                  width: 80,
+                  height: 80,
+                  fit: BoxFit.cover,
+                  placeholder: (_, __) => Container(
+                    width: 80,
+                    height: 80,
+                    color: colorScheme.surfaceContainerHighest,
+                  ),
+                ),
+              ),
+            const SizedBox(width: 16),
+            Expanded(
+              child: Column(
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    state.albumName ?? state.playlistName ?? '',
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                    maxLines: 2,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                  const SizedBox(height: 4),
+                  Text(
+                    '${state.tracks.length} tracks',
+                    style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                    ),
+                  ),
+                ],
+              ),
+            ),
+            // Download all button
+            FilledButton.tonal(
+              onPressed: _downloadAll,
+              style: FilledButton.styleFrom(
+                shape: const CircleBorder(),
+                padding: const EdgeInsets.all(16),
+              ),
+              child: const Icon(Icons.download),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildTrackTile(int index, ColorScheme colorScheme) {
+    final track = ref.watch(trackProvider).tracks[index];
+    return ListTile(
+      leading: track.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: track.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(track.name, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Text(
+        track.artistName, 
+        maxLines: 1, 
+        overflow: TextOverflow.ellipsis,
+        style: TextStyle(color: colorScheme.onSurfaceVariant),
+      ),
+      trailing: IconButton(
+        icon: Icon(Icons.download, color: colorScheme.primary),
+        onPressed: () => _downloadTrack(index),
+      ),
+      onTap: () => _downloadTrack(index),
+    );
+  }
+
+  Widget _buildHistoryTile(DownloadHistoryItem item, ColorScheme colorScheme) {
+    final fileExists = File(item.filePath).existsSync();
+    
+    return ListTile(
+      leading: item.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: item.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(item.trackName, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Text(
+        item.artistName,
+        maxLines: 1,
+        overflow: TextOverflow.ellipsis,
+        style: TextStyle(color: colorScheme.onSurfaceVariant),
+      ),
+      trailing: fileExists
+          ? IconButton(
+              icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+              onPressed: () => _openFile(item.filePath),
+            )
+          : Icon(Icons.error_outline, color: colorScheme.error, size: 20),
+      onTap: fileExists ? () => _openFile(item.filePath) : null,
+    );
+  }
+
+  Widget _buildEmptyState(ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.music_note, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'Paste a Spotify URL to get started',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showClearHistoryDialog(ColorScheme colorScheme) {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Clear History'),
+        content: const Text('Clear all download history?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              ref.read(downloadHistoryProvider.notifier).clearHistory();
+              Navigator.pop(context);
+            },
+            child: Text('Clear', style: TextStyle(color: colorScheme.error)),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showAllHistory(ColorScheme colorScheme) {
+    final historyState = ref.read(downloadHistoryProvider);
+    
+    showModalBottomSheet(
+      context: context,
+      isScrollControlled: true,
+      builder: (context) => DraggableScrollableSheet(
+        initialChildSize: 0.7,
+        minChildSize: 0.5,
+        maxChildSize: 0.95,
+        expand: false,
+        builder: (context, scrollController) => Column(
+          children: [
+            Padding(
+              padding: const EdgeInsets.all(16),
+              child: Row(
+                mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                children: [
+                  Text(
+                    'All Downloads (${historyState.items.length})',
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  IconButton(
+                    icon: const Icon(Icons.close),
+                    onPressed: () => Navigator.pop(context),
+                  ),
+                ],
+              ),
+            ),
+            const Divider(height: 1),
+            Expanded(
+              child: ListView.builder(
+                controller: scrollController,
+                itemCount: historyState.items.length,
+                itemBuilder: (context, index) => _buildHistoryTile(
+                  historyState.items[index],
+                  colorScheme,
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}

lib/screens/main_shell.dart

@@ -0,0 +1,105 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/screens/home_tab.dart';
+import 'package:spotiflac_android/screens/queue_tab.dart';
+import 'package:spotiflac_android/screens/settings_tab.dart';
+
+class MainShell extends ConsumerStatefulWidget {
+  const MainShell({super.key});
+
+  @override
+  ConsumerState<MainShell> createState() => _MainShellState();
+}
+
+class _MainShellState extends ConsumerState<MainShell> {
+  int _currentIndex = 0;
+  late PageController _pageController;
+
+  @override
+  void initState() {
+    super.initState();
+    _pageController = PageController(initialPage: _currentIndex);
+  }
+
+  @override
+  void dispose() {
+    _pageController.dispose();
+    super.dispose();
+  }
+
+  void _onNavTap(int index) {
+    setState(() => _currentIndex = index);
+    _pageController.animateToPage(
+      index,
+      duration: const Duration(milliseconds: 300),
+      curve: Curves.easeInOut,
+    );
+  }
+
+  void _onPageChanged(int index) {
+    setState(() => _currentIndex = index);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final queueState = ref.watch(downloadQueueProvider);
+
+    return Scaffold(
+      appBar: AppBar(
+        leading: Padding(
+          padding: const EdgeInsets.all(8.0),
+          child: ClipRRect(
+            borderRadius: BorderRadius.circular(20),
+            child: Image.asset(
+              'assets/images/logo.png',
+              width: 40,
+              height: 40,
+            ),
+          ),
+        ),
+        title: const Text('SpotiFLAC'),
+      ),
+      body: PageView(
+        controller: _pageController,
+        onPageChanged: _onPageChanged,
+        physics: const BouncingScrollPhysics(),
+        children: const [
+          HomeTab(),
+          QueueTab(),
+          SettingsTab(),
+        ],
+      ),
+      bottomNavigationBar: NavigationBar(
+        selectedIndex: _currentIndex,
+        onDestinationSelected: _onNavTap,
+        animationDuration: const Duration(milliseconds: 300),
+        destinations: [
+          const NavigationDestination(
+            icon: Icon(Icons.home_outlined),
+            selectedIcon: Icon(Icons.home),
+            label: 'Home',
+          ),
+          NavigationDestination(
+            icon: Badge(
+              isLabelVisible: queueState.queuedCount > 0,
+              label: Text('${queueState.queuedCount}'),
+              child: const Icon(Icons.download_outlined),
+            ),
+            selectedIcon: Badge(
+              isLabelVisible: queueState.queuedCount > 0,
+              label: Text('${queueState.queuedCount}'),
+              child: const Icon(Icons.download),
+            ),
+            label: 'Downloads',
+          ),
+          const NavigationDestination(
+            icon: Icon(Icons.settings_outlined),
+            selectedIcon: Icon(Icons.settings),
+            label: 'Settings',
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/queue_screen.dart

@@ -0,0 +1,232 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/models/download_item.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+
+class QueueScreen extends ConsumerWidget {
+  const QueueScreen({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final queueState = ref.watch(downloadQueueProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: const Text('Download Queue'),
+        actions: [
+          if (queueState.items.isNotEmpty)
+            IconButton(
+              icon: const Icon(Icons.delete_sweep),
+              onPressed: () => ref.read(downloadQueueProvider.notifier).clearCompleted(),
+              tooltip: 'Clear completed',
+            ),
+          if (queueState.items.isNotEmpty)
+            IconButton(
+              icon: const Icon(Icons.clear_all),
+              onPressed: () => _showClearAllDialog(context, ref),
+              tooltip: 'Clear all',
+            ),
+        ],
+      ),
+      body: queueState.items.isEmpty
+          ? _buildEmptyState(context, colorScheme)
+          : ListView.builder(
+              itemCount: queueState.items.length,
+              itemBuilder: (context, index) => _buildQueueItem(context, ref, queueState.items[index], colorScheme),
+            ),
+    );
+  }
+
+  Widget _buildEmptyState(BuildContext context, ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.queue, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'No downloads in queue',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Text(
+            'Add tracks from the home screen',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+              color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildQueueItem(BuildContext context, WidgetRef ref, DownloadItem item, ColorScheme colorScheme) {
+    return ListTile(
+      leading: item.track.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: item.track.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(item.track.name, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            item.track.artistName, 
+            maxLines: 1, 
+            overflow: TextOverflow.ellipsis,
+            style: TextStyle(color: colorScheme.onSurfaceVariant),
+          ),
+          if (item.status == DownloadStatus.downloading) ...[
+            const SizedBox(height: 4),
+            Row(
+              children: [
+                Expanded(
+                  child: LinearProgressIndicator(
+                    value: item.progress > 0 ? item.progress : null,
+                    backgroundColor: colorScheme.surfaceContainerHighest,
+                    color: colorScheme.primary,
+                  ),
+                ),
+                const SizedBox(width: 8),
+                Text(
+                  '${(item.progress * 100).toStringAsFixed(0)}%',
+                  style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ],
+            ),
+          ],
+        ],
+      ),
+      trailing: _buildStatusIcon(context, item, colorScheme),
+      onTap: item.status == DownloadStatus.queued
+          ? () => ref.read(downloadQueueProvider.notifier).cancelItem(item.id)
+          : null,
+    );
+  }
+
+  Widget _buildStatusIcon(BuildContext context, DownloadItem item, ColorScheme colorScheme) {
+    switch (item.status) {
+      case DownloadStatus.queued:
+        return Icon(Icons.hourglass_empty, color: colorScheme.onSurfaceVariant);
+      case DownloadStatus.downloading:
+        return SizedBox(
+          width: 24,
+          height: 24,
+          child: CircularProgressIndicator(
+            value: item.progress,
+            strokeWidth: 2,
+            color: colorScheme.primary,
+          ),
+        );
+      case DownloadStatus.completed:
+        return Icon(Icons.check_circle, color: colorScheme.primary);
+      case DownloadStatus.failed:
+        return IconButton(
+          icon: Icon(Icons.error, color: colorScheme.error),
+          onPressed: () => _showErrorDialog(context, item, colorScheme),
+          tooltip: 'Tap to see error details',
+        );
+      case DownloadStatus.skipped:
+        return Icon(Icons.skip_next, color: colorScheme.primary);
+    }
+  }
+
+  void _showErrorDialog(BuildContext context, DownloadItem item, ColorScheme colorScheme) {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Row(
+          children: [
+            Icon(Icons.error, color: colorScheme.error),
+            const SizedBox(width: 8),
+            const Text('Download Failed'),
+          ],
+        ),
+        content: SingleChildScrollView(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Text('Track: ${item.track.name}', style: const TextStyle(fontWeight: FontWeight.bold)),
+              Text('Artist: ${item.track.artistName}'),
+              const SizedBox(height: 16),
+              const Text('Error:', style: TextStyle(fontWeight: FontWeight.bold)),
+              const SizedBox(height: 4),
+              Container(
+                padding: const EdgeInsets.all(8),
+                decoration: BoxDecoration(
+                  color: colorScheme.errorContainer,
+                  borderRadius: BorderRadius.circular(8),
+                ),
+                child: Text(
+                  item.error ?? 'Unknown error',
+                  style: TextStyle(
+                    fontFamily: 'monospace', 
+                    fontSize: 12,
+                    color: colorScheme.onErrorContainer,
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Close'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showClearAllDialog(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Clear All'),
+        content: const Text('Are you sure you want to clear all downloads?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              ref.read(downloadQueueProvider.notifier).clearAll();
+              Navigator.pop(context);
+            },
+            child: Text('Clear', style: TextStyle(color: colorScheme.error)),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/queue_tab.dart

@@ -0,0 +1,251 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/models/download_item.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+
+class QueueTab extends ConsumerWidget {
+  const QueueTab({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final queueState = ref.watch(downloadQueueProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Column(
+      children: [
+        // Header with actions
+        if (queueState.items.isNotEmpty)
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+            child: Row(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
+                Text(
+                  '${queueState.items.length} items',
+                  style: Theme.of(context).textTheme.titleSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                  ),
+                ),
+                Row(
+                  children: [
+                    TextButton.icon(
+                      onPressed: () => ref.read(downloadQueueProvider.notifier).clearCompleted(),
+                      icon: const Icon(Icons.done_all, size: 18),
+                      label: const Text('Clear done'),
+                    ),
+                    TextButton.icon(
+                      onPressed: () => _showClearAllDialog(context, ref),
+                      icon: Icon(Icons.clear_all, size: 18, color: colorScheme.error),
+                      label: Text('Clear all', style: TextStyle(color: colorScheme.error)),
+                    ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+        
+        // Queue list
+        Expanded(
+          child: queueState.items.isEmpty
+              ? _buildEmptyState(context, colorScheme)
+              : ListView.builder(
+                  itemCount: queueState.items.length,
+                  itemBuilder: (context, index) => _buildQueueItem(context, ref, queueState.items[index], colorScheme),
+                ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildEmptyState(BuildContext context, ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.queue_music, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'No downloads in queue',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Text(
+            'Add tracks from the Home tab',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+              color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildQueueItem(BuildContext context, WidgetRef ref, DownloadItem item, ColorScheme colorScheme) {
+    return ListTile(
+      leading: item.track.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: item.track.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(item.track.name, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            item.track.artistName, 
+            maxLines: 1, 
+            overflow: TextOverflow.ellipsis,
+            style: TextStyle(color: colorScheme.onSurfaceVariant),
+          ),
+          if (item.status == DownloadStatus.downloading) ...[
+            const SizedBox(height: 4),
+            Row(
+              children: [
+                Expanded(
+                  child: LinearProgressIndicator(
+                    value: item.progress > 0 ? item.progress : null,
+                    backgroundColor: colorScheme.surfaceContainerHighest,
+                    color: colorScheme.primary,
+                  ),
+                ),
+                const SizedBox(width: 8),
+                Text(
+                  '${(item.progress * 100).toStringAsFixed(0)}%',
+                  style: Theme.of(context).textTheme.labelSmall?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ],
+            ),
+          ],
+        ],
+      ),
+      trailing: _buildStatusIcon(context, item, colorScheme),
+      onTap: item.status == DownloadStatus.queued
+          ? () => ref.read(downloadQueueProvider.notifier).cancelItem(item.id)
+          : null,
+    );
+  }
+
+  Widget _buildStatusIcon(BuildContext context, DownloadItem item, ColorScheme colorScheme) {
+    switch (item.status) {
+      case DownloadStatus.queued:
+        return Icon(Icons.hourglass_empty, color: colorScheme.onSurfaceVariant);
+      case DownloadStatus.downloading:
+        return SizedBox(
+          width: 24,
+          height: 24,
+          child: CircularProgressIndicator(
+            value: item.progress,
+            strokeWidth: 2,
+            color: colorScheme.primary,
+          ),
+        );
+      case DownloadStatus.completed:
+        return Icon(Icons.check_circle, color: colorScheme.primary);
+      case DownloadStatus.failed:
+        return IconButton(
+          icon: Icon(Icons.error, color: colorScheme.error),
+          onPressed: () => _showErrorDialog(context, item, colorScheme),
+          tooltip: 'Tap to see error details',
+        );
+      case DownloadStatus.skipped:
+        return Icon(Icons.skip_next, color: colorScheme.primary);
+    }
+  }
+
+  void _showErrorDialog(BuildContext context, DownloadItem item, ColorScheme colorScheme) {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Row(
+          children: [
+            Icon(Icons.error, color: colorScheme.error),
+            const SizedBox(width: 8),
+            const Text('Download Failed'),
+          ],
+        ),
+        content: SingleChildScrollView(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Text('Track: ${item.track.name}', style: const TextStyle(fontWeight: FontWeight.bold)),
+              Text('Artist: ${item.track.artistName}'),
+              const SizedBox(height: 16),
+              const Text('Error:', style: TextStyle(fontWeight: FontWeight.bold)),
+              const SizedBox(height: 4),
+              Container(
+                padding: const EdgeInsets.all(8),
+                decoration: BoxDecoration(
+                  color: colorScheme.errorContainer,
+                  borderRadius: BorderRadius.circular(8),
+                ),
+                child: Text(
+                  item.error ?? 'Unknown error',
+                  style: TextStyle(
+                    fontFamily: 'monospace', 
+                    fontSize: 12,
+                    color: colorScheme.onErrorContainer,
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Close'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  void _showClearAllDialog(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Clear All'),
+        content: const Text('Are you sure you want to clear all downloads?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              ref.read(downloadQueueProvider.notifier).clearAll();
+              Navigator.pop(context);
+            },
+            child: Text('Clear', style: TextStyle(color: colorScheme.error)),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/screens/search_screen.dart

@@ -0,0 +1,179 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/providers/track_provider.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+
+class SearchScreen extends ConsumerStatefulWidget {
+  final String query;
+
+  const SearchScreen({super.key, required this.query});
+
+  @override
+  ConsumerState<SearchScreen> createState() => _SearchScreenState();
+}
+
+class _SearchScreenState extends ConsumerState<SearchScreen> {
+  late TextEditingController _searchController;
+
+  @override
+  void initState() {
+    super.initState();
+    _searchController = TextEditingController(text: widget.query);
+    if (widget.query.isNotEmpty) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        ref.read(trackProvider.notifier).search(widget.query);
+      });
+    }
+  }
+
+  @override
+  void dispose() {
+    _searchController.dispose();
+    super.dispose();
+  }
+
+  void _search() {
+    final query = _searchController.text.trim();
+    if (query.isNotEmpty) {
+      ref.read(trackProvider.notifier).search(query);
+    }
+  }
+
+  void _downloadTrack(int index) {
+    final trackState = ref.read(trackProvider);
+    if (index >= 0 && index < trackState.tracks.length) {
+      final track = trackState.tracks[index];
+      final settings = ref.read(settingsProvider);
+      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Added "${track.name}" to queue')),
+      );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final trackState = ref.watch(trackProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(
+        title: TextField(
+          controller: _searchController,
+          style: TextStyle(color: colorScheme.onSurface),
+          decoration: InputDecoration(
+            hintText: 'Search tracks...',
+            hintStyle: TextStyle(color: colorScheme.onSurfaceVariant),
+            border: InputBorder.none,
+            enabledBorder: InputBorder.none,
+            focusedBorder: InputBorder.none,
+          ),
+          onSubmitted: (_) => _search(),
+          autofocus: widget.query.isEmpty,
+        ),
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.search),
+            onPressed: _search,
+          ),
+        ],
+      ),
+      body: Column(
+        children: [
+          if (trackState.isLoading)
+            LinearProgressIndicator(color: colorScheme.primary),
+          if (trackState.error != null)
+            Padding(
+              padding: const EdgeInsets.all(16.0),
+              child: Text(
+                trackState.error!, 
+                style: TextStyle(color: colorScheme.error),
+              ),
+            ),
+          Expanded(
+            child: trackState.tracks.isEmpty
+                ? _buildEmptyState(colorScheme)
+                : ListView.builder(
+                    itemCount: trackState.tracks.length,
+                    itemBuilder: (context, index) => _buildTrackTile(index, colorScheme),
+                  ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildEmptyState(ColorScheme colorScheme) {
+    return Center(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.center,
+        children: [
+          Icon(
+            Icons.search, 
+            size: 64, 
+            color: colorScheme.onSurfaceVariant,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            'Search for tracks',
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildTrackTile(int index, ColorScheme colorScheme) {
+    final track = ref.watch(trackProvider).tracks[index];
+    return ListTile(
+      leading: track.coverUrl != null
+          ? ClipRRect(
+              borderRadius: BorderRadius.circular(8),
+              child: CachedNetworkImage(
+                imageUrl: track.coverUrl!,
+                width: 48,
+                height: 48,
+                fit: BoxFit.cover,
+              ),
+            )
+          : Container(
+              width: 48,
+              height: 48,
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceContainerHighest,
+                borderRadius: BorderRadius.circular(8),
+              ),
+              child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
+            ),
+      title: Text(track.name, maxLines: 1, overflow: TextOverflow.ellipsis),
+      subtitle: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Text(
+            track.artistName, 
+            maxLines: 1, 
+            overflow: TextOverflow.ellipsis,
+            style: TextStyle(color: colorScheme.onSurfaceVariant),
+          ),
+          Text(
+            track.albumName,
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+            style: Theme.of(context).textTheme.bodySmall?.copyWith(
+              color: colorScheme.onSurfaceVariant.withValues(alpha: 0.7),
+            ),
+          ),
+        ],
+      ),
+      trailing: IconButton(
+        icon: Icon(Icons.download, color: colorScheme.primary),
+        onPressed: () => _downloadTrack(index),
+      ),
+      onTap: () => _downloadTrack(index),
+    );
+  }
+}

lib/screens/settings_screen.dart

@@ -0,0 +1,426 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:file_picker/file_picker.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/theme_provider.dart';
+
+class SettingsScreen extends ConsumerWidget {
+  const SettingsScreen({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final settings = ref.watch(settingsProvider);
+    final themeSettings = ref.watch(themeProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      appBar: AppBar(title: const Text('Settings')),
+      body: ListView(
+        children: [
+          // Theme Section
+          _buildSectionHeader(context, 'Appearance', colorScheme),
+          
+          // Theme Mode
+          ListTile(
+            leading: Icon(Icons.brightness_6, color: colorScheme.primary),
+            title: const Text('Theme Mode'),
+            subtitle: Text(_getThemeModeName(themeSettings.themeMode)),
+            onTap: () => _showThemeModePicker(context, ref, themeSettings.themeMode),
+          ),
+          
+          // Dynamic Color Toggle
+          SwitchListTile(
+            secondary: Icon(Icons.palette, color: colorScheme.primary),
+            title: const Text('Dynamic Color'),
+            subtitle: const Text('Use colors from your wallpaper'),
+            value: themeSettings.useDynamicColor,
+            onChanged: (value) => ref.read(themeProvider.notifier).setUseDynamicColor(value),
+          ),
+          
+          // Seed Color Picker (only when dynamic color is disabled)
+          if (!themeSettings.useDynamicColor)
+            ListTile(
+              leading: Container(
+                width: 24,
+                height: 24,
+                decoration: BoxDecoration(
+                  color: Color(themeSettings.seedColorValue),
+                  shape: BoxShape.circle,
+                  border: Border.all(color: colorScheme.outline),
+                ),
+              ),
+              title: const Text('Accent Color'),
+              subtitle: const Text('Choose your preferred color'),
+              onTap: () => _showColorPicker(context, ref, themeSettings.seedColorValue),
+            ),
+          
+          // Theme Preview
+          _buildThemePreview(context, colorScheme),
+          
+          const Divider(),
+          
+          // Download Section
+          _buildSectionHeader(context, 'Download', colorScheme),
+
+          // Download Service
+          ListTile(
+            leading: Icon(Icons.cloud_download, color: colorScheme.primary),
+            title: const Text('Default Service'),
+            subtitle: Text(_getServiceName(settings.defaultService)),
+            onTap: () => _showServicePicker(context, ref, settings.defaultService),
+          ),
+
+          // Audio Quality
+          ListTile(
+            leading: Icon(Icons.high_quality, color: colorScheme.primary),
+            title: const Text('Audio Quality'),
+            subtitle: Text(_getQualityName(settings.audioQuality)),
+            onTap: () => _showQualityPicker(context, ref, settings.audioQuality),
+          ),
+
+          // Filename Format
+          ListTile(
+            leading: Icon(Icons.text_fields, color: colorScheme.primary),
+            title: const Text('Filename Format'),
+            subtitle: Text(settings.filenameFormat),
+            onTap: () => _showFormatEditor(context, ref, settings.filenameFormat),
+          ),
+
+          // Download Directory
+          ListTile(
+            leading: Icon(Icons.folder, color: colorScheme.primary),
+            title: const Text('Download Directory'),
+            subtitle: Text(settings.downloadDirectory.isEmpty ? 'Music/SpotiFLAC' : settings.downloadDirectory),
+            onTap: () => _pickDirectory(context, ref),
+          ),
+          
+          const Divider(),
+          
+          // Options Section
+          _buildSectionHeader(context, 'Options', colorScheme),
+
+          // Auto Fallback
+          SwitchListTile(
+            secondary: Icon(Icons.sync, color: colorScheme.primary),
+            title: const Text('Auto Fallback'),
+            subtitle: const Text('Try other services if download fails'),
+            value: settings.autoFallback,
+            onChanged: (value) => ref.read(settingsProvider.notifier).setAutoFallback(value),
+          ),
+
+          // Embed Lyrics
+          SwitchListTile(
+            secondary: Icon(Icons.lyrics, color: colorScheme.primary),
+            title: const Text('Embed Lyrics'),
+            subtitle: const Text('Embed synced lyrics into FLAC files'),
+            value: settings.embedLyrics,
+            onChanged: (value) => ref.read(settingsProvider.notifier).setEmbedLyrics(value),
+          ),
+
+          // Max Quality Cover
+          SwitchListTile(
+            secondary: Icon(Icons.image, color: colorScheme.primary),
+            title: const Text('Max Quality Cover'),
+            subtitle: const Text('Download highest resolution cover art'),
+            value: settings.maxQualityCover,
+            onChanged: (value) => ref.read(settingsProvider.notifier).setMaxQualityCover(value),
+          ),
+          
+          const Divider(),
+
+          // About
+          ListTile(
+            leading: Icon(Icons.info, color: colorScheme.primary),
+            title: const Text('About'),
+            subtitle: const Text('SpotiFLAC v1.0.0'),
+            onTap: () => showAboutDialog(
+              context: context,
+              applicationName: 'SpotiFLAC',
+              applicationVersion: '1.0.0',
+              applicationLegalese: '© 2024 SpotiFLAC',
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildSectionHeader(BuildContext context, String title, ColorScheme colorScheme) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(16, 16, 16, 8),
+      child: Text(
+        title,
+        style: Theme.of(context).textTheme.titleSmall?.copyWith(
+          color: colorScheme.primary,
+          fontWeight: FontWeight.bold,
+        ),
+      ),
+    );
+  }
+
+  Widget _buildThemePreview(BuildContext context, ColorScheme colorScheme) {
+    return Padding(
+      padding: const EdgeInsets.all(16),
+      child: Card(
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(
+                'Theme Preview',
+                style: Theme.of(context).textTheme.titleSmall,
+              ),
+              const SizedBox(height: 12),
+              Wrap(
+                spacing: 8,
+                runSpacing: 8,
+                children: [
+                  _buildColorChip('Primary', colorScheme.primary, colorScheme.onPrimary),
+                  _buildColorChip('Secondary', colorScheme.secondary, colorScheme.onSecondary),
+                  _buildColorChip('Tertiary', colorScheme.tertiary, colorScheme.onTertiary),
+                  _buildColorChip('Surface', colorScheme.surface, colorScheme.onSurface),
+                ],
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+
+  Widget _buildColorChip(String label, Color background, Color foreground) {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+      decoration: BoxDecoration(
+        color: background,
+        borderRadius: BorderRadius.circular(16),
+      ),
+      child: Text(
+        label,
+        style: TextStyle(color: foreground, fontSize: 12),
+      ),
+    );
+  }
+
+  String _getThemeModeName(ThemeMode mode) {
+    switch (mode) {
+      case ThemeMode.light: return 'Light';
+      case ThemeMode.dark: return 'Dark';
+      case ThemeMode.system: return 'System';
+    }
+  }
+
+  String _getServiceName(String service) {
+    switch (service) {
+      case 'tidal': return 'Tidal';
+      case 'qobuz': return 'Qobuz';
+      case 'amazon': return 'Amazon Music';
+      default: return service;
+    }
+  }
+
+  String _getQualityName(String quality) {
+    switch (quality) {
+      case 'LOSSLESS': return 'FLAC (Lossless)';
+      case 'HI_RES': return 'Hi-Res FLAC (24-bit)';
+      default: return quality;
+    }
+  }
+
+  void _showThemeModePicker(BuildContext context, WidgetRef ref, ThemeMode current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Theme Mode'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildThemeModeOption(context, ref, ThemeMode.system, 'System', Icons.brightness_auto, current, colorScheme),
+            _buildThemeModeOption(context, ref, ThemeMode.light, 'Light', Icons.light_mode, current, colorScheme),
+            _buildThemeModeOption(context, ref, ThemeMode.dark, 'Dark', Icons.dark_mode, current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildThemeModeOption(BuildContext context, WidgetRef ref, ThemeMode mode, String label, IconData icon, ThemeMode current, ColorScheme colorScheme) {
+    final isSelected = mode == current;
+    return ListTile(
+      leading: Icon(icon, color: isSelected ? colorScheme.primary : null),
+      title: Text(label),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(themeProvider.notifier).setThemeMode(mode);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showColorPicker(BuildContext context, WidgetRef ref, int currentColor) {
+    final colors = [
+      const Color(0xFF1DB954), // Spotify Green
+      const Color(0xFF6750A4), // Purple
+      const Color(0xFF0061A4), // Blue
+      const Color(0xFF006E1C), // Green
+      const Color(0xFFBA1A1A), // Red
+      const Color(0xFF984061), // Pink
+      const Color(0xFF7D5260), // Brown
+      const Color(0xFF006874), // Teal
+      const Color(0xFFFF6F00), // Orange
+    ];
+
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Choose Accent Color'),
+        content: Wrap(
+          spacing: 12,
+          runSpacing: 12,
+          children: colors.map((color) {
+            final isSelected = color.toARGB32() == currentColor;
+            return GestureDetector(
+              onTap: () {
+                ref.read(themeProvider.notifier).setSeedColor(color);
+                Navigator.pop(context);
+              },
+              child: Container(
+                width: 48,
+                height: 48,
+                decoration: BoxDecoration(
+                  color: color,
+                  shape: BoxShape.circle,
+                  border: isSelected 
+                      ? Border.all(color: Theme.of(context).colorScheme.onSurface, width: 3)
+                      : null,
+                ),
+                child: isSelected 
+                    ? const Icon(Icons.check, color: Colors.white)
+                    : null,
+              ),
+            );
+          }).toList(),
+        ),
+      ),
+    );
+  }
+
+  void _showServicePicker(BuildContext context, WidgetRef ref, String current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Select Service'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildServiceOption(context, ref, 'tidal', 'Tidal', current, colorScheme),
+            _buildServiceOption(context, ref, 'qobuz', 'Qobuz', current, colorScheme),
+            _buildServiceOption(context, ref, 'amazon', 'Amazon Music', current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildServiceOption(BuildContext context, WidgetRef ref, String value, String label, String current, ColorScheme colorScheme) {
+    final isSelected = value == current;
+    return ListTile(
+      title: Text(label),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(settingsProvider.notifier).setDefaultService(value);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showQualityPicker(BuildContext context, WidgetRef ref, String current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Select Quality'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildQualityOption(context, ref, 'LOSSLESS', 'FLAC (Lossless)', '16-bit / 44.1kHz', current, colorScheme),
+            _buildQualityOption(context, ref, 'HI_RES', 'Hi-Res FLAC', '24-bit / up to 192kHz', current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildQualityOption(BuildContext context, WidgetRef ref, String value, String title, String subtitle, String current, ColorScheme colorScheme) {
+    final isSelected = value == current;
+    return ListTile(
+      title: Text(title),
+      subtitle: Text(subtitle),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(settingsProvider.notifier).setAudioQuality(value);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showFormatEditor(BuildContext context, WidgetRef ref, String current) {
+    final controller = TextEditingController(text: current);
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Filename Format'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            TextField(
+              controller: controller,
+              decoration: const InputDecoration(
+                hintText: '{artist} - {title}',
+              ),
+            ),
+            const SizedBox(height: 16),
+            Text(
+              'Available placeholders:',
+              style: Theme.of(context).textTheme.labelMedium?.copyWith(
+                color: colorScheme.onSurfaceVariant,
+              ),
+            ),
+            const SizedBox(height: 4),
+            Text(
+              '{title}, {artist}, {album}, {track}, {year}, {disc}',
+              style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                color: colorScheme.onSurfaceVariant,
+              ),
+            ),
+          ],
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          FilledButton(
+            onPressed: () {
+              ref.read(settingsProvider.notifier).setFilenameFormat(controller.text);
+              Navigator.pop(context);
+            },
+            child: const Text('Save'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _pickDirectory(BuildContext context, WidgetRef ref) async {
+    final result = await FilePicker.platform.getDirectoryPath();
+    if (result != null) {
+      ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+    }
+  }
+}

lib/screens/settings_tab.dart

@@ -0,0 +1,395 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:file_picker/file_picker.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/theme_provider.dart';
+
+class SettingsTab extends ConsumerStatefulWidget {
+  const SettingsTab({super.key});
+
+  @override
+  ConsumerState<SettingsTab> createState() => _SettingsTabState();
+}
+
+class _SettingsTabState extends ConsumerState<SettingsTab> with AutomaticKeepAliveClientMixin {
+  @override
+  bool get wantKeepAlive => true;
+
+  @override
+  Widget build(BuildContext context) {
+    super.build(context);
+    final settings = ref.watch(settingsProvider);
+    final themeSettings = ref.watch(themeProvider);
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return ListView(
+      children: [
+        // Theme Section
+        _buildSectionHeader(context, 'Appearance', colorScheme),
+        
+        // Theme Mode
+        ListTile(
+          leading: Icon(Icons.brightness_6, color: colorScheme.primary),
+          title: const Text('Theme Mode'),
+          subtitle: Text(_getThemeModeName(themeSettings.themeMode)),
+          onTap: () => _showThemeModePicker(context, ref, themeSettings.themeMode),
+        ),
+        
+        // Dynamic Color Toggle
+        SwitchListTile(
+          secondary: Icon(Icons.palette, color: colorScheme.primary),
+          title: const Text('Dynamic Color'),
+          subtitle: const Text('Use colors from your wallpaper'),
+          value: themeSettings.useDynamicColor,
+          onChanged: (value) => ref.read(themeProvider.notifier).setUseDynamicColor(value),
+        ),
+        
+        // Seed Color Picker (only when dynamic color is disabled)
+        if (!themeSettings.useDynamicColor)
+          ListTile(
+            leading: Container(
+              width: 24,
+              height: 24,
+              decoration: BoxDecoration(
+                color: Color(themeSettings.seedColorValue),
+                shape: BoxShape.circle,
+                border: Border.all(color: colorScheme.outline),
+              ),
+            ),
+            title: const Text('Accent Color'),
+            subtitle: const Text('Choose your preferred color'),
+            onTap: () => _showColorPicker(context, ref, themeSettings.seedColorValue),
+          ),
+        
+        // Theme Preview
+        _buildThemePreview(context, colorScheme),
+        
+        const Divider(),
+        
+        // Download Section
+        _buildSectionHeader(context, 'Download', colorScheme),
+
+        // Download Service
+        ListTile(
+          leading: Icon(Icons.cloud_download, color: colorScheme.primary),
+          title: const Text('Default Service'),
+          subtitle: Text(_getServiceName(settings.defaultService)),
+          onTap: () => _showServicePicker(context, ref, settings.defaultService),
+        ),
+
+        // Audio Quality
+        ListTile(
+          leading: Icon(Icons.high_quality, color: colorScheme.primary),
+          title: const Text('Audio Quality'),
+          subtitle: Text(_getQualityName(settings.audioQuality)),
+          onTap: () => _showQualityPicker(context, ref, settings.audioQuality),
+        ),
+
+        // Filename Format
+        ListTile(
+          leading: Icon(Icons.text_fields, color: colorScheme.primary),
+          title: const Text('Filename Format'),
+          subtitle: Text(settings.filenameFormat),
+          onTap: () => _showFormatEditor(context, ref, settings.filenameFormat),
+        ),
+
+        // Download Directory
+        ListTile(
+          leading: Icon(Icons.folder, color: colorScheme.primary),
+          title: const Text('Download Directory'),
+          subtitle: Text(settings.downloadDirectory.isEmpty ? 'Music/SpotiFLAC' : settings.downloadDirectory),
+          onTap: () => _pickDirectory(context, ref),
+        ),
+        
+        const Divider(),
+        
+        // Options Section
+        _buildSectionHeader(context, 'Options', colorScheme),
+
+        // Auto Fallback
+        SwitchListTile(
+          secondary: Icon(Icons.sync, color: colorScheme.primary),
+          title: const Text('Auto Fallback'),
+          subtitle: const Text('Try other services if download fails'),
+          value: settings.autoFallback,
+          onChanged: (value) => ref.read(settingsProvider.notifier).setAutoFallback(value),
+        ),
+
+        // Embed Lyrics
+        SwitchListTile(
+          secondary: Icon(Icons.lyrics, color: colorScheme.primary),
+          title: const Text('Embed Lyrics'),
+          subtitle: const Text('Embed synced lyrics into FLAC files'),
+          value: settings.embedLyrics,
+          onChanged: (value) => ref.read(settingsProvider.notifier).setEmbedLyrics(value),
+        ),
+
+        // Max Quality Cover
+        SwitchListTile(
+          secondary: Icon(Icons.image, color: colorScheme.primary),
+          title: const Text('Max Quality Cover'),
+          subtitle: const Text('Download highest resolution cover art'),
+          value: settings.maxQualityCover,
+          onChanged: (value) => ref.read(settingsProvider.notifier).setMaxQualityCover(value),
+        ),
+        
+        const Divider(),
+
+        // About
+        ListTile(
+          leading: Icon(Icons.info, color: colorScheme.primary),
+          title: const Text('About'),
+          subtitle: const Text('SpotiFLAC v1.0.0'),
+          onTap: () => showAboutDialog(
+            context: context,
+            applicationName: 'SpotiFLAC',
+            applicationVersion: '1.0.0',
+            applicationLegalese: '© 2024 SpotiFLAC',
+          ),
+        ),
+        
+        // Bottom padding for navigation bar
+        const SizedBox(height: 16),
+      ],
+    );
+  }
+
+  Widget _buildSectionHeader(BuildContext context, String title, ColorScheme colorScheme) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(16, 16, 16, 8),
+      child: Text(
+        title,
+        style: Theme.of(context).textTheme.titleSmall?.copyWith(
+          color: colorScheme.primary,
+          fontWeight: FontWeight.bold,
+        ),
+      ),
+    );
+  }
+
+  Widget _buildThemePreview(BuildContext context, ColorScheme colorScheme) {
+    return Padding(
+      padding: const EdgeInsets.all(16),
+      child: Card(
+        child: Padding(
+          padding: const EdgeInsets.all(16),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text('Theme Preview', style: Theme.of(context).textTheme.titleSmall),
+              const SizedBox(height: 12),
+              Wrap(
+                spacing: 8,
+                runSpacing: 8,
+                children: [
+                  _buildColorChip('Primary', colorScheme.primary, colorScheme.onPrimary),
+                  _buildColorChip('Secondary', colorScheme.secondary, colorScheme.onSecondary),
+                  _buildColorChip('Tertiary', colorScheme.tertiary, colorScheme.onTertiary),
+                  _buildColorChip('Surface', colorScheme.surface, colorScheme.onSurface),
+                ],
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+
+  Widget _buildColorChip(String label, Color background, Color foreground) {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+      decoration: BoxDecoration(color: background, borderRadius: BorderRadius.circular(16)),
+      child: Text(label, style: TextStyle(color: foreground, fontSize: 12)),
+    );
+  }
+
+  String _getThemeModeName(ThemeMode mode) {
+    switch (mode) {
+      case ThemeMode.light: return 'Light';
+      case ThemeMode.dark: return 'Dark';
+      case ThemeMode.system: return 'System';
+    }
+  }
+
+  String _getServiceName(String service) {
+    switch (service) {
+      case 'tidal': return 'Tidal';
+      case 'qobuz': return 'Qobuz';
+      case 'amazon': return 'Amazon Music';
+      default: return service;
+    }
+  }
+
+  String _getQualityName(String quality) {
+    switch (quality) {
+      case 'LOSSLESS': return 'FLAC (Lossless)';
+      case 'HI_RES': return 'Hi-Res FLAC (24-bit)';
+      default: return quality;
+    }
+  }
+
+  void _showThemeModePicker(BuildContext context, WidgetRef ref, ThemeMode current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Theme Mode'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildThemeModeOption(context, ref, ThemeMode.system, 'System', Icons.brightness_auto, current, colorScheme),
+            _buildThemeModeOption(context, ref, ThemeMode.light, 'Light', Icons.light_mode, current, colorScheme),
+            _buildThemeModeOption(context, ref, ThemeMode.dark, 'Dark', Icons.dark_mode, current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildThemeModeOption(BuildContext context, WidgetRef ref, ThemeMode mode, String label, IconData icon, ThemeMode current, ColorScheme colorScheme) {
+    final isSelected = mode == current;
+    return ListTile(
+      leading: Icon(icon, color: isSelected ? colorScheme.primary : null),
+      title: Text(label),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(themeProvider.notifier).setThemeMode(mode);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showColorPicker(BuildContext context, WidgetRef ref, int currentColor) {
+    final colors = [
+      const Color(0xFF1DB954), const Color(0xFF6750A4), const Color(0xFF0061A4),
+      const Color(0xFF006E1C), const Color(0xFFBA1A1A), const Color(0xFF984061),
+      const Color(0xFF7D5260), const Color(0xFF006874), const Color(0xFFFF6F00),
+    ];
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Choose Accent Color'),
+        content: Wrap(
+          spacing: 12,
+          runSpacing: 12,
+          children: colors.map((color) {
+            final isSelected = color.toARGB32() == currentColor;
+            return GestureDetector(
+              onTap: () {
+                ref.read(themeProvider.notifier).setSeedColor(color);
+                Navigator.pop(context);
+              },
+              child: Container(
+                width: 48, height: 48,
+                decoration: BoxDecoration(
+                  color: color, shape: BoxShape.circle,
+                  border: isSelected ? Border.all(color: Theme.of(context).colorScheme.onSurface, width: 3) : null,
+                ),
+                child: isSelected ? const Icon(Icons.check, color: Colors.white) : null,
+              ),
+            );
+          }).toList(),
+        ),
+      ),
+    );
+  }
+
+  void _showServicePicker(BuildContext context, WidgetRef ref, String current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Select Service'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildServiceOption(context, ref, 'tidal', 'Tidal', current, colorScheme),
+            _buildServiceOption(context, ref, 'qobuz', 'Qobuz', current, colorScheme),
+            _buildServiceOption(context, ref, 'amazon', 'Amazon Music', current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildServiceOption(BuildContext context, WidgetRef ref, String value, String label, String current, ColorScheme colorScheme) {
+    final isSelected = value == current;
+    return ListTile(
+      title: Text(label),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(settingsProvider.notifier).setDefaultService(value);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showQualityPicker(BuildContext context, WidgetRef ref, String current) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Select Quality'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            _buildQualityOption(context, ref, 'LOSSLESS', 'FLAC (Lossless)', '16-bit / 44.1kHz', current, colorScheme),
+            _buildQualityOption(context, ref, 'HI_RES', 'Hi-Res FLAC', '24-bit / up to 192kHz', current, colorScheme),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildQualityOption(BuildContext context, WidgetRef ref, String value, String title, String subtitle, String current, ColorScheme colorScheme) {
+    final isSelected = value == current;
+    return ListTile(
+      title: Text(title),
+      subtitle: Text(subtitle),
+      trailing: isSelected ? Icon(Icons.check, color: colorScheme.primary) : null,
+      onTap: () {
+        ref.read(settingsProvider.notifier).setAudioQuality(value);
+        Navigator.pop(context);
+      },
+    );
+  }
+
+  void _showFormatEditor(BuildContext context, WidgetRef ref, String current) {
+    final controller = TextEditingController(text: current);
+    final colorScheme = Theme.of(context).colorScheme;
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Filename Format'),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            TextField(controller: controller, decoration: const InputDecoration(hintText: '{artist} - {title}')),
+            const SizedBox(height: 16),
+            Text('Available placeholders:', style: Theme.of(context).textTheme.labelMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+            const SizedBox(height: 4),
+            Text('{title}, {artist}, {album}, {track}, {year}, {disc}', style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant)),
+          ],
+        ),
+        actions: [
+          TextButton(onPressed: () => Navigator.pop(context), child: const Text('Cancel')),
+          FilledButton(
+            onPressed: () {
+              ref.read(settingsProvider.notifier).setFilenameFormat(controller.text);
+              Navigator.pop(context);
+            },
+            child: const Text('Save'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _pickDirectory(BuildContext context, WidgetRef ref) async {
+    final result = await FilePicker.platform.getDirectoryPath();
+    if (result != null) {
+      ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+    }
+  }
+}

lib/screens/setup_screen.dart

@@ -0,0 +1,549 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:file_picker/file_picker.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:go_router/go_router.dart';
+import 'package:device_info_plus/device_info_plus.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+
+class SetupScreen extends ConsumerStatefulWidget {
+  const SetupScreen({super.key});
+
+  @override
+  ConsumerState<SetupScreen> createState() => _SetupScreenState();
+}
+
+class _SetupScreenState extends ConsumerState<SetupScreen> {
+  int _currentStep = 0;
+  bool _permissionGranted = false;
+  String? _selectedDirectory;
+  bool _isLoading = false;
+  int _androidSdkVersion = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    _initDeviceInfo();
+  }
+
+  Future<void> _initDeviceInfo() async {
+    if (Platform.isAndroid) {
+      final deviceInfo = DeviceInfoPlugin();
+      final androidInfo = await deviceInfo.androidInfo;
+      _androidSdkVersion = androidInfo.version.sdkInt;
+      debugPrint('Android SDK Version: $_androidSdkVersion');
+    }
+    await _checkInitialPermission();
+  }
+
+  Future<void> _checkInitialPermission() async {
+    if (Platform.isIOS) {
+      // iOS doesn't need storage permission - app uses its own Documents directory
+      if (mounted) {
+        setState(() => _permissionGranted = true);
+      }
+    } else if (Platform.isAndroid) {
+      PermissionStatus status;
+      
+      if (_androidSdkVersion >= 33) {
+        status = await Permission.audio.status;
+      } else if (_androidSdkVersion >= 30) {
+        status = await Permission.manageExternalStorage.status;
+      } else {
+        status = await Permission.storage.status;
+      }
+      
+      if (status.isGranted && mounted) {
+        setState(() => _permissionGranted = true);
+      }
+    }
+  }
+
+  Future<void> _requestPermission() async {
+    setState(() => _isLoading = true);
+
+    try {
+      if (Platform.isIOS) {
+        // iOS doesn't need storage permission - app uses its own Documents directory
+        setState(() => _permissionGranted = true);
+      } else if (Platform.isAndroid) {
+        PermissionStatus status;
+        
+        if (_androidSdkVersion >= 33) {
+          status = await Permission.audio.request();
+          if (!status.isGranted) {
+            await Permission.notification.request();
+          }
+        } else if (_androidSdkVersion >= 30) {
+          status = await Permission.manageExternalStorage.request();
+        } else {
+          status = await Permission.storage.request();
+        }
+        
+        if (status.isGranted) {
+          setState(() => _permissionGranted = true);
+        } else if (status.isPermanentlyDenied) {
+          _showPermissionDeniedDialog();
+        } else {
+          if (mounted) {
+            ScaffoldMessenger.of(context).showSnackBar(
+              const SnackBar(
+                content: Text('Permission denied. Please grant permission to continue.'),
+              ),
+            );
+          }
+        }
+      }
+    } catch (e) {
+      debugPrint('Permission error: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Error: $e')),
+        );
+      }
+    } finally {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  void _showPermissionDeniedDialog() {
+    showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: const Text('Permission Required'),
+        content: const Text(
+          'Storage permission is required to save downloaded music files. '
+          'Please grant permission in app settings.',
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: const Text('Cancel'),
+          ),
+          TextButton(
+            onPressed: () {
+              Navigator.pop(context);
+              openAppSettings();
+            },
+            child: const Text('Open Settings'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _selectDirectory() async {
+    setState(() => _isLoading = true);
+
+    try {
+      String? selectedDirectory = await FilePicker.platform.getDirectoryPath(
+        dialogTitle: 'Select Download Folder',
+      );
+
+      if (selectedDirectory != null) {
+        setState(() => _selectedDirectory = selectedDirectory);
+      } else {
+        final defaultDir = await _getDefaultDirectory();
+        if (mounted) {
+          final useDefault = await showDialog<bool>(
+            context: context,
+            builder: (context) => AlertDialog(
+              title: const Text('Use Default Folder?'),
+              content: Text(
+                'No folder selected. Would you like to use the default Music folder?\n\n$defaultDir',
+              ),
+              actions: [
+                TextButton(
+                  onPressed: () => Navigator.pop(context, false),
+                  child: const Text('Cancel'),
+                ),
+                TextButton(
+                  onPressed: () => Navigator.pop(context, true),
+                  child: const Text('Use Default'),
+                ),
+              ],
+            ),
+          );
+
+          if (useDefault == true) {
+            setState(() => _selectedDirectory = defaultDir);
+          }
+        }
+      }
+    } finally {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  Future<String> _getDefaultDirectory() async {
+    if (Platform.isIOS) {
+      // iOS: Use Documents directory (accessible via Files app)
+      final appDir = await getApplicationDocumentsDirectory();
+      final musicDir = Directory('${appDir.path}/SpotiFLAC');
+      try {
+        if (!await musicDir.exists()) {
+          await musicDir.create(recursive: true);
+        }
+        return musicDir.path;
+      } catch (e) {
+        debugPrint('Cannot create SpotiFLAC folder: $e');
+      }
+      return '${appDir.path}/SpotiFLAC';
+    } else if (Platform.isAndroid) {
+      final musicDir = Directory('/storage/emulated/0/Music/SpotiFLAC');
+      try {
+        if (!await musicDir.exists()) {
+          await musicDir.create(recursive: true);
+        }
+        return musicDir.path;
+      } catch (e) {
+        debugPrint('Cannot create Music folder: $e');
+      }
+    }
+    final appDir = await getApplicationDocumentsDirectory();
+    return '${appDir.path}/SpotiFLAC';
+  }
+
+  Future<void> _completeSetup() async {
+    if (_selectedDirectory == null) return;
+
+    setState(() => _isLoading = true);
+
+    try {
+      final dir = Directory(_selectedDirectory!);
+      if (!await dir.exists()) {
+        await dir.create(recursive: true);
+      }
+
+      ref.read(settingsProvider.notifier).setDownloadDirectory(_selectedDirectory!);
+      ref.read(settingsProvider.notifier).setFirstLaunchComplete();
+
+      if (mounted) {
+        context.go('/');
+      }
+    } catch (e) {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Error: $e')),
+        );
+      }
+    } finally {
+      setState(() => _isLoading = false);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    
+    return Scaffold(
+      body: SafeArea(
+        child: SingleChildScrollView(
+          padding: const EdgeInsets.all(24.0),
+          child: ConstrainedBox(
+            constraints: BoxConstraints(
+              minHeight: MediaQuery.of(context).size.height -
+                  MediaQuery.of(context).padding.top -
+                  MediaQuery.of(context).padding.bottom - 48,
+            ),
+            child: Column(
+              mainAxisAlignment: MainAxisAlignment.spaceBetween,
+              children: [
+                // Top section - Logo/Title
+                Column(
+                  children: [
+                    const SizedBox(height: 24),
+                    ClipRRect(
+                      borderRadius: BorderRadius.circular(24),
+                      child: Image.asset(
+                        'assets/images/logo.png',
+                        width: 96,
+                        height: 96,
+                      ),
+                    ),
+                    const SizedBox(height: 12),
+                    Text(
+                      'SpotiFLAC',
+                      style: Theme.of(context).textTheme.headlineMedium?.copyWith(
+                        fontWeight: FontWeight.bold,
+                        color: colorScheme.primary,
+                      ),
+                    ),
+                    const SizedBox(height: 4),
+                    Text(
+                      'Download Spotify tracks in FLAC',
+                      style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                  ],
+                ),
+
+                // Middle section - Steps and Content
+                Column(
+                  children: [
+                    const SizedBox(height: 24),
+                    _buildStepIndicator(colorScheme),
+                    const SizedBox(height: 24),
+                    _currentStep == 0
+                        ? _buildPermissionStep(colorScheme)
+                        : _buildDirectoryStep(colorScheme),
+                  ],
+                ),
+
+                // Bottom section - Navigation Buttons
+                Column(
+                  children: [
+                    const SizedBox(height: 24),
+                    _buildNavigationButtons(colorScheme),
+                    const SizedBox(height: 16),
+                  ],
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  Widget _buildStepIndicator(ColorScheme colorScheme) {
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.center,
+      children: [
+        _buildStepDot(0, 'Permission', colorScheme),
+        Container(
+          width: 40,
+          height: 2,
+          color: _currentStep >= 1 ? colorScheme.primary : colorScheme.surfaceContainerHighest,
+        ),
+        _buildStepDot(1, 'Folder', colorScheme),
+      ],
+    );
+  }
+
+  Widget _buildStepDot(int step, String label, ColorScheme colorScheme) {
+    final isActive = _currentStep >= step;
+    final isCompleted = (step == 0 && _permissionGranted) ||
+        (step == 1 && _selectedDirectory != null);
+
+    return Column(
+      children: [
+        Container(
+          width: 32,
+          height: 32,
+          decoration: BoxDecoration(
+            shape: BoxShape.circle,
+            color: isCompleted
+                ? colorScheme.primary
+                : isActive
+                    ? colorScheme.primaryContainer
+                    : colorScheme.surfaceContainerHighest,
+          ),
+          child: Center(
+            child: isCompleted
+                ? Icon(Icons.check, size: 18, color: colorScheme.onPrimary)
+                : Text(
+                    '${step + 1}',
+                    style: TextStyle(
+                      color: isActive ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+          ),
+        ),
+        const SizedBox(height: 4),
+        Text(
+          label,
+          style: Theme.of(context).textTheme.labelSmall?.copyWith(
+            color: isActive ? colorScheme.onSurface : colorScheme.onSurfaceVariant,
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildPermissionStep(ColorScheme colorScheme) {
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Icon(
+          _permissionGranted ? Icons.check_circle : Icons.folder_open,
+          size: 56,
+          color: _permissionGranted ? colorScheme.primary : colorScheme.onSurfaceVariant,
+        ),
+        const SizedBox(height: 16),
+        Text(
+          _permissionGranted
+              ? 'Storage Permission Granted!'
+              : 'Storage Permission Required',
+          style: Theme.of(context).textTheme.titleMedium?.copyWith(
+            fontWeight: FontWeight.bold,
+          ),
+          textAlign: TextAlign.center,
+        ),
+        const SizedBox(height: 8),
+        Text(
+          _permissionGranted
+              ? 'You can now select where to save your music files.'
+              : 'SpotiFLAC needs storage access to save downloaded music files to your device.',
+          style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+            color: colorScheme.onSurfaceVariant,
+          ),
+          textAlign: TextAlign.center,
+        ),
+        const SizedBox(height: 20),
+        if (!_permissionGranted)
+          FilledButton.icon(
+            onPressed: _isLoading ? null : _requestPermission,
+            icon: _isLoading
+                ? SizedBox(
+                    width: 20,
+                    height: 20,
+                    child: CircularProgressIndicator(
+                      strokeWidth: 2,
+                      color: colorScheme.onPrimary,
+                    ),
+                  )
+                : const Icon(Icons.security),
+            label: const Text('Grant Permission'),
+            style: FilledButton.styleFrom(
+              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+            ),
+          ),
+      ],
+    );
+  }
+
+  Widget _buildDirectoryStep(ColorScheme colorScheme) {
+    return Column(
+      mainAxisAlignment: MainAxisAlignment.center,
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        Icon(
+          _selectedDirectory != null ? Icons.folder : Icons.create_new_folder,
+          size: 56,
+          color: _selectedDirectory != null ? colorScheme.primary : colorScheme.onSurfaceVariant,
+        ),
+        const SizedBox(height: 16),
+        Text(
+          _selectedDirectory != null
+              ? 'Download Folder Selected!'
+              : 'Choose Download Folder',
+          style: Theme.of(context).textTheme.titleMedium?.copyWith(
+            fontWeight: FontWeight.bold,
+          ),
+          textAlign: TextAlign.center,
+        ),
+        const SizedBox(height: 8),
+        if (_selectedDirectory != null)
+          Container(
+            padding: const EdgeInsets.all(12),
+            decoration: BoxDecoration(
+              color: colorScheme.surfaceContainerHighest,
+              borderRadius: BorderRadius.circular(12),
+            ),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                Icon(Icons.folder, color: colorScheme.primary, size: 20),
+                const SizedBox(width: 8),
+                Flexible(
+                  child: Text(
+                    _selectedDirectory!,
+                    style: Theme.of(context).textTheme.bodySmall,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                ),
+              ],
+            ),
+          )
+        else
+          Text(
+            'Select a folder where your downloaded music will be saved.',
+            style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+            textAlign: TextAlign.center,
+          ),
+        const SizedBox(height: 20),
+        FilledButton.icon(
+          onPressed: _isLoading ? null : _selectDirectory,
+          icon: _isLoading
+              ? SizedBox(
+                  width: 20,
+                  height: 20,
+                  child: CircularProgressIndicator(
+                    strokeWidth: 2,
+                    color: colorScheme.onPrimary,
+                  ),
+                )
+              : Icon(_selectedDirectory != null ? Icons.edit : Icons.folder_open),
+          label: Text(_selectedDirectory != null ? 'Change Folder' : 'Select Folder'),
+          style: FilledButton.styleFrom(
+            padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildNavigationButtons(ColorScheme colorScheme) {
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+      children: [
+        // Back button
+        if (_currentStep > 0)
+          TextButton.icon(
+            onPressed: () => setState(() => _currentStep--),
+            icon: const Icon(Icons.arrow_back),
+            label: const Text('Back'),
+          )
+        else
+          const SizedBox(width: 100),
+
+        // Next/Finish button
+        if (_currentStep == 0)
+          FilledButton(
+            onPressed: _permissionGranted
+                ? () => setState(() => _currentStep++)
+                : null,
+            child: const Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                Text('Next'),
+                SizedBox(width: 8),
+                Icon(Icons.arrow_forward, size: 18),
+              ],
+            ),
+          )
+        else
+          FilledButton(
+            onPressed: _selectedDirectory != null && !_isLoading
+                ? _completeSetup
+                : null,
+            child: _isLoading
+                ? SizedBox(
+                    width: 20,
+                    height: 20,
+                    child: CircularProgressIndicator(
+                      strokeWidth: 2, 
+                      color: colorScheme.onPrimary,
+                    ),
+                  )
+                : const Row(
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      Text('Get Started'),
+                      SizedBox(width: 8),
+                      Icon(Icons.check, size: 18),
+                    ],
+                  ),
+          ),
+      ],
+    );
+  }
+}

lib/services/ffmpeg_service.dart

@@ -0,0 +1,122 @@
+import 'dart:io';
+import 'package:ffmpeg_kit_flutter_new/ffmpeg_kit.dart';
+import 'package:ffmpeg_kit_flutter_new/return_code.dart';
+
+/// FFmpeg service for audio conversion and remuxing
+class FFmpegService {
+  /// Convert M4A (DASH segments) to FLAC
+  /// Returns the output file path on success, null on failure
+  static Future<String?> convertM4aToFlac(String inputPath) async {
+    final outputPath = inputPath.replaceAll('.m4a', '.flac');
+
+    // FFmpeg command to remux M4A to FLAC
+    final command =
+        '-i "$inputPath" -c:a flac -compression_level 8 "$outputPath" -y';
+
+    final session = await FFmpegKit.execute(command);
+    final returnCode = await session.getReturnCode();
+
+    if (ReturnCode.isSuccess(returnCode)) {
+      // Delete original M4A file
+      try {
+        await File(inputPath).delete();
+      } catch (_) {}
+      return outputPath;
+    }
+
+    // Log error for debugging
+    final logs = await session.getLogs();
+    for (final log in logs) {
+      print('[FFmpeg] ${log.getMessage()}');
+    }
+
+    return null;
+  }
+
+  /// Convert FLAC to MP3
+  static Future<String?> convertFlacToMp3(
+    String inputPath, {
+    String bitrate = '320k',
+  }) async {
+    final dir = File(inputPath).parent.path;
+    final baseName =
+        inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
+    final outputDir = '$dir${Platform.pathSeparator}MP3';
+
+    // Create output directory
+    await Directory(outputDir).create(recursive: true);
+
+    final outputPath = '$outputDir${Platform.pathSeparator}$baseName.mp3';
+
+    final command =
+        '-i "$inputPath" -codec:a libmp3lame -b:a $bitrate -map 0:a -map_metadata 0 -id3v2_version 3 "$outputPath" -y';
+
+    final session = await FFmpegKit.execute(command);
+    final returnCode = await session.getReturnCode();
+
+    if (ReturnCode.isSuccess(returnCode)) {
+      return outputPath;
+    }
+
+    return null;
+  }
+
+  /// Convert FLAC to M4A (AAC or ALAC)
+  static Future<String?> convertFlacToM4a(
+    String inputPath, {
+    String codec = 'aac',
+    String bitrate = '256k',
+  }) async {
+    final dir = File(inputPath).parent.path;
+    final baseName =
+        inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
+    final outputDir = '$dir${Platform.pathSeparator}M4A';
+
+    // Create output directory
+    await Directory(outputDir).create(recursive: true);
+
+    final outputPath = '$outputDir${Platform.pathSeparator}$baseName.m4a';
+
+    String command;
+    if (codec == 'alac') {
+      // ALAC - lossless
+      command =
+          '-i "$inputPath" -codec:a alac -map 0:a -map_metadata 0 "$outputPath" -y';
+    } else {
+      // AAC - lossy
+      command =
+          '-i "$inputPath" -codec:a aac -b:a $bitrate -map 0:a -map_metadata 0 "$outputPath" -y';
+    }
+
+    final session = await FFmpegKit.execute(command);
+    final returnCode = await session.getReturnCode();
+
+    if (ReturnCode.isSuccess(returnCode)) {
+      return outputPath;
+    }
+
+    return null;
+  }
+
+  /// Check if FFmpeg is available
+  static Future<bool> isAvailable() async {
+    try {
+      final session = await FFmpegKit.execute('-version');
+      final returnCode = await session.getReturnCode();
+      return ReturnCode.isSuccess(returnCode);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /// Get FFmpeg version info
+  static Future<String?> getVersion() async {
+    try {
+      final session = await FFmpegKit.execute('-version');
+      final output = await session.getOutput();
+      return output;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/services/platform_bridge.dart

@@ -0,0 +1,198 @@
+import 'dart:convert';
+import 'package:flutter/services.dart';
+
+/// Bridge to communicate with Go backend via platform channels
+class PlatformBridge {
+  static const _channel = MethodChannel('com.zarz.spotiflac/backend');
+
+  /// Parse and validate Spotify URL
+  static Future<Map<String, dynamic>> parseSpotifyUrl(String url) async {
+    final result = await _channel.invokeMethod('parseSpotifyUrl', {'url': url});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Get Spotify metadata from URL
+  static Future<Map<String, dynamic>> getSpotifyMetadata(String url) async {
+    final result = await _channel.invokeMethod('getSpotifyMetadata', {'url': url});
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Search Spotify
+  static Future<Map<String, dynamic>> searchSpotify(String query, {int limit = 10}) async {
+    final result = await _channel.invokeMethod('searchSpotify', {
+      'query': query,
+      'limit': limit,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Check track availability on streaming services
+  static Future<Map<String, dynamic>> checkAvailability(String spotifyId, String isrc) async {
+    final result = await _channel.invokeMethod('checkAvailability', {
+      'spotify_id': spotifyId,
+      'isrc': isrc,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Download a track from specific service
+  static Future<Map<String, dynamic>> downloadTrack({
+    required String isrc,
+    required String service,
+    required String spotifyId,
+    required String trackName,
+    required String artistName,
+    required String albumName,
+    String? albumArtist,
+    String? coverUrl,
+    required String outputDir,
+    required String filenameFormat,
+    bool embedLyrics = true,
+    bool embedMaxQualityCover = true,
+    int trackNumber = 1,
+    int discNumber = 1,
+    int totalTracks = 1,
+    String? releaseDate,
+  }) async {
+    final request = jsonEncode({
+      'isrc': isrc,
+      'service': service,
+      'spotify_id': spotifyId,
+      'track_name': trackName,
+      'artist_name': artistName,
+      'album_name': albumName,
+      'album_artist': albumArtist ?? artistName,
+      'cover_url': coverUrl,
+      'output_dir': outputDir,
+      'filename_format': filenameFormat,
+      'embed_lyrics': embedLyrics,
+      'embed_max_quality_cover': embedMaxQualityCover,
+      'track_number': trackNumber,
+      'disc_number': discNumber,
+      'total_tracks': totalTracks,
+      'release_date': releaseDate ?? '',
+    });
+    
+    final result = await _channel.invokeMethod('downloadTrack', request);
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Download with automatic fallback to other services
+  static Future<Map<String, dynamic>> downloadWithFallback({
+    required String isrc,
+    required String spotifyId,
+    required String trackName,
+    required String artistName,
+    required String albumName,
+    String? albumArtist,
+    String? coverUrl,
+    required String outputDir,
+    required String filenameFormat,
+    bool embedLyrics = true,
+    bool embedMaxQualityCover = true,
+    int trackNumber = 1,
+    int discNumber = 1,
+    int totalTracks = 1,
+    String? releaseDate,
+    String preferredService = 'tidal',
+  }) async {
+    final request = jsonEncode({
+      'isrc': isrc,
+      'service': preferredService,
+      'spotify_id': spotifyId,
+      'track_name': trackName,
+      'artist_name': artistName,
+      'album_name': albumName,
+      'album_artist': albumArtist ?? artistName,
+      'cover_url': coverUrl,
+      'output_dir': outputDir,
+      'filename_format': filenameFormat,
+      'embed_lyrics': embedLyrics,
+      'embed_max_quality_cover': embedMaxQualityCover,
+      'track_number': trackNumber,
+      'disc_number': discNumber,
+      'total_tracks': totalTracks,
+      'release_date': releaseDate ?? '',
+    });
+    
+    final result = await _channel.invokeMethod('downloadWithFallback', request);
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Get download progress
+  static Future<Map<String, dynamic>> getDownloadProgress() async {
+    final result = await _channel.invokeMethod('getDownloadProgress');
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Set download directory
+  static Future<void> setDownloadDirectory(String path) async {
+    await _channel.invokeMethod('setDownloadDirectory', {'path': path});
+  }
+
+  /// Check if file with ISRC already exists
+  static Future<Map<String, dynamic>> checkDuplicate(String outputDir, String isrc) async {
+    final result = await _channel.invokeMethod('checkDuplicate', {
+      'output_dir': outputDir,
+      'isrc': isrc,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Build filename from template
+  static Future<String> buildFilename(String template, Map<String, dynamic> metadata) async {
+    final result = await _channel.invokeMethod('buildFilename', {
+      'template': template,
+      'metadata': jsonEncode(metadata),
+    });
+    return result as String;
+  }
+
+  /// Sanitize filename
+  static Future<String> sanitizeFilename(String filename) async {
+    final result = await _channel.invokeMethod('sanitizeFilename', {
+      'filename': filename,
+    });
+    return result as String;
+  }
+
+  /// Fetch lyrics for a track
+  static Future<Map<String, dynamic>> fetchLyrics(
+    String spotifyId,
+    String trackName,
+    String artistName,
+  ) async {
+    final result = await _channel.invokeMethod('fetchLyrics', {
+      'spotify_id': spotifyId,
+      'track_name': trackName,
+      'artist_name': artistName,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+
+  /// Get lyrics in LRC format
+  static Future<String> getLyricsLRC(
+    String spotifyId,
+    String trackName,
+    String artistName,
+  ) async {
+    final result = await _channel.invokeMethod('getLyricsLRC', {
+      'spotify_id': spotifyId,
+      'track_name': trackName,
+      'artist_name': artistName,
+    });
+    return result as String;
+  }
+
+  /// Embed lyrics into an existing FLAC file
+  static Future<Map<String, dynamic>> embedLyricsToFile(
+    String filePath,
+    String lyrics,
+  ) async {
+    final result = await _channel.invokeMethod('embedLyricsToFile', {
+      'file_path': filePath,
+      'lyrics': lyrics,
+    });
+    return jsonDecode(result as String) as Map<String, dynamic>;
+  }
+}

lib/theme/app_theme.dart

@@ -0,0 +1,237 @@
+import 'package:flutter/material.dart';
+import 'package:spotiflac_android/models/theme_settings.dart';
+
+/// App theme configuration for Material Expressive 3
+class AppTheme {
+  /// Default seed color (Spotify green)
+  static const Color defaultSeedColor = Color(kDefaultSeedColor);
+
+  /// Create light theme
+  static ThemeData light({
+    ColorScheme? dynamicScheme,
+    Color? seedColor,
+  }) {
+    final scheme = dynamicScheme ??
+        ColorScheme.fromSeed(
+          seedColor: seedColor ?? defaultSeedColor,
+          brightness: Brightness.light,
+        );
+
+    return ThemeData(
+      useMaterial3: true,
+      colorScheme: scheme,
+      appBarTheme: _appBarTheme(scheme),
+      cardTheme: _cardTheme(scheme),
+      elevatedButtonTheme: _elevatedButtonTheme(scheme),
+      filledButtonTheme: _filledButtonTheme(scheme),
+      outlinedButtonTheme: _outlinedButtonTheme(scheme),
+      textButtonTheme: _textButtonTheme(scheme),
+      floatingActionButtonTheme: _fabTheme(scheme),
+      inputDecorationTheme: _inputDecorationTheme(scheme),
+      listTileTheme: _listTileTheme(scheme),
+      dialogTheme: _dialogTheme(scheme),
+      navigationBarTheme: _navigationBarTheme(scheme),
+      snackBarTheme: _snackBarTheme(scheme),
+      progressIndicatorTheme: _progressIndicatorTheme(scheme),
+      switchTheme: _switchTheme(scheme),
+      chipTheme: _chipTheme(scheme),
+      dividerTheme: _dividerTheme(scheme),
+    );
+  }
+
+  /// Create dark theme
+  static ThemeData dark({
+    ColorScheme? dynamicScheme,
+    Color? seedColor,
+  }) {
+    final scheme = dynamicScheme ??
+        ColorScheme.fromSeed(
+          seedColor: seedColor ?? defaultSeedColor,
+          brightness: Brightness.dark,
+        );
+
+    return ThemeData(
+      useMaterial3: true,
+      colorScheme: scheme,
+      appBarTheme: _appBarTheme(scheme),
+      cardTheme: _cardTheme(scheme),
+      elevatedButtonTheme: _elevatedButtonTheme(scheme),
+      filledButtonTheme: _filledButtonTheme(scheme),
+      outlinedButtonTheme: _outlinedButtonTheme(scheme),
+      textButtonTheme: _textButtonTheme(scheme),
+      floatingActionButtonTheme: _fabTheme(scheme),
+      inputDecorationTheme: _inputDecorationTheme(scheme),
+      listTileTheme: _listTileTheme(scheme),
+      dialogTheme: _dialogTheme(scheme),
+      navigationBarTheme: _navigationBarTheme(scheme),
+      snackBarTheme: _snackBarTheme(scheme),
+      progressIndicatorTheme: _progressIndicatorTheme(scheme),
+      switchTheme: _switchTheme(scheme),
+      chipTheme: _chipTheme(scheme),
+      dividerTheme: _dividerTheme(scheme),
+    );
+  }
+
+  /// AppBar theme
+  static AppBarTheme _appBarTheme(ColorScheme scheme) => AppBarTheme(
+        elevation: 0,
+        scrolledUnderElevation: 3,
+        backgroundColor: scheme.surface,
+        foregroundColor: scheme.onSurface,
+        surfaceTintColor: scheme.surfaceTint,
+        centerTitle: true,
+        titleTextStyle: TextStyle(
+          color: scheme.onSurface,
+          fontSize: 22,
+          fontWeight: FontWeight.w500,
+        ),
+      );
+
+  /// Card theme
+  static CardThemeData _cardTheme(ColorScheme scheme) => CardThemeData(
+        elevation: 0,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
+        color: scheme.surfaceContainerLow,
+        surfaceTintColor: scheme.surfaceTint,
+      );
+
+  /// Elevated button theme
+  static ElevatedButtonThemeData _elevatedButtonTheme(ColorScheme scheme) =>
+      ElevatedButtonThemeData(
+        style: ElevatedButton.styleFrom(
+          elevation: 1,
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+          padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+        ),
+      );
+
+  /// Filled button theme
+  static FilledButtonThemeData _filledButtonTheme(ColorScheme scheme) =>
+      FilledButtonThemeData(
+        style: FilledButton.styleFrom(
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+          padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+        ),
+      );
+
+  /// Outlined button theme
+  static OutlinedButtonThemeData _outlinedButtonTheme(ColorScheme scheme) =>
+      OutlinedButtonThemeData(
+        style: OutlinedButton.styleFrom(
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+          padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+        ),
+      );
+
+  /// Text button theme
+  static TextButtonThemeData _textButtonTheme(ColorScheme scheme) =>
+      TextButtonThemeData(
+        style: TextButton.styleFrom(
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+        ),
+      );
+
+  /// FAB theme
+  static FloatingActionButtonThemeData _fabTheme(ColorScheme scheme) =>
+      FloatingActionButtonThemeData(
+        elevation: 3,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+        backgroundColor: scheme.primaryContainer,
+        foregroundColor: scheme.onPrimaryContainer,
+      );
+
+  /// Input decoration theme
+  static InputDecorationTheme _inputDecorationTheme(ColorScheme scheme) =>
+      InputDecorationTheme(
+        filled: true,
+        fillColor: scheme.surfaceContainerHighest,
+        border: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide.none,
+        ),
+        enabledBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide.none,
+        ),
+        focusedBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide(color: scheme.primary, width: 2),
+        ),
+        errorBorder: OutlineInputBorder(
+          borderRadius: BorderRadius.circular(12),
+          borderSide: BorderSide(color: scheme.error, width: 1),
+        ),
+        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 16),
+      );
+
+  /// List tile theme
+  static ListTileThemeData _listTileTheme(ColorScheme scheme) => ListTileThemeData(
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
+        contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+      );
+
+  /// Dialog theme
+  static DialogThemeData _dialogTheme(ColorScheme scheme) => DialogThemeData(
+        elevation: 6,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(28)),
+        backgroundColor: scheme.surfaceContainerHigh,
+        surfaceTintColor: scheme.surfaceTint,
+      );
+
+  /// Navigation bar theme
+  static NavigationBarThemeData _navigationBarTheme(ColorScheme scheme) =>
+      NavigationBarThemeData(
+        elevation: 0,
+        backgroundColor: scheme.surfaceContainer,
+        indicatorColor: scheme.secondaryContainer,
+        surfaceTintColor: scheme.surfaceTint,
+        labelBehavior: NavigationDestinationLabelBehavior.alwaysShow,
+      );
+
+  /// SnackBar theme
+  static SnackBarThemeData _snackBarTheme(ColorScheme scheme) => SnackBarThemeData(
+        behavior: SnackBarBehavior.floating,
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+        backgroundColor: scheme.inverseSurface,
+        contentTextStyle: TextStyle(color: scheme.onInverseSurface),
+      );
+
+  /// Progress indicator theme
+  static ProgressIndicatorThemeData _progressIndicatorTheme(ColorScheme scheme) =>
+      ProgressIndicatorThemeData(
+        color: scheme.primary,
+        linearTrackColor: scheme.surfaceContainerHighest,
+        circularTrackColor: scheme.surfaceContainerHighest,
+      );
+
+  /// Switch theme
+  static SwitchThemeData _switchTheme(ColorScheme scheme) => SwitchThemeData(
+        thumbColor: WidgetStateProperty.resolveWith((states) {
+          if (states.contains(WidgetState.selected)) {
+            return scheme.onPrimary;
+          }
+          return scheme.outline;
+        }),
+        trackColor: WidgetStateProperty.resolveWith((states) {
+          if (states.contains(WidgetState.selected)) {
+            return scheme.primary;
+          }
+          return scheme.surfaceContainerHighest;
+        }),
+      );
+
+  /// Chip theme
+  static ChipThemeData _chipTheme(ColorScheme scheme) => ChipThemeData(
+        shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(8)),
+        backgroundColor: scheme.surfaceContainerLow,
+        selectedColor: scheme.secondaryContainer,
+      );
+
+  /// Divider theme
+  static DividerThemeData _dividerTheme(ColorScheme scheme) => DividerThemeData(
+        color: scheme.outlineVariant,
+        thickness: 1,
+        space: 1,
+      );
+}

lib/theme/dynamic_color_wrapper.dart

@@ -0,0 +1,53 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:dynamic_color/dynamic_color.dart';
+import 'package:spotiflac_android/providers/theme_provider.dart';
+import 'package:spotiflac_android/theme/app_theme.dart';
+
+/// Wrapper widget that provides dynamic color support from device wallpaper
+class DynamicColorWrapper extends ConsumerWidget {
+  final Widget Function(ThemeData light, ThemeData dark, ThemeMode mode) builder;
+
+  const DynamicColorWrapper({
+    super.key,
+    required this.builder,
+  });
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final themeSettings = ref.watch(themeProvider);
+
+    return DynamicColorBuilder(
+      builder: (ColorScheme? lightDynamic, ColorScheme? darkDynamic) {
+        // Determine which color scheme to use
+        ColorScheme lightScheme;
+        ColorScheme darkScheme;
+
+        if (themeSettings.useDynamicColor && lightDynamic != null && darkDynamic != null) {
+          // Use dynamic colors from wallpaper (Android 12+)
+          lightScheme = lightDynamic;
+          darkScheme = darkDynamic;
+          debugPrint('Using dynamic color from wallpaper');
+        } else {
+          // Fallback to seed color
+          final seedColor = themeSettings.seedColor;
+          lightScheme = ColorScheme.fromSeed(
+            seedColor: seedColor,
+            brightness: Brightness.light,
+          );
+          darkScheme = ColorScheme.fromSeed(
+            seedColor: seedColor,
+            brightness: Brightness.dark,
+          );
+          debugPrint('Using fallback seed color: ${seedColor.toARGB32().toRadixString(16)}');
+        }
+
+        // Build themes
+        final lightTheme = AppTheme.light(dynamicScheme: lightScheme);
+        final darkTheme = AppTheme.dark(dynamicScheme: darkScheme);
+
+        return builder(lightTheme, darkTheme, themeSettings.themeMode);
+      },
+    );
+  }
+}