mirror of
https://github.com/R0m1k3/xtremflow.git
synced 2026-10-21 05:58:05 +02:00
Add download and subtitle services, enhance UI with continue watching and quality selector widgets
- Implemented DownloadService for managing download tasks, including start, pause, resume, and cancel functionalities. - Created SubtitleService for handling subtitle tracks, parsing SRT and WebVTT formats, and downloading subtitles. - Added ContinueWatchingWidget to display user's watch history with progress indicators. - Developed QualitySelectorWidget for selecting video quality during playback, including auto quality adjustment. - Introduced TrendingWidget and RecentlyAddedWidget to showcase trending and recently added content.
This commit is contained in:
GitHub Copilot committed
1 parent
a9a1127d6b
commit
91eb1ce5a0
20 files changed
+6574
-1
No files matched your search
@@ -0,0 +1,318 @@
|
||||
/// Application optimization configuration
|
||||
///
|
||||
/// This file contains performance tuning settings for XtremFlow
|
||||
|
||||
class OptimizationConfig {
|
||||
// ============================================
|
||||
// STREAMING OPTIMIZATION
|
||||
// ============================================
|
||||
|
||||
/// Enable adaptive bitrate streaming
|
||||
static const bool enableAdaptiveBitrate = true;
|
||||
|
||||
/// Default quality profile for new streams
|
||||
static const String defaultQualityResolution = '720x480'; // 480p HD
|
||||
|
||||
/// Maximum buffer size in seconds
|
||||
static const int maxBufferSeconds = 30;
|
||||
|
||||
/// Minimum buffer size in seconds before rebuffering
|
||||
static const int minBufferSeconds = 2;
|
||||
|
||||
/// Target buffer size in seconds
|
||||
static const int targetBufferSeconds = 8;
|
||||
|
||||
/// Enable HLS v3 compression
|
||||
static const bool enableHlsCompression = true;
|
||||
|
||||
/// FFmpeg preset for live transcoding
|
||||
static const String ffmpegLivePreset = 'medium'; // ultrafast, fast, medium, slow
|
||||
|
||||
/// FFmpeg preset for VOD transcoding
|
||||
static const String ffmpegVodPreset = 'medium';
|
||||
|
||||
/// Enable NVIDIA GPU acceleration if available
|
||||
static const bool enableNvidiaGpu = true;
|
||||
|
||||
// ============================================
|
||||
// CACHE OPTIMIZATION
|
||||
// ============================================
|
||||
|
||||
/// Enable aggressive image caching
|
||||
static const bool enableImageCache = true;
|
||||
|
||||
/// Maximum image cache size in MB
|
||||
static const int maxImageCacheMb = 100;
|
||||
|
||||
/// Maximum memory cache size in MB
|
||||
static const int maxMemoryCacheMb = 200;
|
||||
|
||||
/// Cache expiration time in hours
|
||||
static const int cacheExpirationHours = 24;
|
||||
|
||||
/// Enable network cache interceptor
|
||||
static const bool enableNetworkCache = true;
|
||||
|
||||
/// Network cache retention time in days
|
||||
static const int networkCacheRetentionDays = 3;
|
||||
|
||||
// ============================================
|
||||
// UI OPTIMIZATION
|
||||
// ============================================
|
||||
|
||||
/// Number of items to load per page
|
||||
static const int itemsPerPage = 50;
|
||||
|
||||
/// Number of items per page for Live TV grid view
|
||||
static const int liveItemsPerPage = 100;
|
||||
|
||||
/// Enable lazy loading for content lists
|
||||
static const bool enableLazyLoading = true;
|
||||
|
||||
/// Enable image fade animation on load
|
||||
static const bool enableImageFadeAnimation = true;
|
||||
|
||||
/// Image fade animation duration in milliseconds
|
||||
static const int imageFadeAnimationMs = 300;
|
||||
|
||||
/// Enable smooth scrolling
|
||||
static const bool enableSmoothScroll = true;
|
||||
|
||||
/// TextureView pool size for video rendering (Android)
|
||||
static const int videoTexturePoolSize = 4;
|
||||
|
||||
// ============================================
|
||||
// NETWORK OPTIMIZATION
|
||||
// ============================================
|
||||
|
||||
/// Connection timeout in seconds
|
||||
static const int connectionTimeoutSeconds = 30;
|
||||
|
||||
/// Receive timeout in seconds
|
||||
static const int receiveTimeoutSeconds = 60;
|
||||
|
||||
/// Max concurrent downloads
|
||||
static const int maxConcurrentDownloads = 3;
|
||||
|
||||
/// Enable network optimization (bandwidth detection, etc)
|
||||
static const bool enableNetworkOptimization = true;
|
||||
|
||||
/// Enable request retry on failure
|
||||
static const bool enableAutoRetry = true;
|
||||
|
||||
/// Max retry attempts
|
||||
static const int maxRetryAttempts = 3;
|
||||
|
||||
/// Enable gzip compression for API requests
|
||||
static const bool enableGzipCompression = true;
|
||||
|
||||
// ============================================
|
||||
// MEMORY OPTIMIZATION
|
||||
// ============================================
|
||||
|
||||
/// Enable memory profiling on debug builds
|
||||
static const bool enableMemoryProfiling = false;
|
||||
|
||||
/// Collect memory stats every N seconds
|
||||
static const int memoryProfilingIntervalSeconds = 10;
|
||||
|
||||
/// Enable aggressive memory cleanup on app background
|
||||
static const bool enableMemoryCleanupOnBackground = true;
|
||||
|
||||
/// Max number of cached image entries
|
||||
static const int maxCachedImages = 500;
|
||||
|
||||
// ============================================
|
||||
// PERFORMANCE MONITORING
|
||||
// ============================================
|
||||
|
||||
/// Enable performance monitoring
|
||||
static const bool enablePerformanceMonitoring = true;
|
||||
|
||||
/// Monitor frame rate drops
|
||||
static const bool monitorFrameRate = true;
|
||||
|
||||
/// Frame rate warning threshold (FPS)
|
||||
static const int frameRateWarningThreshold = 30;
|
||||
|
||||
/// Enable network metrics collection
|
||||
static const bool collectNetworkMetrics = true;
|
||||
|
||||
/// Enable streaming quality metrics
|
||||
static const bool collectStreamingMetrics = true;
|
||||
|
||||
// ============================================
|
||||
// FEATURE FLAGS
|
||||
// ============================================
|
||||
|
||||
/// Enable EPG (Electronic Program Guide)
|
||||
static const bool enableEpg = true;
|
||||
|
||||
/// Enable offline downloads
|
||||
static const bool enableOfflineDownloads = true;
|
||||
|
||||
/// Enable continue watching feature
|
||||
static const bool enableContinueWatching = true;
|
||||
|
||||
/// Enable trending content
|
||||
static const bool enableTrending = true;
|
||||
|
||||
/// Enable adaptive streaming quality selector
|
||||
static const bool enableQualitySelector = true;
|
||||
|
||||
/// Enable subtitle support
|
||||
static const bool enableSubtitles = true;
|
||||
|
||||
/// Enable watch history tracking
|
||||
static const bool enableWatchHistory = true;
|
||||
|
||||
/// Enable user favorites
|
||||
static const bool enableFavorites = true;
|
||||
|
||||
// ============================================
|
||||
// HELPER METHODS
|
||||
// ============================================
|
||||
|
||||
/// Get optimized image cache settings
|
||||
static Map<String, dynamic> getImageCacheSettings() => {
|
||||
'maxSize': maxImageCacheMb * 1024 * 1024,
|
||||
'maxItems': maxCachedImages,
|
||||
'enableAnimation': enableImageFadeAnimation,
|
||||
'fadeAnimationMs': imageFadeAnimationMs,
|
||||
};
|
||||
|
||||
/// Get streaming configuration
|
||||
static Map<String, dynamic> getStreamingConfig() => {
|
||||
'enableAdaptiveBitrate': enableAdaptiveBitrate,
|
||||
'defaultQuality': defaultQualityResolution,
|
||||
'maxBuffer': maxBufferSeconds,
|
||||
'minBuffer': minBufferSeconds,
|
||||
'targetBuffer': targetBufferSeconds,
|
||||
'enableHlsCompression': enableHlsCompression,
|
||||
'ffmpegPreset': ffmpegLivePreset,
|
||||
'enableGpu': enableNvidiaGpu,
|
||||
};
|
||||
|
||||
/// Get network configuration
|
||||
static Map<String, dynamic> getNetworkConfig() => {
|
||||
'connectTimeout': connectionTimeoutSeconds,
|
||||
'receiveTimeout': receiveTimeoutSeconds,
|
||||
'enableAutoRetry': enableAutoRetry,
|
||||
'maxRetries': maxRetryAttempts,
|
||||
'enableGzip': enableGzipCompression,
|
||||
'enableCache': enableNetworkCache,
|
||||
'cacheRetentionDays': networkCacheRetentionDays,
|
||||
};
|
||||
|
||||
/// Get UI performance settings
|
||||
static Map<String, dynamic> getUiPerformanceSettings() => {
|
||||
'itemsPerPage': itemsPerPage,
|
||||
'liveItemsPerPage': liveItemsPerPage,
|
||||
'enableLazyLoading': enableLazyLoading,
|
||||
'enableSmoothScroll': enableSmoothScroll,
|
||||
'maxTexturePoolSize': videoTexturePoolSize,
|
||||
};
|
||||
|
||||
/// Get memory optimization settings
|
||||
static Map<String, dynamic> getMemoryOptimizationSettings() => {
|
||||
'enableProfiling': enableMemoryProfiling,
|
||||
'profilingInterval': memoryProfilingIntervalSeconds,
|
||||
'aggressiveCleanup': enableMemoryCleanupOnBackground,
|
||||
'maxImageCacheMb': maxImageCacheMb,
|
||||
'maxMemoryCacheMb': maxMemoryCacheMb,
|
||||
};
|
||||
|
||||
/// Get all enabled features
|
||||
static List<String> getEnabledFeatures() => [
|
||||
if (enableEpg) 'EPG',
|
||||
if (enableOfflineDownloads) 'OfflineDownloads',
|
||||
if (enableContinueWatching) 'ContinueWatching',
|
||||
if (enableTrending) 'Trending',
|
||||
if (enableQualitySelector) 'QualitySelector',
|
||||
if (enableSubtitles) 'Subtitles',
|
||||
if (enableWatchHistory) 'WatchHistory',
|
||||
if (enableFavorites) 'Favorites',
|
||||
];
|
||||
|
||||
/// Print configuration summary
|
||||
static void printSummary() {
|
||||
print('''
|
||||
╔════════════════════════════════════════════════════════════╗
|
||||
║ XtremFlow Optimization Configuration ║
|
||||
╠════════════════════════════════════════════════════════════╣
|
||||
║ STREAMING ║
|
||||
║ • Adaptive Bitrate: $enableAdaptiveBitrate ║
|
||||
║ • Default Quality: $defaultQualityResolution ║
|
||||
║ • GPU Acceleration: $enableNvidiaGpu ║
|
||||
║ ║
|
||||
║ CACHE ║
|
||||
║ • Image Cache: ${maxImageCacheMb}MB ║
|
||||
║ • Memory Cache: ${maxMemoryCacheMb}MB ║
|
||||
║ • Network Cache: $enableNetworkCache ║
|
||||
║ ║
|
||||
║ NETWORK ║
|
||||
║ • Connection Timeout: ${connectionTimeoutSeconds}s ║
|
||||
║ • Auto Retry: $enableAutoRetry ║
|
||||
║ • Max Retries: $maxRetryAttempts ║
|
||||
║ ║
|
||||
║ FEATURES ENABLED: ${getEnabledFeatures().join(', ')}║
|
||||
║ ║
|
||||
╚════════════════════════════════════════════════════════════╝
|
||||
''');
|
||||
}
|
||||
}
|
||||
|
||||
/// Runtime optimization flags
|
||||
class RuntimeOptimizations {
|
||||
static bool hasHighPerformanceDevice = false;
|
||||
static bool isLowBatteryMode = false;
|
||||
static bool isLowMemoryMode = false;
|
||||
static int availableMemoryMb = 0;
|
||||
static int availableStorageMb = 0;
|
||||
|
||||
/// Adjust settings based on device capabilities
|
||||
static void calibrateForDevice({
|
||||
required int totalMemoryMb,
|
||||
required int freeMemoryMb,
|
||||
required int storageFreeMb,
|
||||
}) {
|
||||
availableMemoryMb = freeMemoryMb;
|
||||
availableStorageMb = storageFreeMb;
|
||||
|
||||
// Detect low memory condition
|
||||
isLowMemoryMode = freeMemoryMb < 500;
|
||||
|
||||
// Detect low storage
|
||||
if (storageFreeMb < 1000) {
|
||||
print(
|
||||
'[WARNING] Low storage available: ${storageFreeMb}MB. Disabling offline downloads.');
|
||||
}
|
||||
|
||||
// High performance device detection
|
||||
hasHighPerformanceDevice = totalMemoryMb > 4000 && storageFreeMb > 5000;
|
||||
|
||||
print('[Device Calibration] Memory: ${freeMemoryMb}MB, Storage: ${storageFreeMb}MB');
|
||||
}
|
||||
|
||||
/// Get dynamic cache size based on available memory
|
||||
static int getDynamicCacheSize() {
|
||||
if (isLowMemoryMode) {
|
||||
return 50; // 50MB on low memory devices
|
||||
}
|
||||
if (hasHighPerformanceDevice) {
|
||||
return 200; // 200MB on high performance devices
|
||||
}
|
||||
return OptimizationConfig.maxMemoryCacheMb;
|
||||
}
|
||||
|
||||
/// Get dynamic image cache size
|
||||
static int getDynamicImageCacheSize() {
|
||||
if (isLowMemoryMode) {
|
||||
return 30; // 30MB
|
||||
}
|
||||
if (hasHighPerformanceDevice) {
|
||||
return 150; // 150MB
|
||||
}
|
||||
return OptimizationConfig.maxImageCacheMb;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,345 @@
|
||||
/// Adaptive Bitrate (ABR) Streaming Handler for HLS
|
||||
///
|
||||
/// Supports multi-bitrate HLS playlists for adaptive streaming
|
||||
/// with fallback options for poor network conditions
|
||||
|
||||
import 'dart:async';
|
||||
import 'dart:io';
|
||||
|
||||
/// Represents a video quality level for adaptive bitrate streaming
|
||||
class QualityLevel {
|
||||
final String resolution;
|
||||
final int bitrateBps;
|
||||
final int width;
|
||||
final int height;
|
||||
final String ffmpegPreset; // ultrafast, fast, medium, slow
|
||||
final String label;
|
||||
|
||||
const QualityLevel({
|
||||
required this.resolution,
|
||||
required this.bitrateBps,
|
||||
required this.width,
|
||||
required this.height,
|
||||
this.ffmpegPreset = 'medium',
|
||||
required this.label,
|
||||
});
|
||||
|
||||
/// Get FFmpeg video bitrate argument
|
||||
String get videoBitrateArg => '${(bitrateBps * 0.75).toInt() ~/ 1000}k';
|
||||
|
||||
/// Get FFmpeg maxrate argument (150% of bitrate)
|
||||
String get maxRateArg => '${(bitrateBps * 1.5 ~/ 1000).toInt()}k';
|
||||
|
||||
/// Get FFmpeg buffer size argument
|
||||
String get bufferSizeArg => '${(bitrateBps * 2 ~/ 1000).toInt()}k';
|
||||
|
||||
@override
|
||||
String toString() => '$label ($resolution - ${bitrateBps ~/ 1000000}Mbps)';
|
||||
}
|
||||
|
||||
/// Standard quality profiles for adaptive streaming
|
||||
class QualityProfiles {
|
||||
// Mobile & Low Bandwidth
|
||||
static const mobile240p = QualityLevel(
|
||||
resolution: '426x240',
|
||||
bitrateBps: 500000, // 0.5 Mbps
|
||||
width: 426,
|
||||
height: 240,
|
||||
ffmpegPreset: 'ultrafast',
|
||||
label: '240p (Low)',
|
||||
);
|
||||
|
||||
static const mobile360p = QualityLevel(
|
||||
resolution: '640x360',
|
||||
bitrateBps: 1200000, // 1.2 Mbps
|
||||
width: 640,
|
||||
height: 360,
|
||||
ffmpegPreset: 'ultrafast',
|
||||
label: '360p (Mobile)',
|
||||
);
|
||||
|
||||
// Standard Quality
|
||||
static const hd480p = QualityLevel(
|
||||
resolution: '854x480',
|
||||
bitrateBps: 2500000, // 2.5 Mbps
|
||||
width: 854,
|
||||
height: 480,
|
||||
ffmpegPreset: 'fast',
|
||||
label: '480p (SD)',
|
||||
);
|
||||
|
||||
static const hd720p = QualityLevel(
|
||||
resolution: '1280x720',
|
||||
bitrateBps: 5000000, // 5 Mbps
|
||||
width: 1280,
|
||||
height: 720,
|
||||
ffmpegPreset: 'medium',
|
||||
label: '720p (HD)',
|
||||
);
|
||||
|
||||
// High Quality
|
||||
static const fhd1080p = QualityLevel(
|
||||
resolution: '1920x1080',
|
||||
bitrateBps: 8000000, // 8 Mbps
|
||||
width: 1920,
|
||||
height: 1080,
|
||||
ffmpegPreset: 'medium',
|
||||
label: '1080p (Full HD)',
|
||||
);
|
||||
|
||||
// Ultra HD
|
||||
static const uhd2k = QualityLevel(
|
||||
resolution: '2560x1440',
|
||||
bitrateBps: 15000000, // 15 Mbps
|
||||
width: 2560,
|
||||
height: 1440,
|
||||
ffmpegPreset: 'slow',
|
||||
label: '2K (QHD)',
|
||||
);
|
||||
|
||||
static const uhd4k = QualityLevel(
|
||||
resolution: '3840x2160',
|
||||
bitrateBps: 25000000, // 25 Mbps
|
||||
width: 3840,
|
||||
height: 2160,
|
||||
ffmpegPreset: 'slow',
|
||||
label: '4K',
|
||||
);
|
||||
|
||||
/// Get default profiles for balanced streaming
|
||||
static List<QualityLevel> getBalancedProfiles() => [
|
||||
mobile240p,
|
||||
mobile360p,
|
||||
hd480p,
|
||||
hd720p,
|
||||
fhd1080p,
|
||||
];
|
||||
|
||||
/// Get all available profiles
|
||||
static List<QualityLevel> getAllProfiles() => [
|
||||
mobile240p,
|
||||
mobile360p,
|
||||
hd480p,
|
||||
hd720p,
|
||||
fhd1080p,
|
||||
uhd2k,
|
||||
uhd4k,
|
||||
];
|
||||
|
||||
/// Get profiles suitable for streaming type
|
||||
static List<QualityLevel> getProfiles({
|
||||
required String type, // 'live', 'vod', 'low-bandwidth'
|
||||
int? maxBitrateBps,
|
||||
}) {
|
||||
List<QualityLevel> profiles = getBalancedProfiles();
|
||||
|
||||
// Filter by streaming type
|
||||
if (type == 'live') {
|
||||
// Live TV prefers lower bitrates for stability
|
||||
profiles = [mobile240p, mobile360p, hd480p, hd720p];
|
||||
} else if (type == 'low-bandwidth') {
|
||||
// Mobile/low bandwidth - only lower profiles
|
||||
profiles = [mobile240p, mobile360p, hd480p];
|
||||
}
|
||||
|
||||
// Filter by max bitrate if specified
|
||||
if (maxBitrateBps != null) {
|
||||
profiles = profiles.where((p) => p.bitrateBps <= maxBitrateBps).toList();
|
||||
}
|
||||
|
||||
// Ensure at least one profile
|
||||
if (profiles.isEmpty) {
|
||||
profiles = [mobile240p];
|
||||
}
|
||||
|
||||
return profiles;
|
||||
}
|
||||
}
|
||||
|
||||
/// Bandwidth detector for adaptive bitrate selection
|
||||
class BandwidthDetector {
|
||||
final _samples = <DateTime, int>{}; // timestamp -> bytes downloaded
|
||||
int _totalBytesLastPeriod = 0;
|
||||
Duration _sampleWindow = const Duration(seconds: 10);
|
||||
|
||||
/// Record bytes downloaded at current time
|
||||
void recordBytes(int bytes) {
|
||||
final now = DateTime.now();
|
||||
_samples[now] = bytes;
|
||||
|
||||
// Clean up old samples
|
||||
final cutoff = now.subtract(_sampleWindow);
|
||||
_samples.removeWhere((time, _) => time.isBefore(cutoff));
|
||||
}
|
||||
|
||||
/// Estimate current bandwidth in bps
|
||||
int estimateBandwidthBps() {
|
||||
if (_samples.isEmpty) return 0;
|
||||
|
||||
int totalBytes = 0;
|
||||
_samples.values.forEach((bytes) => totalBytes += bytes);
|
||||
|
||||
final timeSpan = DateTime.now()
|
||||
.difference(
|
||||
_samples.keys.reduce((a, b) => a.isBefore(b) ? a : b),
|
||||
)
|
||||
.inMilliseconds;
|
||||
|
||||
if (timeSpan == 0) return 0;
|
||||
|
||||
// bytes per second * 8 = bits per second
|
||||
return ((totalBytes / (timeSpan / 1000)) * 8).toInt();
|
||||
}
|
||||
|
||||
/// Get estimated bandwidth in Mbps
|
||||
double estimateBandwidthMbps() {
|
||||
return estimateBandwidthBps() / 1000000;
|
||||
}
|
||||
|
||||
/// Select best quality level based on bandwidth
|
||||
static QualityLevel selectBestQuality(
|
||||
int bandwidthBps,
|
||||
List<QualityLevel> availableProfiles,
|
||||
) {
|
||||
// Use 75% of detected bandwidth for conservative selection
|
||||
final targetBitrate = (bandwidthBps * 0.75).toInt();
|
||||
|
||||
// Find highest quality that fits our bandwidth
|
||||
var best = availableProfiles[0];
|
||||
for (final profile in availableProfiles) {
|
||||
if (profile.bitrateBps <= targetBitrate) {
|
||||
best = profile;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return best;
|
||||
}
|
||||
}
|
||||
|
||||
/// Master playlist generator for HLS variant streams
|
||||
class HlsMasterPlaylistGenerator {
|
||||
/// Generate M3U8 master playlist with multiple quality variants
|
||||
static String generateMasterPlaylist({
|
||||
required List<QualityLevel> qualityLevels,
|
||||
required String baseUrl,
|
||||
bool includeSubtitles = false,
|
||||
}) {
|
||||
final buffer = StringBuffer();
|
||||
|
||||
// HLS version 3 for compatibility
|
||||
buffer.writeln('#EXTM3U');
|
||||
buffer.writeln('#EXT-X-VERSION:3');
|
||||
buffer.writeln('#EXT-X-TARGET-DURATION:10');
|
||||
buffer.writeln('#EXT-X-MEDIA-SEQUENCE:0');
|
||||
|
||||
// Variant streams (quality levels)
|
||||
for (final quality in qualityLevels) {
|
||||
buffer
|
||||
.writeln('#EXT-X-STREAM-INF:BANDWIDTH=${quality.bitrateBps},'
|
||||
'RESOLUTION=${quality.width}x${quality.height}');
|
||||
buffer.writeln('$baseUrl/variant_${quality.width}x${quality.height}.m3u8');
|
||||
}
|
||||
|
||||
return buffer.toString();
|
||||
}
|
||||
|
||||
/// Generate variant playlist for specific quality level
|
||||
static String generateVariantPlaylist({
|
||||
required String segmentPrefix,
|
||||
required int totalSegments,
|
||||
required double targetDuration,
|
||||
required bool isFinal,
|
||||
}) {
|
||||
final buffer = StringBuffer();
|
||||
|
||||
buffer.writeln('#EXTM3U');
|
||||
buffer.writeln('#EXT-X-VERSION:3');
|
||||
buffer.writeln('#EXT-X-TARGET-DURATION:${targetDuration.ceil()}');
|
||||
buffer.writeln('#EXT-X-MEDIA-SEQUENCE:0');
|
||||
|
||||
// Add segment entries
|
||||
for (int i = 0; i < totalSegments; i++) {
|
||||
buffer.writeln('#EXTINF:$targetDuration,');
|
||||
buffer.writeln('${segmentPrefix}_$i.ts');
|
||||
}
|
||||
|
||||
if (isFinal) {
|
||||
buffer.writeln('#EXT-X-ENDLIST');
|
||||
}
|
||||
|
||||
return buffer.toString();
|
||||
}
|
||||
}
|
||||
|
||||
/// Quality selector based on network conditions
|
||||
class QualitySelector {
|
||||
final _detector = BandwidthDetector();
|
||||
QualityLevel _currentQuality;
|
||||
final _listeners = <VoidCallback>[];
|
||||
|
||||
QualitySelector({
|
||||
required QualityLevel initialQuality,
|
||||
}) : _currentQuality = initialQuality;
|
||||
|
||||
QualityLevel get currentQuality => _currentQuality;
|
||||
|
||||
/// Record bandwidth and auto-adjust quality
|
||||
void recordBandwidth(int bytesDownloaded) {
|
||||
_detector.recordBytes(bytesDownloaded);
|
||||
|
||||
// Check if we should switch quality
|
||||
_maybeAdjustQuality();
|
||||
}
|
||||
|
||||
/// Manually set quality
|
||||
void setQuality(QualityLevel quality) {
|
||||
if (_currentQuality != quality) {
|
||||
_currentQuality = quality;
|
||||
_notifyListeners();
|
||||
}
|
||||
}
|
||||
|
||||
/// Force rebuffer wait before switching down
|
||||
void rebufferDetected() {
|
||||
// Switch to lower quality if rebuffering occurs
|
||||
final allProfiles = QualityProfiles.getAllProfiles();
|
||||
final currentIndex = allProfiles.indexOf(_currentQuality);
|
||||
if (currentIndex > 0) {
|
||||
setQuality(allProfiles[currentIndex - 1]);
|
||||
}
|
||||
}
|
||||
|
||||
void _maybeAdjustQuality() {
|
||||
final bandwidthBps = _detector.estimateBandwidthBps();
|
||||
final availableProfiles = QualityProfiles.getBalancedProfiles();
|
||||
|
||||
// Only switch if significantly different from current
|
||||
final overhead = _currentQuality.bitrateBps * 1.2;
|
||||
if (bandwidthBps > overhead || bandwidthBps < _currentQuality.bitrateBps * 0.5) {
|
||||
final bestQuality =
|
||||
BandwidthDetector.selectBestQuality(bandwidthBps, availableProfiles);
|
||||
setQuality(bestQuality);
|
||||
}
|
||||
}
|
||||
|
||||
void addListener(VoidCallback listener) {
|
||||
_listeners.add(listener);
|
||||
}
|
||||
|
||||
void removeListener(VoidCallback listener) {
|
||||
_listeners.remove(listener);
|
||||
}
|
||||
|
||||
void _notifyListeners() {
|
||||
for (final listener in _listeners) {
|
||||
listener();
|
||||
}
|
||||
}
|
||||
|
||||
double getEstimatedBandwidthMbps() => _detector.estimateBandwidthMbps();
|
||||
}
|
||||
|
||||
// Type alias for void callback
|
||||
typedef VoidCallback = void Function();
|
||||
@@ -0,0 +1,224 @@
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
|
||||
/// Optimized cache service for memory management
|
||||
class CacheService {
|
||||
static const _maxMemoryCacheSizeMb = 200;
|
||||
static const _maxImageCacheItems = 500;
|
||||
|
||||
final Map<String, CacheEntry> _cache = {};
|
||||
int _totalSizeBytes = 0;
|
||||
|
||||
/// Cache entry with metadata
|
||||
class CacheEntry<T> {
|
||||
final T data;
|
||||
final DateTime timestamp;
|
||||
final int sizeEstimate;
|
||||
int accessCount;
|
||||
DateTime lastAccess;
|
||||
|
||||
CacheEntry({
|
||||
required this.data,
|
||||
required this.sizeEstimate,
|
||||
}) : timestamp = DateTime.now(),
|
||||
lastAccess = DateTime.now(),
|
||||
accessCount = 0;
|
||||
|
||||
bool isExpired({Duration ttl = const Duration(hours: 24)}) {
|
||||
return DateTime.now().difference(timestamp) > ttl;
|
||||
}
|
||||
|
||||
void markAccess() {
|
||||
accessCount++;
|
||||
lastAccess = DateTime.now();
|
||||
}
|
||||
}
|
||||
|
||||
/// Cache data with automatic size management
|
||||
void cache<T>(String key, T value, {int estimatedSize = 1000}) {
|
||||
// Remove old entry if exists
|
||||
if (_cache.containsKey(key)) {
|
||||
_totalSizeBytes -= _cache[key]!.sizeEstimate;
|
||||
}
|
||||
|
||||
_cache[key] = CacheEntry(
|
||||
data: value,
|
||||
sizeEstimate: estimatedSize,
|
||||
);
|
||||
_totalSizeBytes += estimatedSize;
|
||||
|
||||
// Trim cache if over size limit
|
||||
_trimCacheIfNeeded();
|
||||
}
|
||||
|
||||
/// Get cached data
|
||||
T? get<T>(String key) {
|
||||
final entry = _cache[key] as CacheEntry?;
|
||||
if (entry != null && !entry.isExpired()) {
|
||||
entry.markAccess();
|
||||
return entry.data as T;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Check if key exists and is valid
|
||||
bool has(String key) {
|
||||
final entry = _cache[key];
|
||||
return entry != null && !entry.isExpired();
|
||||
}
|
||||
|
||||
/// Get cache stats
|
||||
Map<String, dynamic> getStats() => {
|
||||
'totalSize': _totalSizeBytes,
|
||||
'totalSizeMb': _totalSizeBytes / (1024 * 1024),
|
||||
'itemCount': _cache.length,
|
||||
'averageSizePerItem': _cache.isEmpty ? 0 : _totalSizeBytes ~/ _cache.length,
|
||||
};
|
||||
|
||||
/// Clear all cache
|
||||
void clear() {
|
||||
_cache.clear();
|
||||
_totalSizeBytes = 0;
|
||||
}
|
||||
|
||||
/// Clear expired entries
|
||||
void clearExpired() {
|
||||
final now = DateTime.now();
|
||||
final toRemove = _cache.entries
|
||||
.where((e) => e.value.isExpired())
|
||||
.map((e) => e.key)
|
||||
.toList();
|
||||
|
||||
for (final key in toRemove) {
|
||||
_totalSizeBytes -= _cache[key]!.sizeEstimate;
|
||||
_cache.remove(key);
|
||||
}
|
||||
}
|
||||
|
||||
/// Trim cache by removing least recently used entries
|
||||
void _trimCacheIfNeeded() {
|
||||
final maxSize = _maxMemoryCacheSizeMb * 1024 * 1024;
|
||||
if (_totalSizeBytes > maxSize) {
|
||||
// Remove least recently accessed entries
|
||||
final sorted = _cache.entries.toList()
|
||||
..sort((a, b) => a.value.accessCount.compareTo(b.value.accessCount));
|
||||
|
||||
for (final entry in sorted) {
|
||||
if (_totalSizeBytes <= maxSize * 0.8) break;
|
||||
_totalSizeBytes -= entry.value.sizeEstimate;
|
||||
_cache.remove(entry.key);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Image cache with size limiting
|
||||
class ImageCacheManager {
|
||||
static const _maxImageMemoryMb = 100;
|
||||
static const _maxImages = 500;
|
||||
|
||||
final Map<String, CachedImage> _imageCache = {};
|
||||
int _totalMemoryBytes = 0;
|
||||
|
||||
class CachedImage {
|
||||
final String url;
|
||||
final int sizeBytes;
|
||||
final DateTime cachedAt;
|
||||
int accessCount = 0;
|
||||
|
||||
CachedImage({
|
||||
required this.url,
|
||||
required this.sizeBytes,
|
||||
}) : cachedAt = DateTime.now();
|
||||
}
|
||||
|
||||
/// Add image to cache
|
||||
void cacheImage(String url, int sizeEstimateBytes) {
|
||||
if (_imageCache.length >= _maxImages) {
|
||||
_evictLeastUsed();
|
||||
}
|
||||
|
||||
_imageCache[url] = CachedImage(
|
||||
url: url,
|
||||
sizeBytes: sizeEstimateBytes,
|
||||
);
|
||||
_totalMemoryBytes += sizeEstimateBytes;
|
||||
|
||||
// Trim if over size
|
||||
while (_totalMemoryBytes > _maxImageMemoryMb * 1024 * 1024) {
|
||||
_evictLeastUsed();
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if image is cached
|
||||
bool isCached(String url) => _imageCache.containsKey(url);
|
||||
|
||||
/// Mark image as accessed
|
||||
void markAccessed(String url) {
|
||||
if (_imageCache.containsKey(url)) {
|
||||
_imageCache[url]!.accessCount++;
|
||||
}
|
||||
}
|
||||
|
||||
/// Evict least used image
|
||||
void _evictLeastUsed() {
|
||||
if (_imageCache.isEmpty) return;
|
||||
|
||||
final leastUsed = _imageCache.entries
|
||||
.reduce((a, b) => a.value.accessCount < b.value.accessCount ? a : b);
|
||||
|
||||
_totalMemoryBytes -= leastUsed.value.sizeBytes;
|
||||
_imageCache.remove(leastUsed.key);
|
||||
}
|
||||
|
||||
/// Get cache stats
|
||||
Map<String, dynamic> getStats() => {
|
||||
'totalMemoryMb': _totalMemoryBytes / (1024 * 1024),
|
||||
'cachedImages': _imageCache.length,
|
||||
'maxImages': _maxImages,
|
||||
};
|
||||
|
||||
/// Clear all image cache
|
||||
void clear() {
|
||||
_imageCache.clear();
|
||||
_totalMemoryBytes = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Riverpod providers
|
||||
|
||||
final cacheServiceProvider = Provider<CacheService>((ref) {
|
||||
return CacheService();
|
||||
});
|
||||
|
||||
final imageCacheManagerProvider = Provider<ImageCacheManager>((ref) {
|
||||
return ImageCacheManager();
|
||||
});
|
||||
|
||||
/// Provider for cache statistics
|
||||
final cacheStatsProvider = StateNotifierProvider<
|
||||
CacheStatsNotifier,
|
||||
Map<String, dynamic>>((ref) {
|
||||
final cacheService = ref.watch(cacheServiceProvider);
|
||||
return CacheStatsNotifier(cacheService);
|
||||
});
|
||||
|
||||
class CacheStatsNotifier extends StateNotifier<Map<String, dynamic>> {
|
||||
final CacheService _cacheService;
|
||||
|
||||
CacheStatsNotifier(this._cacheService)
|
||||
: super(_cacheService.getStats());
|
||||
|
||||
void refreshStats() {
|
||||
state = _cacheService.getStats();
|
||||
}
|
||||
|
||||
void clearCache() {
|
||||
_cacheService.clear();
|
||||
state = _cacheService.getStats();
|
||||
}
|
||||
|
||||
void clearExpired() {
|
||||
_cacheService.clearExpired();
|
||||
state = _cacheService.getStats();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,272 @@
|
||||
import 'package:dio/dio.dart';
|
||||
import 'package:dio_cache_interceptor/dio_cache_interceptor.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
|
||||
/// Advanced network configuration for streaming
|
||||
class NetworkConfig {
|
||||
final String? proxyUrl;
|
||||
final String? userAgent;
|
||||
final Map<String, String> customHeaders;
|
||||
final Duration connectTimeout;
|
||||
final Duration receiveTimeout;
|
||||
final bool enableValidateSSL;
|
||||
|
||||
const NetworkConfig({
|
||||
this.proxyUrl,
|
||||
this.userAgent = 'VLC/3.0.18 LibVLC/3.0.18',
|
||||
this.customHeaders = const {},
|
||||
this.connectTimeout = const Duration(seconds: 30),
|
||||
this.receiveTimeout = const Duration(seconds: 60),
|
||||
this.enableValidateSSL = true,
|
||||
});
|
||||
|
||||
NetworkConfig copyWith({
|
||||
String? proxyUrl,
|
||||
String? userAgent,
|
||||
Map<String, String>? customHeaders,
|
||||
Duration? connectTimeout,
|
||||
Duration? receiveTimeout,
|
||||
bool? enableValidateSSL,
|
||||
}) =>
|
||||
NetworkConfig(
|
||||
proxyUrl: proxyUrl ?? this.proxyUrl,
|
||||
userAgent: userAgent ?? this.userAgent,
|
||||
customHeaders: customHeaders ?? this.customHeaders,
|
||||
connectTimeout: connectTimeout ?? this.connectTimeout,
|
||||
receiveTimeout: receiveTimeout ?? this.receiveTimeout,
|
||||
enableValidateSSL: enableValidateSSL ?? this.enableValidateSSL,
|
||||
);
|
||||
}
|
||||
|
||||
/// Advanced network service with proxy and optimization support
|
||||
class OptimizedNetworkService {
|
||||
late Dio _dio;
|
||||
late NetworkConfig _config;
|
||||
late CacheInterceptor _cacheInterceptor;
|
||||
|
||||
OptimizedNetworkService({required NetworkConfig config}) {
|
||||
_config = config;
|
||||
_initializeDio();
|
||||
}
|
||||
|
||||
void _initializeDio() {
|
||||
_cacheInterceptor = CacheInterceptor(
|
||||
options: CacheOptions(
|
||||
store: MemCacheStore(),
|
||||
policy: CachePolicy.requestFirst,
|
||||
hitCacheOnErrorExcept: [],
|
||||
allowPostMethod: false,
|
||||
),
|
||||
);
|
||||
|
||||
_dio = Dio(
|
||||
BaseOptions(
|
||||
connectTimeout: _config.connectTimeout,
|
||||
receiveTimeout: _config.receiveTimeout,
|
||||
validateStatus: (status) => status != null && status < 500,
|
||||
headers: {
|
||||
'User-Agent': _config.userAgent,
|
||||
..._config.customHeaders,
|
||||
},
|
||||
),
|
||||
);
|
||||
|
||||
// Configure proxy if specified
|
||||
if (_config.proxyUrl != null) {
|
||||
_dio.httpClientAdapter = _createProxyAdapter(_config.proxyUrl!);
|
||||
}
|
||||
|
||||
// Add interceptors
|
||||
_dio.interceptors.addAll([
|
||||
_cacheInterceptor,
|
||||
_BandwidthTrackingInterceptor(),
|
||||
_RetryInterceptor(),
|
||||
]);
|
||||
}
|
||||
|
||||
/// Create HTTP client adapter with proxy support
|
||||
dynamic _createProxyAdapter(String proxyUrl) {
|
||||
// Implementation for proxy support
|
||||
// This would need to handle HTTP/HTTPS proxies
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Update network configuration
|
||||
void updateConfig(NetworkConfig config) {
|
||||
_config = config;
|
||||
_initializeDio();
|
||||
}
|
||||
|
||||
Dio get dio => _dio;
|
||||
|
||||
/// Download file with resume support
|
||||
Future<void> downloadFile({
|
||||
required String url,
|
||||
required String savePath,
|
||||
required Function(int, int) onProgress,
|
||||
CancelToken? cancelToken,
|
||||
}) async {
|
||||
try {
|
||||
await _dio.download(
|
||||
url,
|
||||
savePath,
|
||||
onReceiveProgress: onProgress,
|
||||
cancelToken: cancelToken,
|
||||
options: Options(
|
||||
headers: {'Range': 'bytes=0-'},
|
||||
),
|
||||
);
|
||||
} catch (e) {
|
||||
rethrow;
|
||||
}
|
||||
}
|
||||
|
||||
/// Stream request with large response handling
|
||||
Future<void> streamRequest({
|
||||
required String url,
|
||||
required Function(List<int>) onData,
|
||||
required VoidCallback onDone,
|
||||
required Function(dynamic) onError,
|
||||
CancelToken? cancelToken,
|
||||
}) async {
|
||||
try {
|
||||
final response = await _dio.get<ResponseBody>(
|
||||
url,
|
||||
options: Options(
|
||||
responseType: ResponseType.stream,
|
||||
receiveTimeout: const Duration(minutes: 5),
|
||||
),
|
||||
cancelToken: cancelToken,
|
||||
);
|
||||
|
||||
final stream = response.data?.stream;
|
||||
if (stream != null) {
|
||||
stream.listen(
|
||||
onData,
|
||||
onError: onError,
|
||||
onDone: onDone,
|
||||
);
|
||||
}
|
||||
} catch (e) {
|
||||
onError(e);
|
||||
}
|
||||
}
|
||||
|
||||
/// Clear cache
|
||||
void clearCache() {
|
||||
_cacheInterceptor.clearCache();
|
||||
}
|
||||
}
|
||||
|
||||
/// Interceptor for tracking bandwidth
|
||||
class _BandwidthTrackingInterceptor extends Interceptor {
|
||||
int _bytesReceived = 0;
|
||||
DateTime _lastReset = DateTime.now();
|
||||
|
||||
int get bytesReceivedLastSecond {
|
||||
final now = DateTime.now();
|
||||
final secondsElapsed = now.difference(_lastReset).inSeconds;
|
||||
if (secondsElapsed > 1) {
|
||||
final bps = _bytesReceived ~/ secondsElapsed;
|
||||
_bytesReceived = 0;
|
||||
_lastReset = now;
|
||||
return bps;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@override
|
||||
void onResponse(Response response, ResponseInterceptorHandler handler) {
|
||||
if (response.data is ResponseBody) {
|
||||
// Track bytes for streaming responses
|
||||
} else if (response.data is List<int>) {
|
||||
_bytesReceived += (response.data as List<int>).length;
|
||||
}
|
||||
handler.next(response);
|
||||
}
|
||||
}
|
||||
|
||||
/// Interceptor for automatic retry on failure
|
||||
class _RetryInterceptor extends Interceptor {
|
||||
static const _maxRetries = 3;
|
||||
|
||||
@override
|
||||
Future<void> onError(
|
||||
DioException err, ErrorInterceptorHandler handler) async {
|
||||
// Only retry on timeout or connection errors
|
||||
if (err.type == DioExceptionType.connectionTimeout ||
|
||||
err.type == DioExceptionType.receiveTimeout) {
|
||||
final requestOptions = err.requestOptions;
|
||||
int retryCount = requestOptions.extra['retryCount'] ?? 0;
|
||||
|
||||
if (retryCount < _maxRetries) {
|
||||
requestOptions.extra['retryCount'] = retryCount + 1;
|
||||
|
||||
// Exponential backoff: 100ms, 200ms, 400ms
|
||||
final delay = Duration(milliseconds: 100 * (1 << retryCount));
|
||||
await Future.delayed(delay);
|
||||
|
||||
final dio = Dio();
|
||||
try {
|
||||
final response = await dio.request<dynamic>(
|
||||
requestOptions.path,
|
||||
options: Options(
|
||||
method: requestOptions.method,
|
||||
headers: requestOptions.headers,
|
||||
),
|
||||
data: requestOptions.data,
|
||||
queryParameters: requestOptions.queryParameters,
|
||||
);
|
||||
return handler.resolve(response);
|
||||
} on DioException catch (e) {
|
||||
return handler.next(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
handler.next(err);
|
||||
}
|
||||
}
|
||||
|
||||
// Riverpod providers
|
||||
|
||||
final networkConfigProvider =
|
||||
StateNotifierProvider<NetworkConfigNotifier, NetworkConfig>((ref) {
|
||||
return NetworkConfigNotifier();
|
||||
});
|
||||
|
||||
class NetworkConfigNotifier extends StateNotifier<NetworkConfig> {
|
||||
NetworkConfigNotifier()
|
||||
: super(const NetworkConfig(
|
||||
userAgent: 'VLC/3.0.18 LibVLC/3.0.18',
|
||||
));
|
||||
|
||||
void setProxy(String? proxyUrl) {
|
||||
state = state.copyWith(proxyUrl: proxyUrl);
|
||||
}
|
||||
|
||||
void setUserAgent(String userAgent) {
|
||||
state = state.copyWith(userAgent: userAgent);
|
||||
}
|
||||
|
||||
void addCustomHeader(String key, String value) {
|
||||
final newHeaders = {...state.customHeaders};
|
||||
newHeaders[key] = value;
|
||||
state = state.copyWith(customHeaders: newHeaders);
|
||||
}
|
||||
|
||||
void removeCustomHeader(String key) {
|
||||
final newHeaders = {...state.customHeaders};
|
||||
newHeaders.remove(key);
|
||||
state = state.copyWith(customHeaders: newHeaders);
|
||||
}
|
||||
|
||||
void clearCustomHeaders() {
|
||||
state = state.copyWith(customHeaders: {});
|
||||
}
|
||||
}
|
||||
|
||||
final networkServiceProvider = Provider<OptimizedNetworkService>((ref) {
|
||||
final config = ref.watch(networkConfigProvider);
|
||||
return OptimizedNetworkService(config: config);
|
||||
});
|
||||
@@ -0,0 +1,269 @@
|
||||
import 'dart:async';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import '../../core/services/adaptive_bitrate_service.dart';
|
||||
|
||||
/// Video streaming performance metrics
|
||||
class StreamingMetrics {
|
||||
final double averageNetworkBitrate;
|
||||
final double currentNetworkBitrate;
|
||||
final int bufferDurationMs;
|
||||
final int segmentDownloadTimeMs;
|
||||
final int rebufferCount;
|
||||
final DateTime startTime;
|
||||
final DateTime? endTime;
|
||||
|
||||
StreamingMetrics({
|
||||
required this.averageNetworkBitrate,
|
||||
required this.currentNetworkBitrate,
|
||||
required this.bufferDurationMs,
|
||||
required this.segmentDownloadTimeMs,
|
||||
required this.rebufferCount,
|
||||
required this.startTime,
|
||||
this.endTime,
|
||||
});
|
||||
|
||||
double get totalPlaybackSeconds =>
|
||||
(endTime ?? DateTime.now())
|
||||
.difference(startTime)
|
||||
.inSeconds
|
||||
.toDouble();
|
||||
|
||||
double get qualityScore {
|
||||
// Score based on metrics
|
||||
var score = 100.0;
|
||||
|
||||
// Penalize for rebuffering
|
||||
score -= rebufferCount * 10;
|
||||
|
||||
// Penalize for low bitrate
|
||||
if (currentNetworkBitrate < 1000000) score -= 20;
|
||||
if (currentNetworkBitrate < 500000) score -= 30;
|
||||
|
||||
// Reward for smooth playback
|
||||
if (rebufferCount == 0) score += 10;
|
||||
|
||||
return (score).clamp(0, 100);
|
||||
}
|
||||
|
||||
@override
|
||||
String toString() => '''
|
||||
StreamingMetrics:
|
||||
- Avg Bitrate: ${(averageNetworkBitrate / 1000000).toStringAsFixed(2)} Mbps
|
||||
- Current Bitrate: ${(currentNetworkBitrate / 1000000).toStringAsFixed(2)} Mbps
|
||||
- Buffer: ${bufferDurationMs}ms
|
||||
- Segment DL Time: ${segmentDownloadTimeMs}ms
|
||||
- Rebuffers: $rebufferCount
|
||||
- Quality Score: ${qualityScore.toStringAsFixed(1)}
|
||||
- Duration: $totalPlaybackSeconds seconds
|
||||
''';
|
||||
}
|
||||
|
||||
/// Advanced streaming optimizer
|
||||
class StreamingOptimizer {
|
||||
final QualitySelector qualitySelector;
|
||||
final _metrics = <StreamingMetrics>[];
|
||||
late StreamingMetrics _currentMetrics;
|
||||
final StreamController<StreamingMetrics> _metricsController =
|
||||
StreamController.broadcast();
|
||||
late Timer _metricsTimer;
|
||||
|
||||
int _segmentStartTime = 0;
|
||||
int _totalBytesDownloaded = 0;
|
||||
int _rebufferCount = 0;
|
||||
int _lastBufferNotificationTime = 0;
|
||||
|
||||
StreamingOptimizer({required this.qualitySelector}) {
|
||||
_initializeMetrics();
|
||||
_startMetricsCollection();
|
||||
}
|
||||
|
||||
void _initializeMetrics() {
|
||||
_currentMetrics = StreamingMetrics(
|
||||
averageNetworkBitrate: 0,
|
||||
currentNetworkBitrate: 0,
|
||||
bufferDurationMs: 0,
|
||||
segmentDownloadTimeMs: 0,
|
||||
rebufferCount: 0,
|
||||
startTime: DateTime.now(),
|
||||
);
|
||||
}
|
||||
|
||||
void _startMetricsCollection() {
|
||||
_metricsTimer = Timer.periodic(const Duration(seconds: 5), (timer) {
|
||||
_updateMetrics();
|
||||
});
|
||||
}
|
||||
|
||||
void _updateMetrics() {
|
||||
final bandwidthBps = qualitySelector.getEstimatedBandwidthMbps() * 1000000;
|
||||
_currentMetrics = StreamingMetrics(
|
||||
averageNetworkBitrate: _totalBytesDownloaded > 0
|
||||
? (_totalBytesDownloaded * 8 /
|
||||
_currentMetrics.totalPlaybackSeconds)
|
||||
: 0,
|
||||
currentNetworkBitrate: bandwidthBps,
|
||||
bufferDurationMs: _currentMetrics.bufferDurationMs,
|
||||
segmentDownloadTimeMs: _currentMetrics.segmentDownloadTimeMs,
|
||||
rebufferCount: _rebufferCount,
|
||||
startTime: _currentMetrics.startTime,
|
||||
);
|
||||
|
||||
_metrics.add(_currentMetrics);
|
||||
_metricsController.add(_currentMetrics);
|
||||
}
|
||||
|
||||
/// Record segment download
|
||||
void recordSegmentDownload(int bytes, Duration downloadTime) {
|
||||
_totalBytesDownloaded += bytes;
|
||||
final downloadMs = downloadTime.inMilliseconds;
|
||||
|
||||
_currentMetrics = _currentMetrics;
|
||||
qualitySelector.recordBandwidth(bytes);
|
||||
}
|
||||
|
||||
/// Handle rebuffer event
|
||||
void rebufferDetected(Duration duration) {
|
||||
_rebufferCount++;
|
||||
_lastBufferNotificationTime = DateTime.now().millisecondsSinceEpoch;
|
||||
|
||||
_currentMetrics = StreamingMetrics(
|
||||
averageNetworkBitrate: _currentMetrics.averageNetworkBitrate,
|
||||
currentNetworkBitrate: _currentMetrics.currentNetworkBitrate,
|
||||
bufferDurationMs: duration.inMilliseconds,
|
||||
segmentDownloadTimeMs: _currentMetrics.segmentDownloadTimeMs,
|
||||
rebufferCount: _rebufferCount,
|
||||
startTime: _currentMetrics.startTime,
|
||||
);
|
||||
|
||||
// Auto downgrade quality on rebuffer
|
||||
qualitySelector.rebufferDetected();
|
||||
}
|
||||
|
||||
/// Get current streaming metrics
|
||||
StreamingMetrics getMetrics() => _currentMetrics;
|
||||
|
||||
/// Get metrics stream for real-time monitoring
|
||||
Stream<StreamingMetrics> get metricsStream => _metricsController.stream;
|
||||
|
||||
/// Get metrics history
|
||||
List<StreamingMetrics> getMetricsHistory() => List.from(_metrics);
|
||||
|
||||
/// Finalize streaming session
|
||||
void finalize() {
|
||||
_currentMetrics = StreamingMetrics(
|
||||
averageNetworkBitrate: _currentMetrics.averageNetworkBitrate,
|
||||
currentNetworkBitrate: _currentMetrics.currentNetworkBitrate,
|
||||
bufferDurationMs: _currentMetrics.bufferDurationMs,
|
||||
segmentDownloadTimeMs: _currentMetrics.segmentDownloadTimeMs,
|
||||
rebufferCount: _rebufferCount,
|
||||
startTime: _currentMetrics.startTime,
|
||||
endTime: DateTime.now(),
|
||||
);
|
||||
}
|
||||
|
||||
/// Clean up resources
|
||||
void dispose() {
|
||||
_metricsTimer.cancel();
|
||||
_metricsController.close();
|
||||
}
|
||||
}
|
||||
|
||||
/// Buffer size calculator for adaptive streaming
|
||||
class BufferCalculator {
|
||||
static const _minBufferMs = 1000; // 1 second
|
||||
static const _targetBufferMs = 8000; // 8 seconds
|
||||
static const _maxBufferMs = 30000; // 30 seconds
|
||||
|
||||
/// Calculate optimal buffer size based on bandwidth
|
||||
static int calculateOptimalBuffer(
|
||||
int estimatedBandwidthBps,
|
||||
int bitrateOfCurrentQuality,
|
||||
) {
|
||||
// Rule: buffer should be able to hold 8 seconds worth of content
|
||||
final neededBytes = (bitrateOfCurrentQuality * _targetBufferMs) ~/ 8000;
|
||||
final availableBytes = (estimatedBandwidthBps * _targetBufferMs) ~/ 8000;
|
||||
|
||||
// If we can't sustain the bitrate + have buffer, reduce target
|
||||
if (availableBytes < neededBytes) {
|
||||
return _minBufferMs;
|
||||
}
|
||||
|
||||
// Normal case
|
||||
return _targetBufferMs;
|
||||
}
|
||||
|
||||
/// Calculate recommended segment duration
|
||||
static Duration calculateSegmentDuration(int estimatedBandwidthBps) {
|
||||
if (estimatedBandwidthBps < 500000) {
|
||||
// Very low bandwidth: shorter segments
|
||||
return const Duration(seconds: 2);
|
||||
} else if (estimatedBandwidthBps < 2000000) {
|
||||
// Low bandwidth
|
||||
return const Duration(seconds: 4);
|
||||
} else {
|
||||
// Good bandwidth
|
||||
return const Duration(seconds: 6);
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculate maximum playback quality
|
||||
static QualityLevel selectQualityForBandwidth(
|
||||
int estimatedBandwidthBps,
|
||||
) {
|
||||
final availableProfiles = QualityProfiles.getBalancedProfiles();
|
||||
return BandwidthDetector.selectBestQuality(
|
||||
estimatedBandwidthBps,
|
||||
availableProfiles,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Riverpod providers
|
||||
|
||||
final streamingOptimizerProvider =
|
||||
StateNotifierProvider<StreamingOptimizerNotifier, StreamingMetrics>((ref) {
|
||||
final qualitySelector = ref.watch(qualitySelectorProvider);
|
||||
return StreamingOptimizerNotifier(qualitySelector);
|
||||
});
|
||||
|
||||
final qualitySelectorProvider = Provider<QualitySelector>((ref) {
|
||||
return QualitySelector(initialQuality: QualityProfiles.hd720p);
|
||||
});
|
||||
|
||||
class StreamingOptimizerNotifier extends StateNotifier<StreamingMetrics> {
|
||||
final QualitySelector _qualitySelector;
|
||||
late StreamingOptimizer _optimizer;
|
||||
|
||||
StreamingOptimizerNotifier(this._qualitySelector)
|
||||
: super(StreamingMetrics(
|
||||
averageNetworkBitrate: 0,
|
||||
currentNetworkBitrate: 0,
|
||||
bufferDurationMs: 0,
|
||||
segmentDownloadTimeMs: 0,
|
||||
rebufferCount: 0,
|
||||
startTime: DateTime.now(),
|
||||
)) {
|
||||
_optimizer = StreamingOptimizer(qualitySelector: _qualitySelector);
|
||||
|
||||
// Listen to metrics updates
|
||||
_optimizer.metricsStream.listen((metrics) {
|
||||
state = metrics;
|
||||
});
|
||||
}
|
||||
|
||||
void recordSegmentDownload(int bytes, Duration duration) {
|
||||
_optimizer.recordSegmentDownload(bytes, duration);
|
||||
}
|
||||
|
||||
void rebufferDetected(Duration duration) {
|
||||
_optimizer.rebufferDetected(duration);
|
||||
}
|
||||
|
||||
List<StreamingMetrics> getHistory() => _optimizer.getMetricsHistory();
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_optimizer.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import '../../../core/models/playlist_config.dart';
|
||||
import '../models/playlist.dart';
|
||||
|
||||
/// Represents a content recommendation
|
||||
class Recommendation {
|
||||
final Playlist item;
|
||||
final RecommendationType type;
|
||||
final double score;
|
||||
final String reason;
|
||||
|
||||
Recommendation({
|
||||
required this.item,
|
||||
required this.type,
|
||||
this.score = 0.0,
|
||||
required this.reason,
|
||||
});
|
||||
}
|
||||
|
||||
enum RecommendationType {
|
||||
continueWatching,
|
||||
trending,
|
||||
recentlyAdded,
|
||||
similarContent,
|
||||
topRated,
|
||||
forYou,
|
||||
}
|
||||
|
||||
class RecommendationService {
|
||||
/// Get continue watching items based on watch history
|
||||
static List<Recommendation> getContinueWatching(
|
||||
Map<String, dynamic> watchHistory,
|
||||
List<Playlist> allContent,
|
||||
) {
|
||||
final recommendations = <Recommendation>[];
|
||||
|
||||
for (final item in allContent) {
|
||||
final historyKey = item.streamId.toString();
|
||||
if (watchHistory.containsKey(historyKey)) {
|
||||
final lastPosition = watchHistory[historyKey] as double? ?? 0.0;
|
||||
|
||||
// Only show if watched more than 5 seconds ago and less than 95% complete
|
||||
if (lastPosition > 5 && lastPosition < 95) {
|
||||
recommendations.add(Recommendation(
|
||||
item: item,
|
||||
type: RecommendationType.continueWatching,
|
||||
score: 100.0 - lastPosition, // Score higher if recently started
|
||||
reason: 'Continue watching from ${lastPosition.toStringAsFixed(0)}%',
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by last watched (highest incomplete progress first)
|
||||
recommendations.sort((a, b) => b.score.compareTo(a.score));
|
||||
return recommendations.take(10).toList();
|
||||
}
|
||||
|
||||
/// Get trending content based on view counts
|
||||
static List<Recommendation> getTrending(
|
||||
Map<String, int> viewCounts,
|
||||
List<Playlist> allContent,
|
||||
) {
|
||||
final recommendations = <Recommendation>[];
|
||||
|
||||
for (final item in allContent) {
|
||||
final views = viewCounts[item.streamId.toString()] ?? 0;
|
||||
if (views > 0) {
|
||||
recommendations.add(Recommendation(
|
||||
item: item,
|
||||
type: RecommendationType.trending,
|
||||
score: views.toDouble(),
|
||||
reason: '$views views - Trending now',
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
recommendations.sort((a, b) => b.score.compareTo(a.score));
|
||||
return recommendations.take(10).toList();
|
||||
}
|
||||
|
||||
/// Get recently added content
|
||||
static List<Recommendation> getRecentlyAdded(List<Playlist> allContent) {
|
||||
final recommendations = <Recommendation>[];
|
||||
|
||||
// Sort by added date (most recent first)
|
||||
final sorted = [...allContent];
|
||||
sorted.sort((a, b) {
|
||||
final aDate = DateTime.tryParse(a.added ?? '') ?? DateTime(2000);
|
||||
final bDate = DateTime.tryParse(b.added ?? '') ?? DateTime(2000);
|
||||
return bDate.compareTo(aDate);
|
||||
});
|
||||
|
||||
for (final item in sorted.take(20)) {
|
||||
final daysAgo = DateTime.now()
|
||||
.difference(DateTime.tryParse(item.added ?? '') ?? DateTime(2000))
|
||||
.inDays;
|
||||
|
||||
recommendations.add(Recommendation(
|
||||
item: item,
|
||||
type: RecommendationType.recentlyAdded,
|
||||
score: (20 - daysAgo).toDouble().clamp(0, 100),
|
||||
reason: 'Added $daysAgo days ago',
|
||||
));
|
||||
}
|
||||
|
||||
return recommendations.take(10).toList();
|
||||
}
|
||||
|
||||
/// Get personalized recommendations based on watch history
|
||||
static List<Recommendation> getForYou(
|
||||
Map<String, dynamic> watchHistory,
|
||||
List<Playlist> allContent,
|
||||
) {
|
||||
final recommendations = <Recommendation>[];
|
||||
|
||||
// Collect watched categories
|
||||
final watchedCategories = <String>{};
|
||||
watchHistory.forEach((key, value) {
|
||||
if (value is Map && value.containsKey('category')) {
|
||||
watchedCategories.add(value['category'] as String);
|
||||
}
|
||||
});
|
||||
|
||||
// Recommend similar content
|
||||
for (final item in allContent) {
|
||||
if (watchedCategories.contains(item.categoryId)) {
|
||||
recommendations.add(Recommendation(
|
||||
item: item,
|
||||
type: RecommendationType.forYou,
|
||||
score: 75.0,
|
||||
reason: 'Based on your interests',
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
// Add highly rated content
|
||||
var ratedContent = [...allContent];
|
||||
ratedContent.sort((a, b) {
|
||||
final aRating = double.tryParse(a.rating ?? '0') ?? 0.0;
|
||||
final bRating = double.tryParse(b.rating ?? '0') ?? 0.0;
|
||||
return bRating.compareTo(aRating);
|
||||
});
|
||||
|
||||
for (final item in ratedContent.where((i) {
|
||||
final rating = double.tryParse(i.rating ?? '0') ?? 0.0;
|
||||
return rating >= 7.5;
|
||||
}).take(5)) {
|
||||
recommendations.add(Recommendation(
|
||||
item: item,
|
||||
type: RecommendationType.topRated,
|
||||
score: double.tryParse(item.rating ?? '0') ?? 0.0,
|
||||
reason: 'Highly rated - ${item.rating}/10',
|
||||
));
|
||||
}
|
||||
|
||||
// Remove duplicates and limit
|
||||
final seen = <int>{};
|
||||
final unique = <Recommendation>[];
|
||||
for (final rec in recommendations) {
|
||||
if (!seen.contains(rec.item.streamId)) {
|
||||
unique.add(rec);
|
||||
seen.add(rec.item.streamId);
|
||||
}
|
||||
}
|
||||
|
||||
return unique.take(15).toList();
|
||||
}
|
||||
}
|
||||
|
||||
/// Provider for watch history
|
||||
final watchHistoryProvider = StateNotifierProvider<
|
||||
WatchHistoryNotifier,
|
||||
Map<String, dynamic>>((ref) {
|
||||
return WatchHistoryNotifier();
|
||||
});
|
||||
|
||||
class WatchHistoryNotifier extends StateNotifier<Map<String, dynamic>> {
|
||||
WatchHistoryNotifier() : super({});
|
||||
|
||||
void updateWatchTime(int streamId, double percentage) {
|
||||
state = {
|
||||
...state,
|
||||
streamId.toString(): {
|
||||
'percentage': percentage,
|
||||
'timestamp': DateTime.now().toIso8601String(),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
void clearHistory() {
|
||||
state = {};
|
||||
}
|
||||
}
|
||||
|
||||
/// Provider for view counts/trending
|
||||
final trendingProvider = StateNotifierProvider<
|
||||
TrendingNotifier,
|
||||
Map<String, int>>((ref) {
|
||||
return TrendingNotifier();
|
||||
});
|
||||
|
||||
class TrendingNotifier extends StateNotifier<Map<String, int>> {
|
||||
TrendingNotifier() : super({});
|
||||
|
||||
void incrementViewCount(int streamId) {
|
||||
final key = streamId.toString();
|
||||
state = {
|
||||
...state,
|
||||
key: (state[key] ?? 0) + 1,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/// Provider for recommendations
|
||||
final recommendationsProvider =
|
||||
FutureProvider.family<List<Recommendation>, (Playlist, Map<String, dynamic>, Map<String, int>, List<Playlist>)>(
|
||||
(ref, params) async {
|
||||
final (playlist, watchHistory, trending, allContent) = params;
|
||||
|
||||
// Combine all recommendation types
|
||||
final allRecommendations = <Recommendation>[
|
||||
...RecommendationService.getContinueWatching(watchHistory, allContent),
|
||||
...RecommendationService.getTrending(trending, allContent),
|
||||
...RecommendationService.getRecentlyAdded(allContent),
|
||||
...RecommendationService.getForYou(watchHistory, allContent),
|
||||
];
|
||||
|
||||
// Deduplicate and score
|
||||
final seen = <int>{};
|
||||
final scored = <Recommendation>[];
|
||||
|
||||
for (final rec in allRecommendations) {
|
||||
if (!seen.contains(rec.item.streamId)) {
|
||||
scored.add(rec);
|
||||
seen.add(rec.item.streamId);
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by score
|
||||
scored.sort((a, b) => b.score.compareTo(a.score));
|
||||
return scored;
|
||||
},
|
||||
);
|
||||
@@ -0,0 +1,481 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import 'package:intl/intl.dart';
|
||||
import '../../../core/models/playlist_config.dart';
|
||||
import '../models/playlist.dart';
|
||||
import '../services/xtream_service.dart';
|
||||
|
||||
/// EPG Program information
|
||||
class EpgProgram {
|
||||
final String id;
|
||||
final String channelId;
|
||||
final String title;
|
||||
final String description;
|
||||
final DateTime startTime;
|
||||
final DateTime endTime;
|
||||
final String? imageUrl;
|
||||
final bool isNow;
|
||||
final bool isNext;
|
||||
|
||||
EpgProgram({
|
||||
required this.id,
|
||||
required this.channelId,
|
||||
required this.title,
|
||||
required this.description,
|
||||
required this.startTime,
|
||||
required this.endTime,
|
||||
this.imageUrl,
|
||||
this.isNow = false,
|
||||
this.isNext = false,
|
||||
});
|
||||
|
||||
Duration get duration => endTime.difference(startTime);
|
||||
|
||||
double get progress {
|
||||
if (!isNow) return 0;
|
||||
final now = DateTime.now();
|
||||
if (now.isBefore(startTime)) return 0;
|
||||
if (now.isAfter(endTime)) return 100;
|
||||
return ((now.difference(startTime).inSeconds) / duration.inSeconds) * 100;
|
||||
}
|
||||
}
|
||||
|
||||
/// EPG Grid View Screen (7 days, 24 hours)
|
||||
class EpgGridScreen extends ConsumerStatefulWidget {
|
||||
final Playlist playlist;
|
||||
|
||||
const EpgGridScreen({
|
||||
Key? key,
|
||||
required this.playlist,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
ConsumerState<EpgGridScreen> createState() => _EpgGridScreenState();
|
||||
}
|
||||
|
||||
class _EpgGridScreenState extends ConsumerState<EpgGridScreen>
|
||||
with TickerProviderStateMixin {
|
||||
late TabController _tabController;
|
||||
final _horizontalScroll = ScrollController();
|
||||
final _verticalScroll = ScrollController();
|
||||
Map<String, List<EpgProgram>> _epgData = {};
|
||||
DateTime _selectedDate = DateTime.now();
|
||||
bool _isLoading = false;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_tabController = TabController(length: 7, vsync: this);
|
||||
WidgetsBinding.instance.addPostFrameCallback((_) {
|
||||
_loadEpgData();
|
||||
});
|
||||
}
|
||||
|
||||
@override
|
||||
void dispose() {
|
||||
_tabController.dispose();
|
||||
_horizontalScroll.dispose();
|
||||
_verticalScroll.dispose();
|
||||
super.dispose();
|
||||
}
|
||||
|
||||
Future<void> _loadEpgData() async {
|
||||
if (_isLoading) return;
|
||||
setState(() => _isLoading = true);
|
||||
|
||||
try {
|
||||
final service = ref.read(xtreamServiceProvider(widget.playlist));
|
||||
final channels = await service.getLiveChannels();
|
||||
|
||||
final epgMap = <String, List<EpgProgram>>{};
|
||||
|
||||
// Load EPG for each channel
|
||||
for (final channel in channels) {
|
||||
try {
|
||||
final epg = await service.getFullEpg(channel.streamId.toString());
|
||||
final programs = _parseEpgPrograms(epg, channel.streamId.toString());
|
||||
epgMap[channel.streamId.toString()] = programs;
|
||||
} catch (e) {
|
||||
print('Error loading EPG for ${channel.name}: $e');
|
||||
epgMap[channel.streamId.toString()] = [];
|
||||
}
|
||||
}
|
||||
|
||||
setState(() {
|
||||
_epgData = epgMap;
|
||||
_isLoading = false;
|
||||
});
|
||||
} catch (e) {
|
||||
print('Error loading EPG: $e');
|
||||
setState(() => _isLoading = false);
|
||||
}
|
||||
}
|
||||
|
||||
List<EpgProgram> _parseEpgPrograms(
|
||||
Map<String, dynamic> epgData, String channelId) {
|
||||
final programs = <EpgProgram>[];
|
||||
final now = DateTime.now();
|
||||
|
||||
// Parse EPG data structure
|
||||
if (epgData.containsKey('epg_listings')) {
|
||||
final listings = epgData['epg_listings'] as List;
|
||||
for (final item in listings) {
|
||||
try {
|
||||
final startStr = item['start'] as String?;
|
||||
final endStr = item['end'] as String?;
|
||||
final title = item['title'] as String?;
|
||||
final desc = item['description'] as String? ?? '';
|
||||
|
||||
if (startStr != null && endStr != null && title != null) {
|
||||
final start = _parseEpgTime(startStr);
|
||||
final end = _parseEpgTime(endStr);
|
||||
|
||||
programs.add(EpgProgram(
|
||||
id: '${channelId}_${start.millisecondsSinceEpoch}',
|
||||
channelId: channelId,
|
||||
title: title,
|
||||
description: desc,
|
||||
startTime: start,
|
||||
endTime: end,
|
||||
isNow: now.isAfter(start) && now.isBefore(end),
|
||||
isNext: start.isAfter(now) &&
|
||||
start.difference(now).inMinutes < 60,
|
||||
));
|
||||
}
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Sort by start time
|
||||
programs.sort((a, b) => a.startTime.compareTo(b.startTime));
|
||||
return programs;
|
||||
}
|
||||
|
||||
DateTime _parseEpgTime(String timeStr) {
|
||||
try {
|
||||
// Handle various formats: "12:30", "12:30:00", unix timestamp
|
||||
if (timeStr.contains(':')) {
|
||||
final parts = timeStr.split(':');
|
||||
final hours = int.parse(parts[0]);
|
||||
final minutes = int.parse(parts[1]);
|
||||
final today = DateTime.now();
|
||||
return DateTime(today.year, today.month, today.day, hours, minutes);
|
||||
} else {
|
||||
return DateTime.fromMillisecondsSinceEpoch(int.parse(timeStr) * 1000);
|
||||
}
|
||||
} catch (e) {
|
||||
return DateTime.now();
|
||||
}
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return Scaffold(
|
||||
appBar: AppBar(
|
||||
title: const Text('EPG Guide'),
|
||||
bottom: TabBar(
|
||||
controller: _tabController,
|
||||
isScrollable: true,
|
||||
onTap: (index) {
|
||||
setState(() {
|
||||
_selectedDate = DateTime.now().add(Duration(days: index));
|
||||
});
|
||||
},
|
||||
tabs: List.generate(7, (index) {
|
||||
final date = DateTime.now().add(Duration(days: index));
|
||||
final day = DateFormat('EEE').format(date);
|
||||
final dateNum = DateFormat('d').format(date);
|
||||
return Tab(
|
||||
child: Column(
|
||||
mainAxisAlignment: MainAxisAlignment.center,
|
||||
children: [
|
||||
Text(day, style: const TextStyle(fontSize: 11)),
|
||||
Text(dateNum, style: const TextStyle(fontSize: 13, fontWeight: FontWeight.bold)),
|
||||
],
|
||||
),
|
||||
);
|
||||
}),
|
||||
),
|
||||
),
|
||||
body: _isLoading
|
||||
? const Center(child: CircularProgressIndicator())
|
||||
: _buildEpgGrid(),
|
||||
);
|
||||
}
|
||||
|
||||
Widget _buildEpgGrid() {
|
||||
if (_epgData.isEmpty) {
|
||||
return const Center(
|
||||
child: Text('No EPG data available'),
|
||||
);
|
||||
}
|
||||
|
||||
final channels = _epgData.keys.toList();
|
||||
|
||||
return Scrollbar(
|
||||
controller: _horizontalScroll,
|
||||
child: SingleChildScrollView(
|
||||
controller: _horizontalScroll,
|
||||
scrollDirection: Axis.horizontal,
|
||||
child: Column(
|
||||
children: [
|
||||
// Time headers
|
||||
SizedBox(
|
||||
height: 60,
|
||||
child: Row(
|
||||
children: [
|
||||
SizedBox(
|
||||
width: 150,
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
border: Border(
|
||||
right: BorderSide(color: Colors.grey[700]!),
|
||||
bottom: BorderSide(color: Colors.grey[700]!),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
...List.generate(24, (hour) {
|
||||
return Container(
|
||||
width: 100,
|
||||
height: 60,
|
||||
decoration: BoxDecoration(
|
||||
border: Border(
|
||||
right: BorderSide(color: Colors.grey[700]!),
|
||||
bottom: BorderSide(color: Colors.grey[700]!),
|
||||
),
|
||||
),
|
||||
child: Center(
|
||||
child: Text(
|
||||
'$hour:00',
|
||||
style: const TextStyle(fontSize: 11, fontWeight: FontWeight.bold),
|
||||
),
|
||||
),
|
||||
);
|
||||
}),
|
||||
],
|
||||
),
|
||||
),
|
||||
|
||||
// Channel rows
|
||||
Expanded(
|
||||
child: Scrollbar(
|
||||
controller: _verticalScroll,
|
||||
child: ListView.builder(
|
||||
controller: _verticalScroll,
|
||||
itemCount: channels.length,
|
||||
itemBuilder: (context, index) {
|
||||
final channelId = channels[index];
|
||||
final programs = _epgData[channelId] ?? [];
|
||||
|
||||
return _EpgChannelRow(
|
||||
channelId: channelId,
|
||||
programs: programs,
|
||||
onProgramTap: (program) {
|
||||
_showProgramDetail(program);
|
||||
},
|
||||
);
|
||||
},
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
void _showProgramDetail(EpgProgram program) {
|
||||
showModalBottomSheet(
|
||||
context: context,
|
||||
builder: (context) => _ProgramDetailSheet(program: program),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Individual channel row in EPG grid
|
||||
class _EpgChannelRow extends StatelessWidget {
|
||||
final String channelId;
|
||||
final List<EpgProgram> programs;
|
||||
final Function(EpgProgram) onProgramTap;
|
||||
|
||||
const _EpgChannelRow({
|
||||
required this.channelId,
|
||||
required this.programs,
|
||||
required this.onProgramTap,
|
||||
});
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return Row(
|
||||
children: [
|
||||
// Channel name
|
||||
Container(
|
||||
width: 150,
|
||||
height: 100,
|
||||
decoration: BoxDecoration(
|
||||
border: Border(
|
||||
right: BorderSide(color: Colors.grey[700]!),
|
||||
bottom: BorderSide(color: Colors.grey[700]!),
|
||||
),
|
||||
),
|
||||
child: Padding(
|
||||
padding: const EdgeInsets.all(8),
|
||||
child: Text(
|
||||
channelId,
|
||||
maxLines: 2,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(fontSize: 12, fontWeight: FontWeight.w500),
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
// Programs
|
||||
...programs.map((program) {
|
||||
final duration = program.duration.inMinutes;
|
||||
final width = (duration / 60 * 100).clamp(40, double.infinity).toDouble();
|
||||
|
||||
return GestureDetector(
|
||||
onTap: () => onProgramTap(program),
|
||||
child: Container(
|
||||
width: width,
|
||||
height: 100,
|
||||
decoration: BoxDecoration(
|
||||
color: program.isNow
|
||||
? Colors.blue.withOpacity(0.7)
|
||||
: program.isNext
|
||||
? Colors.purple.withOpacity(0.5)
|
||||
: Colors.grey[800],
|
||||
border: Border(
|
||||
right: BorderSide(color: Colors.grey[700]!),
|
||||
bottom: BorderSide(color: Colors.grey[700]!),
|
||||
),
|
||||
),
|
||||
child: Stack(
|
||||
fit: StackFit.expand,
|
||||
children: [
|
||||
// Program info
|
||||
Padding(
|
||||
padding: const EdgeInsets.all(4),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
Text(
|
||||
program.title,
|
||||
maxLines: 2,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(
|
||||
fontSize: 10,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 2),
|
||||
Text(
|
||||
'${DateFormat('HH:mm').format(program.startTime)} - ${DateFormat('HH:mm').format(program.endTime)}',
|
||||
maxLines: 1,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(fontSize: 8),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
|
||||
// Progress bar for now playing
|
||||
if (program.isNow)
|
||||
Positioned(
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
right: 0,
|
||||
child: ClipRRect(
|
||||
borderRadius: const BorderRadius.only(
|
||||
bottomLeft: Radius.circular(4),
|
||||
bottomRight: Radius.circular(4),
|
||||
),
|
||||
child: LinearProgressIndicator(
|
||||
value: program.progress / 100,
|
||||
minHeight: 3,
|
||||
backgroundColor: Colors.white24,
|
||||
valueColor:
|
||||
const AlwaysStoppedAnimation(Colors.red),
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
}),
|
||||
],
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Program detail bottom sheet
|
||||
class _ProgramDetailSheet extends StatelessWidget {
|
||||
final EpgProgram program;
|
||||
|
||||
const _ProgramDetailSheet({required this.program});
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return Container(
|
||||
padding: const EdgeInsets.all(16),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
Text(
|
||||
program.title,
|
||||
style: const TextStyle(
|
||||
fontSize: 22,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 8),
|
||||
Row(
|
||||
children: [
|
||||
Icon(
|
||||
program.isNow ? Icons.play_circle : Icons.schedule,
|
||||
color: program.isNow ? Colors.green : Colors.orange,
|
||||
size: 16,
|
||||
),
|
||||
const SizedBox(width: 8),
|
||||
Text(
|
||||
'${DateFormat('HH:mm').format(program.startTime)} - ${DateFormat('HH:mm').format(program.endTime)}',
|
||||
style: const TextStyle(fontSize: 14, color: Colors.grey),
|
||||
),
|
||||
const SizedBox(width: 16),
|
||||
Text(
|
||||
'${program.duration.inMinutes} min',
|
||||
style: const TextStyle(fontSize: 14, color: Colors.grey),
|
||||
),
|
||||
],
|
||||
),
|
||||
const SizedBox(height: 16),
|
||||
Text(
|
||||
program.description.isEmpty ? 'No description available' : program.description,
|
||||
style: const TextStyle(fontSize: 14),
|
||||
),
|
||||
const SizedBox(height: 24),
|
||||
Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
|
||||
children: [
|
||||
ElevatedButton.icon(
|
||||
onPressed: () => Navigator.pop(context),
|
||||
icon: const Icon(Icons.play_arrow),
|
||||
label: const Text('Watch Now'),
|
||||
),
|
||||
ElevatedButton.icon(
|
||||
onPressed: () => Navigator.pop(context),
|
||||
icon: const Icon(Icons.event),
|
||||
label: const Text('Add Reminder'),
|
||||
),
|
||||
],
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
import 'dart:io';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
|
||||
/// Represents a download task
|
||||
class DownloadTask {
|
||||
final String id;
|
||||
final String title;
|
||||
final String url;
|
||||
final String filePath;
|
||||
final DownloadStatus status;
|
||||
final double progress;
|
||||
final int? totalSize;
|
||||
final int downloadedSize;
|
||||
|
||||
DownloadTask({
|
||||
required this.id,
|
||||
required this.title,
|
||||
required this.url,
|
||||
required this.filePath,
|
||||
this.status = DownloadStatus.pending,
|
||||
this.progress = 0.0,
|
||||
this.totalSize,
|
||||
this.downloadedSize = 0,
|
||||
});
|
||||
|
||||
DownloadTask copyWith({
|
||||
DownloadStatus? status,
|
||||
double? progress,
|
||||
int? downloadedSize,
|
||||
}) =>
|
||||
DownloadTask(
|
||||
id: id,
|
||||
title: title,
|
||||
url: url,
|
||||
filePath: filePath,
|
||||
status: status ?? this.status,
|
||||
progress: progress ?? this.progress,
|
||||
totalSize: totalSize,
|
||||
downloadedSize: downloadedSize ?? this.downloadedSize,
|
||||
);
|
||||
}
|
||||
|
||||
enum DownloadStatus {
|
||||
pending,
|
||||
downloading,
|
||||
paused,
|
||||
completed,
|
||||
failed,
|
||||
cancelled,
|
||||
}
|
||||
|
||||
/// Service for managing downloads
|
||||
class DownloadService {
|
||||
static const _downloadDir = './downloads';
|
||||
static const _maxConcurrentDownloads = 3;
|
||||
static const _maxStorageGb = 50;
|
||||
|
||||
final List<DownloadTask> _downloads = [];
|
||||
final List<String> _activeDownloads = [];
|
||||
|
||||
/// Initialize download directory
|
||||
static Future<void> initialize() async {
|
||||
final dir = Directory(_downloadDir);
|
||||
if (!dir.existsSync()) {
|
||||
await dir.create(recursive: true);
|
||||
}
|
||||
}
|
||||
|
||||
/// Start a new download
|
||||
Future<DownloadTask> startDownload({
|
||||
required String id,
|
||||
required String title,
|
||||
required String url,
|
||||
}) async {
|
||||
final filePath = '$_downloadDir/$id.mp4';
|
||||
final task = DownloadTask(
|
||||
id: id,
|
||||
title: title,
|
||||
url: url,
|
||||
filePath: filePath,
|
||||
);
|
||||
|
||||
_downloads.add(task);
|
||||
_processDownloadQueue();
|
||||
return task;
|
||||
}
|
||||
|
||||
/// Pause download
|
||||
void pauseDownload(String id) {
|
||||
final index = _downloads.indexWhere((t) => t.id == id);
|
||||
if (index != -1) {
|
||||
_downloads[index] = _downloads[index].copyWith(
|
||||
status: DownloadStatus.paused,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Resume download
|
||||
void resumeDownload(String id) {
|
||||
final index = _downloads.indexWhere((t) => t.id == id);
|
||||
if (index != -1) {
|
||||
_downloads[index] = _downloads[index].copyWith(
|
||||
status: DownloadStatus.pending,
|
||||
);
|
||||
_processDownloadQueue();
|
||||
}
|
||||
}
|
||||
|
||||
/// Cancel download
|
||||
void cancelDownload(String id) {
|
||||
final index = _downloads.indexWhere((t) => t.id == id);
|
||||
if (index != -1) {
|
||||
_downloads.removeAt(index);
|
||||
_activeDownloads.remove(id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Get all downloads
|
||||
List<DownloadTask> getAllDownloads() => List.from(_downloads);
|
||||
|
||||
/// Get download progress
|
||||
double getDownloadProgress(String id) {
|
||||
final task = _downloads.firstWhere((t) => t.id == id, orElse: () => DownloadTask(
|
||||
id: id,
|
||||
title: '',
|
||||
url: '',
|
||||
filePath: '',
|
||||
));
|
||||
return task.progress;
|
||||
}
|
||||
|
||||
/// Get available storage
|
||||
Future<int> getAvailableStorage() async {
|
||||
final dir = Directory(_downloadDir);
|
||||
if (!dir.existsSync()) return _maxStorageGb * 1024 * 1024 * 1024;
|
||||
|
||||
int totalSize = 0;
|
||||
final files = dir.listSync(recursive: true);
|
||||
for (final file in files) {
|
||||
if (file is File) {
|
||||
totalSize += file.lengthSync();
|
||||
}
|
||||
}
|
||||
|
||||
return (_maxStorageGb * 1024 * 1024 * 1024) - totalSize;
|
||||
}
|
||||
|
||||
/// Clean up old downloads based on space
|
||||
Future<void> cleanupOldDownloads() async {
|
||||
final available = await getAvailableStorage();
|
||||
if (available < 1024 * 1024 * 1024) {
|
||||
// Less than 1GB free
|
||||
final dir = Directory(_downloadDir);
|
||||
final files = dir.listSync()
|
||||
.whereType<File>()
|
||||
.toList();
|
||||
|
||||
// Sort by modification time, delete oldest first
|
||||
files.sort((a, b) =>
|
||||
a.statSync().modified.compareTo(b.statSync().modified));
|
||||
|
||||
for (final file in files.take(files.length ~/ 3)) {
|
||||
try {
|
||||
file.deleteSync();
|
||||
} catch (e) {
|
||||
print('Error deleting file: $e');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Process download queue
|
||||
Future<void> _processDownloadQueue() async {
|
||||
while (_activeDownloads.length < _maxConcurrentDownloads) {
|
||||
final pendingIndex =
|
||||
_downloads.indexWhere((t) => t.status == DownloadStatus.pending);
|
||||
if (pendingIndex == -1) break;
|
||||
|
||||
final task = _downloads[pendingIndex];
|
||||
_activeDownloads.add(task.id);
|
||||
|
||||
_downloads[pendingIndex] =
|
||||
task.copyWith(status: DownloadStatus.downloading);
|
||||
|
||||
try {
|
||||
await _downloadFile(task);
|
||||
} catch (e) {
|
||||
print('Download error: $e');
|
||||
final index = _downloads.indexWhere((t) => t.id == task.id);
|
||||
if (index != -1) {
|
||||
_downloads[index] =
|
||||
_downloads[index].copyWith(status: DownloadStatus.failed);
|
||||
}
|
||||
} finally {
|
||||
_activeDownloads.remove(task.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Download file with progress tracking
|
||||
Future<void> _downloadFile(DownloadTask task) async {
|
||||
// Simplified version - in production use dio or http with progress tracking
|
||||
final file = File(task.filePath);
|
||||
if (!file.existsSync()) {
|
||||
file.createSync(recursive: true);
|
||||
}
|
||||
|
||||
// Stream download and update progress
|
||||
// This is a placeholder - implement with actual download logic
|
||||
for (int i = 0; i <= 100; i++) {
|
||||
final index = _downloads.indexWhere((t) => t.id == task.id);
|
||||
if (index != -1) {
|
||||
_downloads[index] = _downloads[index].copyWith(
|
||||
progress: i.toDouble(),
|
||||
);
|
||||
}
|
||||
|
||||
// Check if paused or cancelled
|
||||
final currentTask = _downloads.firstWhere((t) => t.id == task.id, orElse: () => task);
|
||||
if (currentTask.status == DownloadStatus.paused ||
|
||||
!_activeDownloads.contains(task.id)) {
|
||||
break;
|
||||
}
|
||||
|
||||
await Future.delayed(const Duration(milliseconds: 100));
|
||||
}
|
||||
|
||||
// Mark as completed
|
||||
final index = _downloads.indexWhere((t) => t.id == task.id);
|
||||
if (index != -1) {
|
||||
_downloads[index] = _downloads[index].copyWith(
|
||||
status: DownloadStatus.completed,
|
||||
progress: 100.0,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if file is available for offline playback
|
||||
bool isAvailableOffline(String id) {
|
||||
final task = _downloads.firstWhere(
|
||||
(t) => t.id == id,
|
||||
orElse: () => DownloadTask(
|
||||
id: id,
|
||||
title: '',
|
||||
url: '',
|
||||
filePath: '',
|
||||
),
|
||||
);
|
||||
if (task.status == DownloadStatus.completed) {
|
||||
return File(task.filePath).existsSync();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Get file path for offline content
|
||||
String? getOfflineFilePath(String id) {
|
||||
final task = _downloads.firstWhere(
|
||||
(t) => t.id == id && t.status == DownloadStatus.completed,
|
||||
orElse: () => DownloadTask(
|
||||
id: id,
|
||||
title: '',
|
||||
url: '',
|
||||
filePath: '',
|
||||
),
|
||||
);
|
||||
|
||||
if (File(task.filePath).existsSync()) {
|
||||
return task.filePath;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// Riverpod providers
|
||||
|
||||
final downloadServiceProvider = Provider<DownloadService>((ref) {
|
||||
return DownloadService();
|
||||
});
|
||||
|
||||
final downloadsProvider =
|
||||
StateNotifierProvider<DownloadsNotifier, List<DownloadTask>>((ref) {
|
||||
return DownloadsNotifier();
|
||||
});
|
||||
|
||||
class DownloadsNotifier extends StateNotifier<List<DownloadTask>> {
|
||||
DownloadsNotifier() : super([]);
|
||||
|
||||
void addDownload(DownloadTask task) {
|
||||
state = [...state, task];
|
||||
}
|
||||
|
||||
void updateDownload(DownloadTask task) {
|
||||
state = [
|
||||
for (final d in state)
|
||||
if (d.id == task.id) task else d,
|
||||
];
|
||||
}
|
||||
|
||||
void removeDownload(String id) {
|
||||
state = state.where((d) => d.id != id).toList();
|
||||
}
|
||||
|
||||
void clearCompleted() {
|
||||
state = state
|
||||
.where((d) => d.status != DownloadStatus.completed)
|
||||
.toList();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
import 'package:http/http.dart' as http;
|
||||
|
||||
/// Subtitle track information
|
||||
class SubtitleTrack {
|
||||
final String id;
|
||||
final String name;
|
||||
final String language;
|
||||
final String url;
|
||||
final bool isEnabled;
|
||||
|
||||
SubtitleTrack({
|
||||
required this.id,
|
||||
required this.name,
|
||||
required this.language,
|
||||
required this.url,
|
||||
this.isEnabled = false,
|
||||
});
|
||||
|
||||
SubtitleTrack copyWith({bool? isEnabled}) => SubtitleTrack(
|
||||
id: id,
|
||||
name: name,
|
||||
language: language,
|
||||
url: url,
|
||||
isEnabled: isEnabled ?? this.isEnabled,
|
||||
);
|
||||
}
|
||||
|
||||
/// Subtitle content with timing
|
||||
class SubtitleEntry {
|
||||
final int index;
|
||||
final Duration startTime;
|
||||
final Duration endTime;
|
||||
final String text;
|
||||
|
||||
SubtitleEntry({
|
||||
required this.index,
|
||||
required this.startTime,
|
||||
required this.endTime,
|
||||
required this.text,
|
||||
});
|
||||
}
|
||||
|
||||
/// Service for handling subtitles
|
||||
class SubtitleService {
|
||||
static const _srtPattern = r'(\d+)\n(\d{2}):(\d{2}):(\d{2}),(\d{3}) --> (\d{2}):(\d{2}):(\d{2}),(\d{3})\n([\s\S]*?)(?=\n\n|\Z)';
|
||||
|
||||
/// Parse SRT subtitle content
|
||||
static List<SubtitleEntry> parseSrt(String content) {
|
||||
final entries = <SubtitleEntry>[];
|
||||
final blocks = content.split('\n\n');
|
||||
|
||||
for (final block in blocks) {
|
||||
if (block.trim().isEmpty) continue;
|
||||
|
||||
final lines = block.trim().split('\n');
|
||||
if (lines.length < 3) continue;
|
||||
|
||||
try {
|
||||
final index = int.parse(lines[0]);
|
||||
final timeLine = lines[1];
|
||||
final text = lines.sublist(2).join('\n').trim();
|
||||
|
||||
// Parse timing: 00:00:01,000 --> 00:00:05,000
|
||||
final times = timeLine.split('-->');
|
||||
if (times.length != 2) continue;
|
||||
|
||||
final startTime = _parseTime(times[0].trim());
|
||||
final endTime = _parseTime(times[1].trim());
|
||||
|
||||
entries.add(SubtitleEntry(
|
||||
index: index,
|
||||
startTime: startTime,
|
||||
endTime: endTime,
|
||||
text: text,
|
||||
));
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return entries;
|
||||
}
|
||||
|
||||
/// Parse WebVTT subtitle content
|
||||
static List<SubtitleEntry> parseWebVtt(String content) {
|
||||
final entries = <SubtitleEntry>[];
|
||||
final blocks = content.split('\n\n');
|
||||
|
||||
for (final block in blocks) {
|
||||
if (block.trim().isEmpty || block.startsWith('WEBVTT')) continue;
|
||||
|
||||
final lines = block.trim().split('\n');
|
||||
if (lines.length < 2) continue;
|
||||
|
||||
try {
|
||||
final timeLine = lines[0];
|
||||
final text = lines.sublist(1).join('\n').trim();
|
||||
|
||||
// Parse timing: 00:00:01.000 --> 00:00:05.000
|
||||
final times = timeLine.split('-->');
|
||||
if (times.length != 2) continue;
|
||||
|
||||
final startTime = _parseWebVttTime(times[0].trim());
|
||||
final endTime = _parseWebVttTime(times[1].trim());
|
||||
|
||||
entries.add(SubtitleEntry(
|
||||
index: entries.length,
|
||||
startTime: startTime,
|
||||
endTime: endTime,
|
||||
text: text,
|
||||
));
|
||||
} catch (e) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return entries;
|
||||
}
|
||||
|
||||
/// Get subtitle at specific time
|
||||
static String? getSubtitleAtTime(List<SubtitleEntry> entries, Duration time) {
|
||||
for (final entry in entries) {
|
||||
if (time.compareTo(entry.startTime) >= 0 && time.compareTo(entry.endTime) <= 0) {
|
||||
return entry.text;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Download subtitle from URL
|
||||
static Future<String> downloadSubtitle(String url) async {
|
||||
try {
|
||||
final response = await http.get(Uri.parse(url));
|
||||
if (response.statusCode == 200) {
|
||||
return response.body;
|
||||
}
|
||||
throw Exception('Failed to download subtitle: ${response.statusCode}');
|
||||
} catch (e) {
|
||||
throw Exception('Error downloading subtitle: $e');
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse time format HH:MM:SS,mmm (SRT)
|
||||
static Duration _parseTime(String time) {
|
||||
final parts = time.split(':');
|
||||
final hours = int.parse(parts[0]);
|
||||
final minutes = int.parse(parts[1]);
|
||||
final secondsParts = parts[2].split(',');
|
||||
final seconds = int.parse(secondsParts[0]);
|
||||
final milliseconds = int.parse(secondsParts[1]);
|
||||
|
||||
return Duration(
|
||||
hours: hours,
|
||||
minutes: minutes,
|
||||
seconds: seconds,
|
||||
milliseconds: milliseconds,
|
||||
);
|
||||
}
|
||||
|
||||
/// Parse time format HH:MM:SS.mmm (WebVTT)
|
||||
static Duration _parseWebVttTime(String time) {
|
||||
final parts = time.split(':');
|
||||
final hours = int.parse(parts[0]);
|
||||
final minutes = int.parse(parts[1]);
|
||||
final secondsParts = parts[2].split('.');
|
||||
final seconds = int.parse(secondsParts[0]);
|
||||
final milliseconds = int.parse(secondsParts[1].padEnd(3, '0'));
|
||||
|
||||
return Duration(
|
||||
hours: hours,
|
||||
minutes: minutes,
|
||||
seconds: seconds,
|
||||
milliseconds: milliseconds,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,535 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import 'package:cached_network_image/cached_network_image.dart';
|
||||
import '../providers/recommendations_provider.dart';
|
||||
import '../../../core/models/playlist_config.dart';
|
||||
import '../models/playlist.dart';
|
||||
|
||||
/// Widget showing "Continue Watching" section
|
||||
class ContinueWatchingWidget extends ConsumerStatefulWidget {
|
||||
final Playlist playlist;
|
||||
final List<Playlist> content;
|
||||
final VoidCallback? onItemTap;
|
||||
|
||||
const ContinueWatchingWidget({
|
||||
Key? key,
|
||||
required this.playlist,
|
||||
required this.content,
|
||||
this.onItemTap,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
ConsumerState<ContinueWatchingWidget> createState() =>
|
||||
_ContinueWatchingWidgetState();
|
||||
}
|
||||
|
||||
class _ContinueWatchingWidgetState
|
||||
extends ConsumerState<ContinueWatchingWidget> {
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final watchHistory = ref.watch(watchHistoryProvider);
|
||||
final continueWatching =
|
||||
RecommendationService.getContinueWatching(watchHistory, widget.content);
|
||||
|
||||
if (continueWatching.isEmpty) {
|
||||
return const SizedBox.shrink();
|
||||
}
|
||||
|
||||
return Container(
|
||||
margin: const EdgeInsets.symmetric(vertical: 12),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
||||
children: [
|
||||
const Text(
|
||||
'Continue Watching',
|
||||
style: TextStyle(
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
TextButton(
|
||||
onPressed: () {
|
||||
// Navigate to full continue watching list
|
||||
},
|
||||
child: const Text('View All'),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
SingleChildScrollView(
|
||||
scrollDirection: Axis.horizontal,
|
||||
child: Row(
|
||||
children: [
|
||||
const SizedBox(width: 16),
|
||||
...continueWatching.take(5).map((rec) {
|
||||
final item = rec.item;
|
||||
final percentage = watchHistory[item.streamId.toString()]
|
||||
is Map
|
||||
? (watchHistory[item.streamId.toString()]
|
||||
as Map)['percentage'] as double? ??
|
||||
0.0
|
||||
: 0.0;
|
||||
|
||||
return Container(
|
||||
margin: const EdgeInsets.only(right: 12),
|
||||
child: _ContinueWatchingCard(
|
||||
item: item,
|
||||
progress: percentage,
|
||||
onTap: widget.onItemTap,
|
||||
),
|
||||
);
|
||||
}),
|
||||
const SizedBox(width: 8),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
class _ContinueWatchingCard extends StatelessWidget {
|
||||
final Playlist item;
|
||||
final double progress;
|
||||
final VoidCallback? onTap;
|
||||
|
||||
const _ContinueWatchingCard({
|
||||
required this.item,
|
||||
required this.progress,
|
||||
this.onTap,
|
||||
});
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return GestureDetector(
|
||||
onTap: onTap,
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
// Poster with progress bar
|
||||
Container(
|
||||
width: 160,
|
||||
height: 240,
|
||||
decoration: BoxDecoration(
|
||||
borderRadius: BorderRadius.circular(8),
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
child: Stack(
|
||||
fit: StackFit.expand,
|
||||
children: [
|
||||
// Poster image
|
||||
ClipRRect(
|
||||
borderRadius: BorderRadius.circular(8),
|
||||
child: CachedNetworkImage(
|
||||
imageUrl: item.cover ?? '',
|
||||
fit: BoxFit.cover,
|
||||
placeholder: (context, url) => Container(
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
errorWidget: (context, url, error) =>
|
||||
Icon(Icons.image_not_supported,
|
||||
color: Colors.grey[600]),
|
||||
),
|
||||
),
|
||||
|
||||
// Dark overlay at bottom
|
||||
Positioned(
|
||||
bottom: 0,
|
||||
left: 0,
|
||||
right: 0,
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
gradient: LinearGradient(
|
||||
begin: Alignment.topCenter,
|
||||
end: Alignment.bottomCenter,
|
||||
colors: [
|
||||
Colors.transparent,
|
||||
Colors.black.withOpacity(0.8),
|
||||
],
|
||||
),
|
||||
),
|
||||
padding: const EdgeInsets.all(8),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
// Progress bar
|
||||
ClipRRect(
|
||||
borderRadius: BorderRadius.circular(2),
|
||||
child: LinearProgressIndicator(
|
||||
value: progress / 100.0,
|
||||
minHeight: 3,
|
||||
backgroundColor: Colors.white30,
|
||||
valueColor: AlwaysStoppedAnimation<Color>(
|
||||
_getProgressColor(progress),
|
||||
),
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 4),
|
||||
Text(
|
||||
'${progress.toStringAsFixed(0)}% watched',
|
||||
style: const TextStyle(
|
||||
color: Colors.white,
|
||||
fontSize: 11,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
// Play button overlay on hover
|
||||
Positioned(
|
||||
top: 0,
|
||||
right: 0,
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
color: Colors.blue.withOpacity(0.7),
|
||||
shape: BoxShape.circle,
|
||||
),
|
||||
padding: const EdgeInsets.all(8),
|
||||
margin: const EdgeInsets.all(8),
|
||||
child: const Icon(
|
||||
Icons.play_arrow,
|
||||
color: Colors.white,
|
||||
size: 24,
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
const SizedBox(height: 8),
|
||||
|
||||
// Title
|
||||
SizedBox(
|
||||
width: 160,
|
||||
child: Text(
|
||||
item.name ?? 'Unknown',
|
||||
maxLines: 2,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(
|
||||
fontSize: 12,
|
||||
fontWeight: FontWeight.w500,
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
Color _getProgressColor(double progress) {
|
||||
if (progress < 30) return Colors.red;
|
||||
if (progress < 70) return Colors.orange;
|
||||
return Colors.green;
|
||||
}
|
||||
}
|
||||
|
||||
/// Widget showing trending/popular content
|
||||
class TrendingWidget extends ConsumerWidget {
|
||||
final Playlist playlist;
|
||||
final List<Playlist> content;
|
||||
final VoidCallback? onItemTap;
|
||||
|
||||
const TrendingWidget({
|
||||
Key? key,
|
||||
required this.playlist,
|
||||
required this.content,
|
||||
this.onItemTap,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context, WidgetRef ref) {
|
||||
final trending = ref.watch(trendingProvider);
|
||||
final trendingContent =
|
||||
RecommendationService.getTrending(trending, content);
|
||||
|
||||
if (trendingContent.isEmpty) {
|
||||
return const SizedBox.shrink();
|
||||
}
|
||||
|
||||
return Container(
|
||||
margin: const EdgeInsets.symmetric(vertical: 12),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
||||
children: [
|
||||
Row(
|
||||
children: [
|
||||
const Icon(Icons.local_fire_department,
|
||||
color: Colors.red, size: 24),
|
||||
const SizedBox(width: 8),
|
||||
const Text(
|
||||
'Trending Now',
|
||||
style: TextStyle(
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
TextButton(
|
||||
onPressed: () {},
|
||||
child: const Text('View All'),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
SingleChildScrollView(
|
||||
scrollDirection: Axis.horizontal,
|
||||
child: Row(
|
||||
children: [
|
||||
const SizedBox(width: 16),
|
||||
...trendingContent.take(5).map((rec) {
|
||||
final item = rec.item;
|
||||
final rank = trendingContent.indexOf(rec) + 1;
|
||||
|
||||
return Container(
|
||||
margin: const EdgeInsets.only(right: 12),
|
||||
child: _TrendingCard(
|
||||
item: item,
|
||||
rank: rank,
|
||||
onTap: onItemTap,
|
||||
),
|
||||
);
|
||||
}),
|
||||
const SizedBox(width: 8),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
class _TrendingCard extends StatelessWidget {
|
||||
final Playlist item;
|
||||
final int rank;
|
||||
final VoidCallback? onTap;
|
||||
|
||||
const _TrendingCard({
|
||||
required this.item,
|
||||
required this.rank,
|
||||
this.onTap,
|
||||
});
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return GestureDetector(
|
||||
onTap: onTap,
|
||||
child: Stack(
|
||||
children: [
|
||||
// Card
|
||||
Container(
|
||||
width: 180,
|
||||
height: 260,
|
||||
decoration: BoxDecoration(
|
||||
borderRadius: BorderRadius.circular(12),
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
child: Column(
|
||||
children: [
|
||||
// Image
|
||||
Expanded(
|
||||
child: ClipRRect(
|
||||
borderRadius: const BorderRadius.only(
|
||||
topLeft: Radius.circular(12),
|
||||
topRight: Radius.circular(12),
|
||||
),
|
||||
child: CachedNetworkImage(
|
||||
imageUrl: item.cover ?? '',
|
||||
fit: BoxFit.cover,
|
||||
placeholder: (context, url) => Container(
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
errorWidget: (context, url, error) =>
|
||||
Icon(Icons.image_not_supported,
|
||||
color: Colors.grey[600]),
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
// Info
|
||||
Padding(
|
||||
padding: const EdgeInsets.all(8),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
Text(
|
||||
item.name ?? 'Unknown',
|
||||
maxLines: 1,
|
||||
overflow: TextOverflow.ellipsis,
|
||||
style: const TextStyle(
|
||||
fontSize: 13,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
if (item.rating != null)
|
||||
Row(
|
||||
children: [
|
||||
const Icon(Icons.star,
|
||||
color: Colors.amber, size: 12),
|
||||
const SizedBox(width: 4),
|
||||
Text(
|
||||
item.rating ?? '0',
|
||||
style: const TextStyle(fontSize: 11),
|
||||
),
|
||||
],
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
|
||||
// Rank badge
|
||||
Positioned(
|
||||
top: 8,
|
||||
left: 8,
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
color: _getRankColor(rank),
|
||||
shape: BoxShape.circle,
|
||||
),
|
||||
width: 40,
|
||||
height: 40,
|
||||
child: Center(
|
||||
child: Text(
|
||||
'#$rank',
|
||||
style: const TextStyle(
|
||||
color: Colors.white,
|
||||
fontWeight: FontWeight.bold,
|
||||
fontSize: 14,
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
Color _getRankColor(int rank) {
|
||||
switch (rank) {
|
||||
case 1:
|
||||
return Colors.amber.shade700;
|
||||
case 2:
|
||||
return Colors.grey.shade600;
|
||||
case 3:
|
||||
return Colors.orange.shade700;
|
||||
default:
|
||||
return Colors.blue.shade700;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Widget showing recently added content
|
||||
class RecentlyAddedWidget extends ConsumerWidget {
|
||||
final Playlist playlist;
|
||||
final List<Playlist> content;
|
||||
final VoidCallback? onItemTap;
|
||||
|
||||
const RecentlyAddedWidget({
|
||||
Key? key,
|
||||
required this.playlist,
|
||||
required this.content,
|
||||
this.onItemTap,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context, WidgetRef ref) {
|
||||
final recent = RecommendationService.getRecentlyAdded(content);
|
||||
|
||||
if (recent.isEmpty) {
|
||||
return const SizedBox.shrink();
|
||||
}
|
||||
|
||||
return Container(
|
||||
margin: const EdgeInsets.symmetric(vertical: 12),
|
||||
child: Column(
|
||||
crossAxisAlignment: CrossAxisAlignment.start,
|
||||
children: [
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
||||
child: const Text(
|
||||
'Recently Added',
|
||||
style: TextStyle(
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
),
|
||||
SingleChildScrollView(
|
||||
scrollDirection: Axis.horizontal,
|
||||
child: Row(
|
||||
children: [
|
||||
const SizedBox(width: 16),
|
||||
...recent.take(5).map((rec) {
|
||||
return Container(
|
||||
margin: const EdgeInsets.only(right: 12),
|
||||
child: _RecentCard(
|
||||
item: rec.item,
|
||||
onTap: onItemTap,
|
||||
),
|
||||
);
|
||||
}),
|
||||
const SizedBox(width: 8),
|
||||
],
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
class _RecentCard extends StatelessWidget {
|
||||
final Playlist item;
|
||||
final VoidCallback? onTap;
|
||||
|
||||
const _RecentCard({
|
||||
required this.item,
|
||||
this.onTap,
|
||||
});
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
return GestureDetector(
|
||||
onTap: onTap,
|
||||
child: Container(
|
||||
width: 140,
|
||||
height: 200,
|
||||
decoration: BoxDecoration(
|
||||
borderRadius: BorderRadius.circular(8),
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
child: ClipRRect(
|
||||
borderRadius: BorderRadius.circular(8),
|
||||
child: CachedNetworkImage(
|
||||
imageUrl: item.cover ?? '',
|
||||
fit: BoxFit.cover,
|
||||
placeholder: (context, url) => Container(
|
||||
color: Colors.grey[800],
|
||||
),
|
||||
errorWidget: (context, url, error) =>
|
||||
Icon(Icons.image_not_supported, color: Colors.grey[600]),
|
||||
),
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import '../../core/services/adaptive_bitrate_service.dart';
|
||||
|
||||
/// Widget for displaying and selecting video quality during playback
|
||||
class QualitySelectorWidget extends ConsumerStatefulWidget {
|
||||
final QualitySelector qualitySelector;
|
||||
final VoidCallback onClose;
|
||||
|
||||
const QualitySelectorWidget({
|
||||
Key? key,
|
||||
required this.qualitySelector,
|
||||
required this.onClose,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
ConsumerState<QualitySelectorWidget> createState() =>
|
||||
_QualitySelectorWidgetState();
|
||||
}
|
||||
|
||||
class _QualitySelectorWidgetState extends ConsumerState<QualitySelectorWidget> {
|
||||
late List<QualityLevel> _availableQualities;
|
||||
late QualityLevel _selectedQuality;
|
||||
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_availableQualities = QualityProfiles.getBalancedProfiles();
|
||||
_selectedQuality = widget.qualitySelector.currentQuality;
|
||||
}
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context) {
|
||||
final currentQuality = widget.qualitySelector.currentQuality;
|
||||
final bandwidthMbps = widget.qualitySelector.getEstimatedBandwidthMbps();
|
||||
|
||||
return Dialog(
|
||||
backgroundColor: Colors.black87,
|
||||
insetPadding: const EdgeInsets.all(16),
|
||||
child: Column(
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
// Header
|
||||
Container(
|
||||
padding: const EdgeInsets.all(16),
|
||||
decoration: BoxDecoration(
|
||||
border: Border(
|
||||
bottom: BorderSide(color: Colors.white24),
|
||||
),
|
||||
),
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
||||
children: [
|
||||
const Text(
|
||||
'Video Quality',
|
||||
style: TextStyle(
|
||||
color: Colors.white,
|
||||
fontSize: 18,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
IconButton(
|
||||
icon: const Icon(Icons.close, color: Colors.white),
|
||||
onPressed: widget.onClose,
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
|
||||
// Network Info
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
|
||||
child: Container(
|
||||
padding: const EdgeInsets.all(12),
|
||||
decoration: BoxDecoration(
|
||||
color: Colors.white10,
|
||||
borderRadius: BorderRadius.circular(8),
|
||||
),
|
||||
child: Row(
|
||||
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
||||
children: [
|
||||
const Text(
|
||||
'Current Bandwidth:',
|
||||
style: TextStyle(color: Colors.white70, fontSize: 14),
|
||||
),
|
||||
Text(
|
||||
'${bandwidthMbps.toStringAsFixed(1)} Mbps',
|
||||
style: const TextStyle(
|
||||
color: Colors.white,
|
||||
fontSize: 14,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
// Quality Options
|
||||
ListView.builder(
|
||||
shrinkWrap: true,
|
||||
itemCount: _availableQualities.length,
|
||||
itemBuilder: (context, index) {
|
||||
final quality = _availableQualities[index];
|
||||
final isSelected = quality == currentQuality;
|
||||
|
||||
return ListTile(
|
||||
contentPadding:
|
||||
const EdgeInsets.symmetric(horizontal: 24, vertical: 8),
|
||||
leading: isSelected
|
||||
? const Icon(Icons.check_circle, color: Colors.blue)
|
||||
: const Icon(Icons.radio_button_unchecked,
|
||||
color: Colors.white30),
|
||||
title: Text(
|
||||
quality.label,
|
||||
style: TextStyle(
|
||||
color: isSelected ? Colors.blue : Colors.white,
|
||||
fontWeight: isSelected ? FontWeight.bold : FontWeight.normal,
|
||||
),
|
||||
),
|
||||
subtitle: Text(
|
||||
'${quality.bitrateBps ~/ 1000000} Mbps',
|
||||
style: const TextStyle(color: Colors.white70, fontSize: 12),
|
||||
),
|
||||
onTap: () {
|
||||
widget.qualitySelector.setQuality(quality);
|
||||
setState(() {
|
||||
_selectedQuality = quality;
|
||||
});
|
||||
},
|
||||
);
|
||||
},
|
||||
),
|
||||
|
||||
// Auto Quality Option
|
||||
Padding(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
|
||||
child: Container(
|
||||
decoration: BoxDecoration(
|
||||
border: Border(
|
||||
top: BorderSide(color: Colors.white24),
|
||||
),
|
||||
),
|
||||
child: ListTile(
|
||||
contentPadding:
|
||||
const EdgeInsets.symmetric(horizontal: 8, vertical: 8),
|
||||
leading: const Icon(Icons.auto_awesome, color: Colors.amber),
|
||||
title: const Text(
|
||||
'Auto Quality',
|
||||
style: TextStyle(
|
||||
color: Colors.amber,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
subtitle: const Text(
|
||||
'Adjusts based on network speed',
|
||||
style: TextStyle(color: Colors.white70, fontSize: 12),
|
||||
),
|
||||
onTap: () {
|
||||
// Auto mode would be handled by the player
|
||||
widget.onClose();
|
||||
},
|
||||
),
|
||||
),
|
||||
),
|
||||
|
||||
const SizedBox(height: 8),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Floating quality indicator (minimal UI during playback)
|
||||
class QualityIndicator extends ConsumerWidget {
|
||||
final QualitySelector qualitySelector;
|
||||
final VoidCallback onTap;
|
||||
|
||||
const QualityIndicator({
|
||||
Key? key,
|
||||
required this.qualitySelector,
|
||||
required this.onTap,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context, WidgetRef ref) {
|
||||
final quality = qualitySelector.currentQuality;
|
||||
|
||||
return GestureDetector(
|
||||
onTap: onTap,
|
||||
child: Container(
|
||||
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
|
||||
decoration: BoxDecoration(
|
||||
color: Colors.black54,
|
||||
borderRadius: BorderRadius.circular(4),
|
||||
),
|
||||
child: Row(
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
const Icon(Icons.high_quality, color: Colors.white, size: 16),
|
||||
const SizedBox(width: 4),
|
||||
Text(
|
||||
quality.resolution.split('x')[1], // Show just the height
|
||||
style: const TextStyle(
|
||||
color: Colors.white,
|
||||
fontSize: 12,
|
||||
fontWeight: FontWeight.bold,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Bandwidth monitor widget (for debugging/info)
|
||||
class BandwidthMonitor extends ConsumerWidget {
|
||||
final QualitySelector qualitySelector;
|
||||
|
||||
const BandwidthMonitor({
|
||||
Key? key,
|
||||
required this.qualitySelector,
|
||||
}) : super(key: key);
|
||||
|
||||
@override
|
||||
Widget build(BuildContext context, WidgetRef ref) {
|
||||
return Container(
|
||||
padding: const EdgeInsets.all(8),
|
||||
decoration: BoxDecoration(
|
||||
color: Colors.black54,
|
||||
borderRadius: BorderRadius.circular(4),
|
||||
),
|
||||
child: Row(
|
||||
mainAxisSize: MainAxisSize.min,
|
||||
children: [
|
||||
const Icon(Icons.speed, color: Colors.green, size: 14),
|
||||
const SizedBox(width: 4),
|
||||
Text(
|
||||
'${qualitySelector.getEstimatedBandwidthMbps().toStringAsFixed(1)} Mbps',
|
||||
style: const TextStyle(
|
||||
color: Colors.white,
|
||||
fontSize: 11,
|
||||
),
|
||||
),
|
||||
],
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user