feat: Implement Xtream API data models and live TV tab for IPTV functionality, including application icons.

lib/features/iptv/providers/settings_provider.dart

@@ -1,43 +1,173 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
+/// Streaming quality presets for Live TV
+enum StreamQuality {
+  low,    // 1.5 Mbps, CRF 26
+  medium, // 3 Mbps, CRF 23
+  high,   // 5 Mbps, CRF 20
+}
+
+/// Buffer size presets for Live TV
+enum BufferSize {
+  low,    // 2s segments, 4MB buffer
+  medium, // 4s segments, 8MB buffer
+  high,   // 6s segments, 12MB buffer
+}
+
+/// Connection timeout presets
+enum ConnectionTimeout {
+  short,  // 15 seconds
+  medium, // 30 seconds
+  long,   // 60 seconds
+}
+
+/// EPG cache duration presets
+enum EpgCacheDuration {
+  short,  // 5 minutes
+  medium, // 15 minutes
+  long,   // 60 minutes
+}
+
+/// Transcoding mode for Live TV
+enum TranscodingMode {
+  auto,     // Auto-detect best mode
+  forced,   // Always transcode
+  disabled, // Direct stream (no transcoding)
+}
+
 /// Keys for SharedPreferences storage
 class _SettingsKeys {
+  // Filters
   static const String liveTvFilter = 'filter_live_tv';
   static const String moviesFilter = 'filter_movies';
   static const String seriesFilter = 'filter_series';
+  
+  // Streaming settings
+  static const String streamQuality = 'stream_quality';
+  static const String bufferSize = 'buffer_size';
+  static const String connectionTimeout = 'connection_timeout';
+  static const String autoReconnect = 'auto_reconnect';
+  static const String epgCacheDuration = 'epg_cache_duration';
+  static const String transcodingMode = 'transcoding_mode';
+  static const String preferDirectPlay = 'prefer_direct_play';
 }
 
 /// Settings state for IPTV preferences with persistence
 class IptvSettings {
-  /// Category filter keywords for Live TV (comma-separated)
+  // Category filters
   final String liveTvCategoryFilter;
-  
-  /// Category filter keywords for Movies (comma-separated)
   final String moviesCategoryFilter;
-  
-  /// Category filter keywords for Series (comma-separated)
   final String seriesCategoryFilter;
 
+  // Streaming settings (Live TV only)
+  final StreamQuality streamQuality;
+  final BufferSize bufferSize;
+  final ConnectionTimeout connectionTimeout;
+  final bool autoReconnect;
+  final EpgCacheDuration epgCacheDuration;
+  final TranscodingMode transcodingMode;
+  final bool preferDirectPlay;
+
   const IptvSettings({
+    // Filters
     this.liveTvCategoryFilter = '',
     this.moviesCategoryFilter = '',
     this.seriesCategoryFilter = '',
+    // Streaming defaults
+    this.streamQuality = StreamQuality.medium,
+    this.bufferSize = BufferSize.medium,
+    this.connectionTimeout = ConnectionTimeout.medium,
+    this.autoReconnect = true,
+    this.epgCacheDuration = EpgCacheDuration.medium,
+    this.transcodingMode = TranscodingMode.auto,
+    this.preferDirectPlay = false,
   });
 
   IptvSettings copyWith({
     String? liveTvCategoryFilter,
     String? moviesCategoryFilter,
     String? seriesCategoryFilter,
+    StreamQuality? streamQuality,
+    BufferSize? bufferSize,
+    ConnectionTimeout? connectionTimeout,
+    bool? autoReconnect,
+    EpgCacheDuration? epgCacheDuration,
+    TranscodingMode? transcodingMode,
+    bool? preferDirectPlay,
   }) {
     return IptvSettings(
       liveTvCategoryFilter: liveTvCategoryFilter ?? this.liveTvCategoryFilter,
       moviesCategoryFilter: moviesCategoryFilter ?? this.moviesCategoryFilter,
       seriesCategoryFilter: seriesCategoryFilter ?? this.seriesCategoryFilter,
+      streamQuality: streamQuality ?? this.streamQuality,
+      bufferSize: bufferSize ?? this.bufferSize,
+      connectionTimeout: connectionTimeout ?? this.connectionTimeout,
+      autoReconnect: autoReconnect ?? this.autoReconnect,
+      epgCacheDuration: epgCacheDuration ?? this.epgCacheDuration,
+      transcodingMode: transcodingMode ?? this.transcodingMode,
+      preferDirectPlay: preferDirectPlay ?? this.preferDirectPlay,
     );
   }
 
-  /// Get list of filter keywords for a given filter string
+  // ===== Streaming Value Getters =====
+
+  /// Get bitrate in kbps based on quality setting
+  int get bitrateKbps {
+    switch (streamQuality) {
+      case StreamQuality.low: return 1500;
+      case StreamQuality.medium: return 3000;
+      case StreamQuality.high: return 5000;
+    }
+  }
+
+  /// Get CRF value based on quality setting
+  int get crfValue {
+    switch (streamQuality) {
+      case StreamQuality.low: return 26;
+      case StreamQuality.medium: return 23;
+      case StreamQuality.high: return 20;
+    }
+  }
+
+  /// Get HLS segment duration in seconds
+  int get hlsSegmentDuration {
+    switch (bufferSize) {
+      case BufferSize.low: return 2;
+      case BufferSize.medium: return 4;
+      case BufferSize.high: return 6;
+    }
+  }
+
+  /// Get buffer size in KB
+  int get bufferSizeKb {
+    switch (bufferSize) {
+      case BufferSize.low: return 4000;
+      case BufferSize.medium: return 8000;
+      case BufferSize.high: return 12000;
+    }
+  }
+
+  /// Get connection timeout in seconds
+  int get timeoutSeconds {
+    switch (connectionTimeout) {
+      case ConnectionTimeout.short: return 15;
+      case ConnectionTimeout.medium: return 30;
+      case ConnectionTimeout.long: return 60;
+    }
+  }
+
+  /// Get EPG cache duration in minutes
+  int get epgCacheMinutes {
+    switch (epgCacheDuration) {
+      case EpgCacheDuration.short: return 5;
+      case EpgCacheDuration.medium: return 15;
+      case EpgCacheDuration.long: return 60;
+    }
+  }
+
+  // ===== Filter Methods =====
+
   static List<String> _parseKeywords(String filter) {
     if (filter.isEmpty) return [];
     return filter
@@ -47,38 +177,28 @@ class IptvSettings {
         .toList();
   }
 
-  /// Get live TV filter keywords
   List<String> get liveTvKeywords => _parseKeywords(liveTvCategoryFilter);
-  
-  /// Get movies filter keywords
   List<String> get moviesKeywords => _parseKeywords(moviesCategoryFilter);
-  
-  /// Get series filter keywords
   List<String> get seriesKeywords => _parseKeywords(seriesCategoryFilter);
 
-  /// Check if a category name matches the Live TV filter
   bool matchesLiveTvFilter(String categoryName) {
     return _matchesFilter(categoryName, liveTvKeywords);
   }
 
-  /// Check if a category name matches the Movies filter
   bool matchesMoviesFilter(String categoryName) {
     return _matchesFilter(categoryName, moviesKeywords);
   }
 
-  /// Check if a category name matches the Series filter
   bool matchesSeriesFilter(String categoryName) {
     return _matchesFilter(categoryName, seriesKeywords);
   }
 
-  /// Generic filter matching
   bool _matchesFilter(String categoryName, List<String> keywords) {
     if (keywords.isEmpty) return true;
     final upperName = categoryName.toUpperCase();
     return keywords.any((keyword) => upperName.contains(keyword));
   }
 
-  /// Legacy method for backwards compatibility
   bool matchesFilter(String categoryName) => matchesLiveTvFilter(categoryName);
 }
 
@@ -98,24 +218,52 @@ class IptvSettingsNotifier extends StateNotifier<IptvSettings> {
     try {
       _prefs = await SharedPreferences.getInstance();
       
+      // Load filters
       final liveTv = _prefs?.getString(_SettingsKeys.liveTvFilter) ?? '';
       final movies = _prefs?.getString(_SettingsKeys.moviesFilter) ?? '';
       final series = _prefs?.getString(_SettingsKeys.seriesFilter) ?? '';
       
+      // Load streaming settings
+      final quality = StreamQuality.values[
+        _prefs?.getInt(_SettingsKeys.streamQuality) ?? StreamQuality.medium.index
+      ];
+      final buffer = BufferSize.values[
+        _prefs?.getInt(_SettingsKeys.bufferSize) ?? BufferSize.medium.index
+      ];
+      final timeout = ConnectionTimeout.values[
+        _prefs?.getInt(_SettingsKeys.connectionTimeout) ?? ConnectionTimeout.medium.index
+      ];
+      final reconnect = _prefs?.getBool(_SettingsKeys.autoReconnect) ?? true;
+      final epgCache = EpgCacheDuration.values[
+        _prefs?.getInt(_SettingsKeys.epgCacheDuration) ?? EpgCacheDuration.medium.index
+      ];
+      final transcoding = TranscodingMode.values[
+        _prefs?.getInt(_SettingsKeys.transcodingMode) ?? TranscodingMode.auto.index
+      ];
+      final directPlay = _prefs?.getBool(_SettingsKeys.preferDirectPlay) ?? false;
+      
       state = IptvSettings(
         liveTvCategoryFilter: liveTv,
         moviesCategoryFilter: movies,
         seriesCategoryFilter: series,
+        streamQuality: quality,
+        bufferSize: buffer,
+        connectionTimeout: timeout,
+        autoReconnect: reconnect,
+        epgCacheDuration: epgCache,
+        transcodingMode: transcoding,
+        preferDirectPlay: directPlay,
       );
       
       _initialized = true;
-      print('Settings loaded: LiveTV="$liveTv", Movies="$movies", Series="$series"');
+      print('Settings loaded: LiveTV="$liveTv", Quality=${quality.name}');
     } catch (e) {
       print('Error loading settings: $e');
     }
   }
 
-  /// Save a setting to SharedPreferences
+  // ===== Save Helpers =====
+
   Future<void> _saveString(String key, String value) async {
     try {
       _prefs ??= await SharedPreferences.getInstance();
@@ -125,41 +273,89 @@ class IptvSettingsNotifier extends StateNotifier<IptvSettings> {
     }
   }
 
-  /// Set Live TV category filter
+  Future<void> _saveInt(String key, int value) async {
+    try {
+      _prefs ??= await SharedPreferences.getInstance();
+      await _prefs?.setInt(key, value);
+    } catch (e) {
+      print('Error saving setting $key: $e');
+    }
+  }
+
+  Future<void> _saveBool(String key, bool value) async {
+    try {
+      _prefs ??= await SharedPreferences.getInstance();
+      await _prefs?.setBool(key, value);
+    } catch (e) {
+      print('Error saving setting $key: $e');
+    }
+  }
+
+  // ===== Filter Setters =====
+
   void setLiveTvFilter(String filter) {
     state = state.copyWith(liveTvCategoryFilter: filter);
     _saveString(_SettingsKeys.liveTvFilter, filter);
   }
 
-  /// Set Movies category filter
   void setMoviesFilter(String filter) {
     state = state.copyWith(moviesCategoryFilter: filter);
     _saveString(_SettingsKeys.moviesFilter, filter);
   }
 
-  /// Set Series category filter
   void setSeriesFilter(String filter) {
     state = state.copyWith(seriesCategoryFilter: filter);
     _saveString(_SettingsKeys.seriesFilter, filter);
   }
 
-  /// Clear Live TV filter
   void clearLiveTvFilter() => setLiveTvFilter('');
-  
-  /// Clear Movies filter
   void clearMoviesFilter() => setMoviesFilter('');
-  
-  /// Clear Series filter
   void clearSeriesFilter() => setSeriesFilter('');
 
-  /// Clear all filters
   void clearAllFilters() {
     clearLiveTvFilter();
     clearMoviesFilter();
     clearSeriesFilter();
   }
 
-  // Legacy methods for backwards compatibility
+  // ===== Streaming Setters =====
+
+  void setStreamQuality(StreamQuality quality) {
+    state = state.copyWith(streamQuality: quality);
+    _saveInt(_SettingsKeys.streamQuality, quality.index);
+  }
+
+  void setBufferSize(BufferSize buffer) {
+    state = state.copyWith(bufferSize: buffer);
+    _saveInt(_SettingsKeys.bufferSize, buffer.index);
+  }
+
+  void setConnectionTimeout(ConnectionTimeout timeout) {
+    state = state.copyWith(connectionTimeout: timeout);
+    _saveInt(_SettingsKeys.connectionTimeout, timeout.index);
+  }
+
+  void setAutoReconnect(bool value) {
+    state = state.copyWith(autoReconnect: value);
+    _saveBool(_SettingsKeys.autoReconnect, value);
+  }
+
+  void setEpgCacheDuration(EpgCacheDuration duration) {
+    state = state.copyWith(epgCacheDuration: duration);
+    _saveInt(_SettingsKeys.epgCacheDuration, duration.index);
+  }
+
+  void setTranscodingMode(TranscodingMode mode) {
+    state = state.copyWith(transcodingMode: mode);
+    _saveInt(_SettingsKeys.transcodingMode, mode.index);
+  }
+
+  void setPreferDirectPlay(bool value) {
+    state = state.copyWith(preferDirectPlay: value);
+    _saveBool(_SettingsKeys.preferDirectPlay, value);
+  }
+
+  // Legacy methods
   void setCategoryFilter(String filter) => setLiveTvFilter(filter);
   void clearCategoryFilter() => clearLiveTvFilter();
 }