feat: introduce XtreamServiceMobile for IPTV API interactions and DnsFallbackInterceptor for network robustness.

lib/mobile/features/iptv/screens/lite_player_screen.dart

@@ -0,0 +1,586 @@
+import 'dart:async';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:video_player/video_player.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:xtremflow/mobile/widgets/tv_focusable.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:xtremflow/core/models/iptv_models.dart';
+import 'package:xtremflow/core/models/playlist_config.dart';
+import 'package:xtremflow/features/iptv/services/xtream_service_mobile.dart';
+import 'package:xtremflow/mobile/providers/mobile_settings_providers.dart';
+import 'package:xtremflow/core/theme/app_colors.dart';
+import 'package:xtremflow/mobile/providers/mobile_xtream_providers.dart';
+import 'package:xtremflow/mobile/features/iptv/screens/native_player_screen.dart' show StreamType;
+import 'package:xtremflow/features/iptv/models/xtream_models.dart' as xm;
+
+/// Lite version of the player using standard video_player (ExoPlayer on Android)
+/// Targeted for 1GB RAM devices where MPV is too heavy.
+class LitePlayerScreen extends ConsumerStatefulWidget {
+  final String streamId;
+  final String title;
+  final StreamType streamType;
+  final String? containerExtension;
+  final PlaylistConfig playlist;
+  final List<Channel>? channels;
+  final int initialIndex;
+  
+  // For series episodes
+  final dynamic seriesId;
+  final int? season;
+  final int? episodeNum;
+
+  const LitePlayerScreen({
+    super.key,
+    required this.streamId,
+    required this.title,
+    required this.playlist,
+    required this.streamType,
+    this.containerExtension,
+    this.channels,
+    this.initialIndex = 0,
+    this.seriesId,
+    this.season,
+    this.episodeNum,
+  });
+
+  @override
+  ConsumerState<LitePlayerScreen> createState() => _LitePlayerScreenState();
+}
+
+class _LitePlayerScreenState extends ConsumerState<LitePlayerScreen> with WidgetsBindingObserver {
+  VideoPlayerController? _controller;
+  XtreamServiceMobile? _xtreamService;
+  
+  bool _isLoading = true;
+  String? _errorMessage;
+  late int _currentIndex;
+  bool _showControls = true;
+  bool _isPlaying = false;
+  
+  // EPG
+  xm.ShortEPG? _epg;
+  Timer? _epgTimer;
+  
+  // Progress & Seeking
+  Duration _position = Duration.zero;
+  Duration _duration = Duration.zero;
+  bool _isSeeking = false;
+  
+  // Focus Nodes
+  final FocusNode _playPauseFocusNode = FocusNode();
+  final FocusNode _backFocusNode = FocusNode();
+
+  Timer? _controlsTimer;
+  Timer? _clockTimer;
+  String _currentTime = '';
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addObserver(this);
+    HardwareKeyboard.instance.addHandler(_handleKeyEvent);
+    
+    _currentIndex = widget.initialIndex;
+    _startClock();
+    
+    // Lock orientation
+    SystemChrome.setPreferredOrientations([
+      DeviceOrientation.landscapeLeft,
+      DeviceOrientation.landscapeRight,
+    ]);
+    SystemChrome.setEnabledSystemUIMode(SystemUiMode.immersiveSticky);
+
+    _initializeService();
+  }
+
+  Future<void> _initializeService() async {
+    try {
+      final dir = await getApplicationDocumentsDirectory();
+      _xtreamService = XtreamServiceMobile(dir.path);
+      await _xtreamService!.setPlaylistAsync(widget.playlist);
+      _loadStream();
+      _updateEPG(); // Initial Load
+      
+      // Update EPG periodically for Live TV
+      if (widget.streamType == StreamType.live) {
+        _epgTimer = Timer.periodic(const Duration(minutes: 5), (_) => _updateEPG());
+      }
+    } catch (e) {
+      if (mounted) setState(() => _errorMessage = "Service Error: $e");
+    }
+  }
+  
+  Future<void> _updateEPG() async {
+    if (widget.streamType != StreamType.live || _xtreamService == null) return;
+    
+    try {
+      final currentChannelId = widget.channels?[_currentIndex].streamId ?? widget.streamId;
+      // Get EPG for current channel
+      final epgData = await _xtreamService!.getShortEPG(currentChannelId);
+      if (mounted) {
+        setState(() => _epg = epgData);
+      }
+    } catch (_) {}
+  }
+
+  Future<void> _loadStream() async {
+    if (_xtreamService == null) return;
+
+    // cleanup previous
+    await _controller?.dispose();
+    _controller = null;
+
+    if (!mounted) return;
+    setState(() {
+      _isLoading = true;
+      _errorMessage = null;
+    });
+
+    try {
+      final currentStreamId = widget.channels != null && widget.channels!.isNotEmpty
+          ? widget.channels![_currentIndex].streamId 
+          : widget.streamId;
+          
+      // Update EPG when changing channels
+      if (widget.streamType == StreamType.live) {
+         _updateEPG();
+      }
+
+      String streamUrl;
+      if (widget.streamType == StreamType.live) {
+        streamUrl = _xtreamService!.getLiveStreamUrl(currentStreamId);
+      } else if (widget.streamType == StreamType.vod) {
+        streamUrl = _xtreamService!.getVodStreamUrl(currentStreamId, widget.containerExtension ?? 'mp4');
+      } else {
+        streamUrl = _xtreamService!.getSeriesStreamUrl(currentStreamId, widget.containerExtension ?? 'mp4');
+      }
+
+      final controller = VideoPlayerController.networkUrl(
+        Uri.parse(streamUrl),
+        httpHeaders: {'User-Agent': 'XtremFlow/1.0'},
+      );
+
+      _controller = controller;
+      await controller.initialize();
+      
+      if (!mounted) {
+        await controller.dispose();
+        return;
+      }
+
+      await controller.play();
+      setState(() {
+        _isLoading = false;
+        _isPlaying = true;
+        _duration = controller.value.duration;
+      });
+      _resetControlsTimer();
+      
+      // Listen for errors and completion via controller listener
+      controller.addListener(_videoListener);
+      
+    } catch (e) {
+      if (mounted) {
+        setState(() {
+          _isLoading = false;
+          _errorMessage = "Playback Error: $e";
+        });
+      }
+    }
+  }
+
+  void _videoListener() {
+    if (_controller == null || !mounted) return;
+    
+    // Update Play/Pause state
+    final isPlaying = _controller!.value.isPlaying;
+    if (isPlaying != _isPlaying) {
+      setState(() => _isPlaying = isPlaying);
+    }
+    
+    // Update Duration/Position (if not seeking)
+    if (!_isSeeking) {
+        final pos = _controller!.value.position;
+        final dur = _controller!.value.duration;
+        if (pos != _position || dur != _duration) {
+             setState(() {
+               _position = pos;
+               _duration = dur;
+             });
+        }
+    }
+    
+    if (_controller!.value.hasError) {
+      setState(() => _errorMessage = _controller!.value.errorDescription);
+    }
+  }
+
+  void _onUserInteraction() {
+    setState(() => _showControls = true);
+    _resetControlsTimer();
+  }
+
+  void _resetControlsTimer() {
+    _controlsTimer?.cancel();
+    if (_showControls && _isPlaying) {
+      _controlsTimer = Timer(const Duration(seconds: 5), () {
+        if (mounted) setState(() => _showControls = false);
+      });
+    }
+  }
+
+  void _togglePlayPause() {
+    if (_controller == null) return;
+    if (_controller!.value.isPlaying) {
+      _controller!.pause();
+    } else {
+      _controller!.play();
+    }
+    _onUserInteraction();
+  }
+  
+  void _playNext() {
+    if (widget.channels == null || widget.channels!.isEmpty) return;
+    final nextIndex = (_currentIndex + 1) % widget.channels!.length;
+    _switchChannel(nextIndex);
+  }
+
+  void _playPrevious() {
+    if (widget.channels == null || widget.channels!.isEmpty) return;
+    final prevIndex = (_currentIndex - 1 + widget.channels!.length) % widget.channels!.length;
+    _switchChannel(prevIndex);
+  }
+
+  void _switchChannel(int index) {
+    setState(() => _currentIndex = index);
+    _loadStream();
+  }
+  
+  Future<void> _seek(Duration offset) async {
+    if (_controller == null || !_controller!.value.isInitialized) return;
+    final newPos = _controller!.value.position + offset;
+    final clamped = Duration(
+       milliseconds: newPos.inMilliseconds.clamp(0, _controller!.value.duration.inMilliseconds)
+    );
+    await _controller!.seekTo(clamped);
+    _onUserInteraction();
+  }
+
+  // Simplified Key Handler
+  bool _handleKeyEvent(KeyEvent event) {
+    if (event is! KeyDownEvent) return false;
+    final key = event.logicalKey;
+    
+    // Media Keys (Remote)
+    if (key == LogicalKeyboardKey.mediaPlay || key == LogicalKeyboardKey.mediaPause || key == LogicalKeyboardKey.mediaPlayPause) {
+       _togglePlayPause();
+       return true;
+    }
+
+    if (key == LogicalKeyboardKey.select || key == LogicalKeyboardKey.enter || key == LogicalKeyboardKey.space) {
+       if (!_showControls) {
+         _onUserInteraction();
+         return true;
+       }
+       // If controls visible, let focus system handle it
+       return false;
+    }
+    
+    // Seek / Channel Change
+
+    if (key == LogicalKeyboardKey.arrowDown || key == LogicalKeyboardKey.channelDown) {
+      // User requested "Down" => Previous Channel (Index - 1)
+      if (widget.streamType == StreamType.live) {
+         _playPrevious();
+         _onUserInteraction(); // Show OSD
+      }
+      return true;
+    }
+
+    if (key == LogicalKeyboardKey.arrowUp || key == LogicalKeyboardKey.channelUp) { 
+        // User requested "Up" => Next Channel (Index + 1)
+        if (widget.streamType == StreamType.live) {
+           _playNext();
+           _onUserInteraction(); // Show OSD
+        } 
+        return true;
+    }
+    if (widget.streamType != StreamType.live) {
+      if (key == LogicalKeyboardKey.arrowLeft) {
+         _seek(const Duration(seconds: -10));
+         return true;
+      }
+      if (key == LogicalKeyboardKey.arrowRight) {
+         _seek(const Duration(seconds: 10));
+         return true;
+      }
+    }
+    
+    if (key == LogicalKeyboardKey.escape || key == LogicalKeyboardKey.goBack) {
+      if (_showControls) {
+        setState(() => _showControls = false); 
+      } else {
+        // Force pop completely to return to list, not just playlist selection
+        // Check navigator stack if needed, but standard pop should work if pushed correctly
+        Navigator.pop(context);
+      }
+      return true;
+    }
+
+    return false;
+  }
+  
+  void _startClock() {
+    _updateTime();
+    _clockTimer = Timer.periodic(const Duration(seconds: 1), (_) => _updateTime());
+  }
+  
+  void _updateTime() {
+    if (mounted) {
+      final now = DateTime.now();
+      setState(() {
+        _currentTime = "${now.hour.toString().padLeft(2, '0')}:${now.minute.toString().padLeft(2, '0')}";
+      });
+    }
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    HardwareKeyboard.instance.removeHandler(_handleKeyEvent);
+    _controlsTimer?.cancel();
+    _clockTimer?.cancel();
+    _epgTimer?.cancel();
+    _controller?.dispose();
+    _xtreamService?.dispose();
+    _playPauseFocusNode.dispose();
+    _backFocusNode.dispose();
+    
+    SystemChrome.setPreferredOrientations([
+      DeviceOrientation.portraitUp,
+      DeviceOrientation.landscapeLeft,
+      DeviceOrientation.landscapeRight,
+    ]);
+    SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
+    super.dispose();
+  }
+
+  String _formatDuration(Duration duration) {
+    String twoDigits(int n) => n.toString().padLeft(2, '0');
+    String twoDigitMinutes = twoDigits(duration.inMinutes.remainder(60));
+    String twoDigitSeconds = twoDigits(duration.inSeconds.remainder(60));
+    return "${twoDigits(duration.inHours)}:$twoDigitMinutes:$twoDigitSeconds";
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final title = widget.channels != null && widget.channels!.isNotEmpty 
+        ? widget.channels![_currentIndex].name 
+        : widget.title;
+
+    return Scaffold(
+      backgroundColor: Colors.black,
+      body: GestureDetector(
+        behavior: HitTestBehavior.opaque,
+        onTap: _onUserInteraction,
+        child: Stack(
+          children: [
+            Center(
+              child: _controller != null && _controller!.value.isInitialized
+                  ? AspectRatio(
+                      aspectRatio: _controller!.value.aspectRatio,
+                      child: VideoPlayer(_controller!),
+                    )
+                  : const CircularProgressIndicator(color: AppColors.primary),
+            ),
+            
+            if (_errorMessage != null)
+              Center(child: Text(_errorMessage!, style: const TextStyle(color: Colors.red))),
+
+            if (_showControls)
+              _buildControls(title),
+          ],
+        ),
+      ),
+    );
+  }
+  
+  Widget _buildControls(String title) {
+    return Stack(
+      children: [
+        // Top Bar
+        Positioned(
+          top: 0, left: 0, right: 0,
+          child: Container(
+            color: Colors.black54,
+            padding: const EdgeInsets.symmetric(vertical: 8, horizontal: 16),
+            child: Row(
+              children: [
+                 TVFocusable(
+                   focusNode: _backFocusNode,
+                   onPressed: () => Navigator.pop(context),
+                   child: const Icon(Icons.arrow_back, color: Colors.white),
+                 ),
+                 const SizedBox(width: 16),
+                 // Icon
+                 if (widget.channels != null && widget.channels![_currentIndex].streamIcon.isNotEmpty)
+                   Padding(
+                     padding: const EdgeInsets.only(right: 12),
+                     child: SizedBox(
+                       width: 32, 
+                       height: 32,
+                       child: CachedNetworkImage(
+                         imageUrl: widget.channels![_currentIndex].streamIcon,
+                         errorWidget: (_,__,___) => const SizedBox.shrink(),
+                       ),
+                     ),
+                   ),
+                 Text('LITE PLAYER: $title', style: const TextStyle(color: Colors.white, fontWeight: FontWeight.bold)),
+                 const Spacer(),
+                 Text(_currentTime, style: const TextStyle(color: Colors.white70)),
+              ],
+            ),
+          ),
+        ),
+        
+        // Center Controls
+        Center(
+          child: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              if (widget.streamType == StreamType.live) ...[
+                 IconButton(
+                   icon: const Icon(Icons.keyboard_arrow_up, color: Colors.white, size: 40),
+                   onPressed: _playPrevious,
+                 ),
+                 const SizedBox(width: 32),
+              ] else ...[
+                 IconButton(
+                   icon: const Icon(Icons.replay_10, color: Colors.white, size: 40),
+                   onPressed: () => _seek(const Duration(seconds: -10)),
+                 ),
+                 const SizedBox(width: 32),
+              ],
+              
+              TVFocusable(
+                focusNode: _playPauseFocusNode,
+                onPressed: _togglePlayPause,
+                child: Icon(
+                  _isPlaying ? Icons.pause_circle_filled : Icons.play_circle_filled,
+                  color: AppColors.primary,
+                  size: 64,
+                ),
+              ),
+
+              if (widget.streamType == StreamType.live) ...[
+                 const SizedBox(width: 32),
+                 IconButton(
+                   icon: const Icon(Icons.keyboard_arrow_down, color: Colors.white, size: 40),
+                   onPressed: _playNext,
+                 ),
+              ] else ...[
+                 const SizedBox(width: 32),
+                 IconButton(
+                   icon: const Icon(Icons.forward_10, color: Colors.white, size: 40),
+                   onPressed: () => _seek(const Duration(seconds: 10)),
+                 ),
+              ],
+            ],
+          ),
+        ),
+        
+        // EPG Content (Bottom Left)
+        if (widget.streamType == StreamType.live && _epg != null && _epg!.nowPlaying != null)
+              Positioned(
+                bottom: 80, // Above progress/bottom bar
+                left: 24,
+                width: 350, 
+                child: Container(
+                        padding: const EdgeInsets.all(12),
+                        decoration: BoxDecoration(
+                          color: Colors.black.withOpacity(0.7),
+                          borderRadius: BorderRadius.circular(8),
+                          border: Border.all(color: Colors.white24),
+                        ),
+                        child: Row(
+                         children: [
+                           Expanded(
+                             child: Column(
+                               crossAxisAlignment: CrossAxisAlignment.start,
+                               mainAxisSize: MainAxisSize.min,
+                               children: [
+                                 Text(
+                                   _epg!.nowPlaying!,
+                                   style: const TextStyle(color: Colors.white, fontSize: 16, fontWeight: FontWeight.bold),
+                                   maxLines: 2,
+                                   overflow: TextOverflow.ellipsis,
+                                 ),
+                                 if (_epg!.nextPlaying != null)
+                                   Padding(
+                                     padding: const EdgeInsets.only(top: 4),
+                                     child: Text(
+                                       "A suivre: ${_epg!.nextPlaying}",
+                                       style: const TextStyle(color: Colors.white70, fontSize: 14),
+                                       maxLines: 1,
+                                       overflow: TextOverflow.ellipsis,
+                                     ),
+                                   ),
+                               ],
+                             ),
+                           ),
+                           // LIVE Badge
+                           Container(
+                              padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+                              margin: const EdgeInsets.only(left: 8),
+                              decoration: BoxDecoration(
+                                color: Colors.red,
+                                borderRadius: BorderRadius.circular(4),
+                              ),
+                              child: const Text('LIVE', style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold, fontSize: 12)),
+                            ),
+                         ],
+                        ),
+                  ),
+              ),
+
+        // Progress Bar (Bottom) - Only for VOD
+        if (widget.streamType != StreamType.live)
+          Positioned(
+              bottom: 0, left: 0, right: 0,
+              child: Container(
+                  color: Colors.black54,
+                  padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 16),
+                  child: Row(
+                    children: [
+                        Text(_formatDuration(_position), style: const TextStyle(color: Colors.white)),
+                        Expanded(
+                          child: Slider(
+                            value: _position.inSeconds.toDouble().clamp(0, _duration.inSeconds.toDouble()),
+                            min: 0,
+                            max: _duration.inSeconds.toDouble(),
+                            activeColor: AppColors.primary,
+                            inactiveColor: Colors.white24,
+                            onChanged: (val) {
+                               setState(() {
+                                 _position = Duration(seconds: val.toInt());
+                                 _isSeeking = true;
+                               });
+                            },
+                            onChangeEnd: (val) {
+                               _controller?.seekTo(Duration(seconds: val.toInt()));
+                               _isSeeking = false;
+                               _onUserInteraction();
+                            },
+                          ), 
+                        ),
+                        Text(_formatDuration(_duration), style: const TextStyle(color: Colors.white)),
+                    ],
+                  ),
+              ),
+          ),
+      ],
+    );
+  }
+}

lib/mobile/features/iptv/screens/mobile_playlist_selection_screen.dart

@@ -13,77 +13,130 @@ final playlistsProvider = FutureProvider<List<PlaylistConfig>>((ref) async {
   return service.getPlaylists();
 });
 
-class MobilePlaylistSelectionScreen extends ConsumerWidget {
-  const MobilePlaylistSelectionScreen({super.key});
+class MobilePlaylistSelectionScreen extends ConsumerStatefulWidget {
+  final bool manageMode;
+  const MobilePlaylistSelectionScreen({super.key, this.manageMode = false});
 
   @override
-  Widget build(BuildContext context, WidgetRef ref) {
+  ConsumerState<MobilePlaylistSelectionScreen> createState() => _MobilePlaylistSelectionScreenState();
+}
+
+class _MobilePlaylistSelectionScreenState extends ConsumerState<MobilePlaylistSelectionScreen> {
+  @override
+  void initState() {
+    super.initState();
+    if (!widget.manageMode) {
+      // Check for auto-login after build
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        _checkAutoLogin();
+      });
+    }
+  }
+
+  Future<void> _checkAutoLogin() async {
+    final playlists = await ref.read(playlistsProvider.future);
+    if (playlists.isNotEmpty && mounted) {
+      // Auto-login to the first playlist (or last used)
+      // Ideally last used, but for now first is fine as per request "une playlist existe".
+      context.go('/dashboard', extra: playlists.first);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
     final currentUser = ref.watch(authProvider).currentUser;
     final playlistsAsync = ref.watch(playlistsProvider);
 
     return Theme(
       data: MobileTheme.darkTheme,
       child: Scaffold(
+        extendBodyBehindAppBar: true, // For gradient
         appBar: AppBar(
-          title: const Text('Playlists'),
+          title: Text(widget.manageMode ? 'Gérer les Playlists' : 'Playlists'),
+          backgroundColor: Colors.transparent,
+          elevation: 0,
           actions: [
-            IconButton(
-              icon: const Icon(Icons.logout),
-              onPressed: () async {
-                await ref.read(authProvider.notifier).logout();
-                if (context.mounted) {
-                  context.go('/login');
-                }
-              },
-            ),
+             if (widget.manageMode)
+               IconButton(
+                 icon: const Icon(Icons.close),
+                 onPressed: () => Navigator.pop(context),
+               ),
           ],
         ),
-        body: playlistsAsync.when(
-          loading: () => const Center(child: CircularProgressIndicator()),
-          error: (error, stack) => Center(
-            child: Column(
-              mainAxisAlignment: MainAxisAlignment.center,
-              children: [
-                const Icon(Icons.error_outline, size: 48, color: AppColors.error),
-                const SizedBox(height: 16),
-                Text('Error loading playlists', style: GoogleFonts.inter()),
-                TextButton(
-                  onPressed: () => ref.refresh(playlistsProvider),
-                  child: const Text('Retry'),
-                ),
-              ],
-            ),
+        body: Container(
+          decoration: const BoxDecoration(
+            gradient: AppColors.appleTvGradient,
           ),
-          data: (playlists) {
-            if (playlists.isEmpty) {
-              return Center(
-                child: Column(
-                  mainAxisAlignment: MainAxisAlignment.center,
-                  children: [
-                    const Icon(Icons.playlist_remove, size: 48, color: AppColors.textSecondary),
-                    const SizedBox(height: 16),
-                    Text('No playlists available', style: GoogleFonts.inter(color: AppColors.textSecondary)),
-                  ],
-                ),
-              );
-            }
+          child: playlistsAsync.when(
+            loading: () => const Center(child: CircularProgressIndicator()),
+            error: (error, stack) => Center(
+              child: Column(
+                mainAxisAlignment: MainAxisAlignment.center,
+                children: [
+                  const Icon(Icons.error_outline, size: 48, color: AppColors.error),
+                  const SizedBox(height: 16),
+                  Text('Erreur de chargement', style: GoogleFonts.inter(color: Colors.white)),
+                  TextButton(
+                    onPressed: () => ref.refresh(playlistsProvider),
+                    child: const Text('Réessayer'),
+                  ),
+                ],
+              ),
+            ),
+            data: (playlists) {
+              if (playlists.isEmpty) {
+                 // Even in auto-mode, if empty we show this (or add button)
+                 return Center(
+                    child: Column(
+                      mainAxisAlignment: MainAxisAlignment.center,
+                      children: [
+                        const Icon(Icons.playlist_add, size: 64, color: Colors.white54),
+                        const SizedBox(height: 24),
+                        Text(
+                          'Aucune playlist configurée',
+                          style: GoogleFonts.inter(fontSize: 18, color: Colors.white70),
+                        ),
+                        const SizedBox(height: 32),
+                        ElevatedButton.icon(
+                          onPressed: () {
+                             // Logic to add playlist (usually dialog or separate screen)
+                             // specific logic for add playlist
+                          },
+                          icon: const Icon(Icons.add),
+                          label: const Text('Ajouter une Playlist'),
+                          style: ElevatedButton.styleFrom(
+                            backgroundColor: AppColors.primary,
+                            foregroundColor: Colors.black,
+                            padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 12),
+                          ),
+                        ),
+                      ],
+                    ),
+                 );
+              }
 
-            return ListView.separated(
-              padding: const EdgeInsets.all(16),
-              itemCount: playlists.length,
-              separatorBuilder: (context, index) => const SizedBox(height: 16),
-              itemBuilder: (context, index) {
-                final playlist = playlists[index];
-                return _MobilePlaylistCard(
-                  playlist: playlist,
-                  onTap: () {
-                    // Mobile navigation to dashboard with playlist
-                    context.go('/dashboard', extra: playlist); 
-                  },
-                );
-              },
-            );
-          },
+              return ListView.separated(
+                padding: const EdgeInsets.fromLTRB(16, 100, 16, 16), // Top padding for AppBar
+                itemCount: playlists.length,
+                separatorBuilder: (context, index) => const SizedBox(height: 16),
+                itemBuilder: (context, index) {
+                  final playlist = playlists[index];
+                  return _MobilePlaylistCard(
+                    playlist: playlist,
+                    onTap: () {
+                      if (widget.manageMode) {
+                         // In manage mode, maybe we want to edit or delete? 
+                         // For now, just switch to it.
+                         context.go('/dashboard', extra: playlist);
+                      } else {
+                         context.go('/dashboard', extra: playlist);
+                      }
+                    },
+                  );
+                },
+              );
+            },
+          ),
         ),
       ),
     );

lib/mobile/features/iptv/screens/mobile_series_detail_screen.dart

@@ -4,6 +4,7 @@ import 'package:cached_network_image/cached_network_image.dart';
 import 'package:google_fonts/google_fonts.dart';
 import '../../../../core/models/playlist_config.dart';
 import '../../../../features/iptv/models/xtream_models.dart';
+import 'package:xtremflow/mobile/features/iptv/screens/lite_player_screen.dart';
 import '../../../providers/mobile_xtream_providers.dart';
 import '../../../providers/mobile_settings_providers.dart';
 import 'native_player_screen.dart';
@@ -104,7 +105,7 @@ class _MobileSeriesDetailScreenState extends ConsumerState<MobileSeriesDetailScr
       slivers: [
         // App Bar with Cover
         SliverAppBar(
-          expandedHeight: 400,
+          expandedHeight: 280, // Reduced from 400 for better TV visibility
           pinned: true,
           backgroundColor: AppColors.background,
           leading: Container(
@@ -280,21 +281,41 @@ class _MobileSeriesDetailScreenState extends ConsumerState<MobileSeriesDetailScr
     return InkWell(
       onTap: () {
         // Watch progress is tracked in player at 80% completion
-        Navigator.push(
-          context,
-          MaterialPageRoute(
-            builder: (context) => NativePlayerScreen(
-              streamId: episode.id,
-              title: '${widget.series.name} - ${episode.title}',
-              playlist: widget.playlist,
-              streamType: StreamType.series,
-              containerExtension: episode.containerExtension ?? 'mkv',
-              seriesId: widget.series.seriesId,
-              season: _selectedSeason,
-              episodeNum: episode.episodeNum,
-            ),
-          ),
-        );
+          final engine = ref.read(mobileSettingsProvider).playerEngine;
+          
+          if (engine == 'lite') {
+            Navigator.push(
+              context,
+              MaterialPageRoute(
+                builder: (context) => LitePlayerScreen(
+                  streamId: episode.streamId,
+                  title: "${widget.series.name} S${episode.seasonNum}E${episode.episodeNum}",
+                  playlist: widget.playlist,
+                  streamType: StreamType.series,
+                  containerExtension: episode.containerExtension ?? 'mp4',
+                  seriesId: widget.series.seriesId,
+                  season: episode.seasonNum,
+                  episodeNum: episode.episodeNum,
+                ),
+              ),
+            );
+          } else {
+            Navigator.push(
+              context,
+              MaterialPageRoute(
+                builder: (context) => NativePlayerScreen(
+                  streamId: episode.streamId,
+                  title: "${widget.series.name} S${episode.seasonNum}E${episode.episodeNum}",
+                  playlist: widget.playlist,
+                  streamType: StreamType.series,
+                  containerExtension: episode.containerExtension ?? 'mp4',
+                  seriesId: widget.series.seriesId,
+                  season: episode.seasonNum,
+                  episodeNum: episode.episodeNum,
+                ),
+              ),
+            );
+          }
       },
       child: Container(
         padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),

lib/mobile/features/iptv/screens/native_player_screen.dart

@@ -5,6 +5,7 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:google_fonts/google_fonts.dart';
 import 'package:media_kit/media_kit.dart';
 import 'package:media_kit_video/media_kit_video.dart';
+import 'package:xtremflow/mobile/widgets/tv_focusable.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:xtremflow/core/models/iptv_models.dart';
 import 'package:xtremflow/core/models/playlist_config.dart';
@@ -54,6 +55,13 @@ class NativePlayerScreen extends ConsumerStatefulWidget {
 class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with WidgetsBindingObserver {
   late final Player _player;
   late final VideoController _controller;
+
+  // Focus Nodes
+  final FocusNode _playPauseFocusNode = FocusNode();
+  final FocusNode _prevFocusNode = FocusNode();
+  final FocusNode _nextFocusNode = FocusNode();
+  final FocusNode _backFocusNode = FocusNode();
+
   bool _isLoading = true;
   String? _errorMessage;
   late int _currentIndex;
@@ -73,12 +81,16 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
   String _currentTime = '';
   bool _hasMarkedAsWatched = false; // Flag to mark watched only once at 80%
 
+
+
   void _resetControlsTimer() {
     _controlsTimer?.cancel();
+    _startClock(); // Ensure clock runs when controls are shown
     if (_showControls && _isPlaying) {
       _controlsTimer = Timer(const Duration(seconds: 10), () {
         if (mounted) {
           setState(() => _showControls = false);
+          _stopClock(); // Save CPU when hidden
         }
       });
     }
@@ -113,29 +125,37 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     _player = Player(configuration: config);
     
     // Enable software decoding fallback if hardware fails (handled by mpv usually, but ensuring 'auto' helps)
-    (_player.platform as dynamic)?.setProperty('hwdec', 'auto');
+    final decoderMode = ref.read(mobileSettingsProvider).decoderMode;
+    (_player.platform as dynamic)?.setProperty('hwdec', decoderMode);
+    debugPrint('MediaKitPlayer: Decoder Mode set to $decoderMode');
     
-    // ============ OPTIMIZED STREAM STABILITY CONFIGURATION ============
-    // Aggressive buffering and reconnection for stable live TV playback
+    // ============ PERFORMANCE 2.0 (LOW MEMORY 1GB PROFILE) ============
+    // Tuned for Low-End Android TV hardware (1GB RAM Sticks)
+    // Goal: Prevent OOM Kills & Crashes
     
-    // Large cache for smooth playback
+    // 50MB Cache = ~1 min of HD stream. Critical for 1GB RAM.
     (_player.platform as dynamic)?.setProperty('cache', 'yes');
-    (_player.platform as dynamic)?.setProperty('cache-secs', '300'); // Cache up to 5 minutes
-    (_player.platform as dynamic)?.setProperty('demuxer-max-bytes', '150000000'); // 150MB max buffer
-    (_player.platform as dynamic)?.setProperty('demuxer-max-back-bytes', '75000000'); // 75MB back buffer
-    (_player.platform as dynamic)?.setProperty('cache-pause-initial', 'yes'); // Wait for cache before playing
-    (_player.platform as dynamic)?.setProperty('cache-pause-wait', '5'); // Wait 5s minimum cache
+    (_player.platform as dynamic)?.setProperty('cache-secs', '60'); // 1 minute cache
+    (_player.platform as dynamic)?.setProperty('demuxer-max-bytes', '50000000'); // 50MB buffer
+    (_player.platform as dynamic)?.setProperty('demuxer-max-back-bytes', '10000000'); // 10MB back buffer
+    (_player.platform as dynamic)?.setProperty('cache-pause-initial', 'yes');
+    (_player.platform as dynamic)?.setProperty('cache-pause-wait', '3'); // Shorter wait to start 
+
+    // Standard Processing (Hardware handles it)
+    (_player.platform as dynamic)?.setProperty('video-sync', 'audio');
+    (_player.platform as dynamic)?.setProperty('interpolation', 'no'); // Keep off for safety
+    (_player.platform as dynamic)?.setProperty('audio-buffer', '0.5'); // Standard audio buffer
     
     // Network resilience
-    (_player.platform as dynamic)?.setProperty('network-timeout', '120'); // 2 minute timeout
-    (_player.platform as dynamic)?.setProperty('stream-timeout', '120'); // 2 minute stream timeout
-    (_player.platform as dynamic)?.setProperty('tls-verify', 'no'); // Ignore SSL errors
+    (_player.platform as dynamic)?.setProperty('network-timeout', '120');
+    (_player.platform as dynamic)?.setProperty('stream-timeout', '120');
+    (_player.platform as dynamic)?.setProperty('tls-verify', 'no');
     (_player.platform as dynamic)?.setProperty('http-header-fields', 'User-Agent: XtremFlow/1.0');
     
-    // Aggressive reconnection for live streams
-    (_player.platform as dynamic)?.setProperty('stream-lavf-o', 'reconnect=1,reconnect_streamed=1,reconnect_on_network_error=1,reconnect_on_http_error=4xx,reconnect_delay_max=10');
+    // Live Stream optimizations
+    (_player.platform as dynamic)?.setProperty('stream-lavf-o', 'reconnect=1,reconnect_streamed=1,reconnect_on_network_error=1,reconnect_delay_max=5');
     (_player.platform as dynamic)?.setProperty('force-seekable', 'yes');
-    (_player.platform as dynamic)?.setProperty('demuxer-lavf-o', 'live_start_index=-1,analyzeduration=10000000,probesize=10000000');
+    (_player.platform as dynamic)?.setProperty('demuxer-lavf-o', 'live_start_index=-1'); // Removed large probesize
     
     // Prevent stalls
     (_player.platform as dynamic)?.setProperty('demuxer-readahead-secs', '60'); // Read 60s ahead
@@ -223,10 +243,16 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
   }
 
   void _startClock() {
+    if (_clockTimer != null && _clockTimer!.isActive) return;
     _updateTime();
     _clockTimer = Timer.periodic(const Duration(seconds: 1), (_) => _updateTime());
   }
 
+  void _stopClock() {
+    _clockTimer?.cancel();
+    _clockTimer = null;
+  }
+
   void _updateTime() {
     if (mounted) {
       final now = DateTime.now();
@@ -272,6 +298,12 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     ]);
     SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
     
+    // Dispose focus nodes
+    _playPauseFocusNode.dispose();
+    _prevFocusNode.dispose();
+    _nextFocusNode.dispose();
+    _backFocusNode.dispose();
+    
     super.dispose();
   }
   
@@ -475,7 +507,13 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
 
       // Enable software decoding fallback if hardware fails (handled by mpv usually, but ensuring 'auto' helps)
       // If we are in fallback mode, force software ('no')
-      (_player.platform as dynamic)?.setProperty('hwdec', _useSoftwareDecoder ? 'no' : 'auto');
+      String hwdecValue;
+      if (_useSoftwareDecoder) {
+         hwdecValue = 'no';
+      } else {
+         hwdecValue = ref.read(mobileSettingsProvider).decoderMode;
+      }
+      (_player.platform as dynamic)?.setProperty('hwdec', hwdecValue);
 
       await _player.open(
         Media(streamUrl, httpHeaders: {'User-Agent': 'XtremFlow/1.0'}),
@@ -566,6 +604,11 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     // Always show controls on tap, then start auto-hide timer
     if (!_showControls) {
       setState(() => _showControls = true);
+      // Request focus on Play/Pause button when opening
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        // If controls opened, default to Play/Pause
+        _playPauseFocusNode.requestFocus();
+      });
     }
     _resetControlsTimer();
   }
@@ -576,16 +619,37 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     
     final key = event.logicalKey;
     
-    // Space / Enter / Select - Toggle play/pause
+    // Space / Enter / Select
     if (key == LogicalKeyboardKey.space ||
         key == LogicalKeyboardKey.enter ||
-        key == LogicalKeyboardKey.select) {
-      _togglePlayPause();
-      return true;
+        key == LogicalKeyboardKey.select || 
+        key == LogicalKeyboardKey.numpadEnter ||
+        key == LogicalKeyboardKey.gameButtonA) {
+      // If controls are hidden, toggle them + play/pause
+      if (!_showControls) {
+        _togglePlayPause();
+        _toggleControls();
+        return true;
+      }
+      // If controls are visible, let Focus system handle button press
+      return false;
+    }
+    
+    // Debug Toggle: Long Press Key 'D' or 0 (if mapped) - Simplified to just a secret key combo?
+    // Let's use a long-press logic on Select in _handleKeyEvent?
+    // Actually, handling long press in key down is hard. 
+    // We'll add a 'Debug' button in the settings or just map Key '0' if remote has it.
+    // Debug Toggle: Long Press Key 'D' or 0 (if mapped)
+    if (key == LogicalKeyboardKey.digit0) {
+       final current = ref.read(mobileSettingsProvider).showDebugStats;
+       ref.read(mobileSettingsProvider.notifier).toggleShowDebugStats(!current);
+       return true;
     }
     
     // Left Arrow - Seek back 10 seconds
     if (key == LogicalKeyboardKey.arrowLeft) {
+      if (_showControls) return false; // Let Focus handle navigation
+      
       if (widget.streamType != StreamType.live) {
         final newPos = _position - const Duration(seconds: 10);
         _player.seek(newPos < Duration.zero ? Duration.zero : newPos);
@@ -596,6 +660,8 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     
     // Right Arrow - Seek forward 10 seconds
     if (key == LogicalKeyboardKey.arrowRight) {
+      if (_showControls) return false; // Let Focus handle navigation
+
       if (widget.streamType != StreamType.live) {
         final newPos = _position + const Duration(seconds: 10);
         if (newPos < _duration) {
@@ -625,7 +691,12 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     // Escape / Back - Exit player
     if (key == LogicalKeyboardKey.escape ||
         key == LogicalKeyboardKey.goBack) {
-      Navigator.of(context).pop();
+      // If controls are visible, close them first
+      if (_showControls) {
+        setState(() => _showControls = false);
+      } else {
+        Navigator.of(context).pop();
+      }
       return true;
     }
     
@@ -683,22 +754,33 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
                 child: SafeArea(
                   child: Container(
                     padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
-                    decoration: BoxDecoration(
-                      gradient: LinearGradient(
-                        begin: Alignment.topCenter,
-                        end: Alignment.bottomCenter,
-                        colors: [
-                          Colors.black.withOpacity(0.8),
-                          Colors.transparent,
-                        ],
-                      ),
+                    decoration: const BoxDecoration(
+                      color: Colors.black54, // Flat color instead of Gradient for performance
                     ),
                     child: Row(
                       children: [
                         // Main Back Button
-                        IconButton(
-                          icon: const Icon(Icons.arrow_back, color: Colors.white),
-                          onPressed: () => Navigator.pop(context),
+                        // Main Back Button
+                        TVFocusable(
+                           focusNode: _backFocusNode,
+                           onPressed: () => Navigator.pop(context),
+                           onFocus: _resetControlsTimer,
+                           borderRadius: BorderRadius.circular(50),
+                           child: IconButton(
+                            icon: const Icon(Icons.arrow_back, color: Colors.white),
+                            onPressed: () => Navigator.pop(context),
+                          ),
+                        ),
+                        // Hidden Debug Trigger (Invisible InkWell next to back button)
+                        InkWell(
+                          onLongPress: () {
+                             final current = ref.read(mobileSettingsProvider).showDebugStats;
+                             ref.read(mobileSettingsProvider.notifier).toggleShowDebugStats(!current);
+                             ScaffoldMessenger.of(context).showSnackBar(
+                               SnackBar(content: Text('Debug Mode: ${!current ? "ON" : "OFF"}'), duration: const Duration(seconds: 1)),
+                             );
+                          },
+                           child: const SizedBox(width: 20, height: 40), 
                         ),
                         Expanded(
                           child: Column(
@@ -734,12 +816,20 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
                   ),
                 ),
               ),
+
+             // Stats Overlay (Top Left) - Isolated to prevent main rebuilds
+             Positioned(
+               top: 80,
+               left: 16,
+               child: StatsOverlayWidget(player: _player),
+             ),
           ],
         ),
       ),
     );
   }
 
+
   String _formatDuration(Duration duration) {
     String twoDigits(int n) => n.toString().padLeft(2, '0');
     String twoDigitMinutes = twoDigits(duration.inMinutes.remainder(60));
@@ -763,46 +853,85 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
                 children: [
                   // Prev Channel / Replay 10s
                   if (widget.streamType == StreamType.live && widget.channels != null && widget.channels!.isNotEmpty)
-                    IconButton(
-                      icon: const Icon(Icons.skip_previous, color: Colors.white, size: 48),
+                    TVFocusable(
+                      focusNode: _prevFocusNode,
                       onPressed: _playPrevious,
+                      onFocus: _resetControlsTimer,
+                      borderRadius: BorderRadius.circular(50),
+                      child: IconButton(
+                        icon: const Icon(Icons.skip_previous, color: Colors.white, size: 48),
+                        onPressed: _playPrevious,
+                      ),
                     )
                   else if (widget.streamType != StreamType.live)
-                    IconButton(
-                      icon: const Icon(Icons.replay_10, color: Colors.white, size: 48),
+                    TVFocusable(
+                      focusNode: _prevFocusNode,
                       onPressed: () async {
                         final pos = await _player.stream.position.first;
                         _player.seek(pos - const Duration(seconds: 10));
+                        _resetControlsTimer();
                       },
+                      onFocus: _resetControlsTimer,
+                      borderRadius: BorderRadius.circular(50),
+                      child: IconButton(
+                        icon: const Icon(Icons.replay_10, color: Colors.white, size: 48),
+                        onPressed: () async {
+                          final pos = await _player.stream.position.first;
+                          _player.seek(pos - const Duration(seconds: 10));
+                        },
+                      ),
                     ),
 
                   const SizedBox(width: 32),
                   
                   // Play/Pause
-                  IconButton(
-                    iconSize: 72,
-                    icon: Icon(
-                      _isPlaying ? Icons.pause_circle_filled : Icons.play_circle_filled,
-                      color: Colors.white,
-                    ),
+                  TVFocusable(
+                    focusNode: _playPauseFocusNode,
                     onPressed: _togglePlayPause,
+                    onFocus: _resetControlsTimer,
+                    scale: 1.1, // Larger scale for main button
+                    borderRadius: BorderRadius.circular(50),
+                    child: IconButton(
+                      iconSize: 72,
+                      icon: Icon(
+                        _isPlaying ? Icons.pause_circle_filled : Icons.play_circle_filled,
+                        color: Colors.white,
+                      ),
+                      onPressed: _togglePlayPause,
+                    ),
                   ),
                   
                   const SizedBox(width: 32),
 
                   // Next Channel / Forward 10s
                   if (widget.streamType == StreamType.live && widget.channels != null && widget.channels!.isNotEmpty)
-                    IconButton(
-                      icon: const Icon(Icons.skip_next, color: Colors.white, size: 48),
+                    TVFocusable(
+                      focusNode: _nextFocusNode,
                       onPressed: _playNext,
+                      onFocus: _resetControlsTimer,
+                      borderRadius: BorderRadius.circular(50),
+                      child: IconButton(
+                        icon: const Icon(Icons.skip_next, color: Colors.white, size: 48),
+                        onPressed: _playNext,
+                      ),
                     )
                   else if (widget.streamType != StreamType.live)
-                    IconButton(
-                      icon: const Icon(Icons.forward_10, color: Colors.white, size: 48),
+                    TVFocusable(
+                      focusNode: _nextFocusNode,
                       onPressed: () async {
                         final pos = await _player.stream.position.first;
                         _player.seek(pos + const Duration(seconds: 10));
+                        _resetControlsTimer();
                       },
+                      onFocus: _resetControlsTimer,
+                      borderRadius: BorderRadius.circular(50),
+                      child: IconButton(
+                        icon: const Icon(Icons.forward_10, color: Colors.white, size: 48),
+                        onPressed: () async {
+                          final pos = await _player.stream.position.first;
+                          _player.seek(pos + const Duration(seconds: 10));
+                        },
+                      ),
                     ),
                 ],
               ),
@@ -1015,3 +1144,70 @@ class _NativePlayerScreenState extends ConsumerState<NativePlayerScreen> with Wi
     );
   }
 }
+
+/// Isolated Stats Widget to prevent rebuilding the entire Video Player on every update
+class StatsOverlayWidget extends ConsumerStatefulWidget {
+  final Player player;
+  const StatsOverlayWidget({super.key, required this.player});
+
+  @override
+  ConsumerState<StatsOverlayWidget> createState() => _StatsOverlayWidgetState();
+}
+
+class _StatsOverlayWidgetState extends ConsumerState<StatsOverlayWidget> {
+  Duration _buffer = Duration.zero;
+  String _decoder = 'Unknown';
+  
+  // Throttling updates
+  Timer? _updateTimer;
+
+  @override
+  void initState() {
+    super.initState();
+    // Use a periodic timer to poll/update stats instead of listening to every single frequent event
+    // This reduces UI thread load significantly on low-end devices
+    _updateTimer = Timer.periodic(const Duration(milliseconds: 1000), (_) {
+      if (mounted) {
+         setState(() {
+           _buffer = widget.player.state.buffer;
+           // Accessing nested prop safely just in case
+           final track = widget.player.state.track.video;
+           _decoder = track.decoder ?? 'Auto'; 
+         });
+      }
+    });
+  }
+
+  @override
+  void dispose() {
+    _updateTimer?.cancel();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (!ref.watch(mobileSettingsProvider).showDebugStats) return const SizedBox.shrink();
+
+    return Container(
+      padding: const EdgeInsets.all(8),
+      decoration: BoxDecoration(
+        color: Colors.black.withOpacity(0.7),
+        borderRadius: BorderRadius.circular(8),
+        border: Border.all(color: Colors.green.withOpacity(0.5)),
+      ),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          const Text('STATS FOR NERDS 🤓', 
+            style: TextStyle(color: Colors.green, fontWeight: FontWeight.bold, fontSize: 12)),
+          const SizedBox(height: 4),
+          Text('Buffer: ${_buffer.inSeconds}s', 
+            style: const TextStyle(color: Colors.white, fontSize: 12)),
+          Text('Decoder: $_decoder', 
+            style: const TextStyle(color: Colors.white, fontSize: 12)),
+        ],
+      ),
+    );
+  }
+}