added cargo files

PinePods-0.8.2/mobile/lib/ui/utils/position_utils.dart

@@ -0,0 +1,151 @@
+// lib/ui/utils/position_utils.dart
+import 'package:flutter/material.dart';
+import 'package:pinepods_mobile/entities/pinepods_episode.dart';
+import 'package:pinepods_mobile/entities/episode.dart';
+import 'package:pinepods_mobile/entities/downloadable.dart';
+import 'package:pinepods_mobile/services/logging/app_logger.dart';
+import 'package:pinepods_mobile/services/pinepods/pinepods_service.dart';
+import 'package:pinepods_mobile/bloc/podcast/podcast_bloc.dart';
+import 'package:provider/provider.dart';
+
+/// Utility class for managing episode position synchronization and display
+class PositionUtils {
+  static final AppLogger _logger = AppLogger();
+
+  /// Generate consistent GUID for PinePods episodes
+  static String generateEpisodeGuid(PinepodsEpisode episode) {
+    return 'pinepods_${episode.episodeId}';
+  }
+
+  /// Get local position for episode from repository
+  static Future<double?> getLocalPosition(BuildContext context, PinepodsEpisode episode) async {
+    try {
+      final podcastBloc = Provider.of<PodcastBloc>(context, listen: false);
+      final guid = generateEpisodeGuid(episode);
+      
+      // Get all episodes and find matches with both new and old GUID formats
+      final allEpisodes = await podcastBloc.podcastService.repository.findAllEpisodes();
+      final matchingEpisodes = allEpisodes.where((ep) => 
+        ep.guid == guid || ep.guid.startsWith('${guid}_')
+      ).toList();
+      
+      if (matchingEpisodes.isNotEmpty) {
+        // Return the highest position from any matching episode (in case of duplicates)
+        final positions = matchingEpisodes.map((ep) => ep.position / 1000.0).toList();
+        return positions.reduce((a, b) => a > b ? a : b);
+      }
+      
+      return null;
+    } catch (e) {
+      _logger.error('PositionUtils', 'Error getting local position for episode: ${episode.episodeTitle}', e.toString());
+      return null;
+    }
+  }
+
+  /// Get server position for episode (use existing data from feed)
+  static Future<double?> getServerPosition(PinepodsService pinepodsService, PinepodsEpisode episode, int userId) async {
+    return episode.listenDuration?.toDouble();
+  }
+
+  /// Get the best available position (furthest of local vs server)
+  static Future<PositionInfo> getBestPosition(
+    BuildContext context,
+    PinepodsService pinepodsService,
+    PinepodsEpisode episode,
+    int userId,
+  ) async {
+    // Get both positions in parallel
+    final futures = await Future.wait([
+      getLocalPosition(context, episode),
+      getServerPosition(pinepodsService, episode, userId),
+    ]);
+    
+    final localPosition = futures[0] ?? 0.0;
+    final serverPosition = futures[1] ?? episode.listenDuration?.toDouble() ?? 0.0;
+    
+    final bestPosition = localPosition > serverPosition ? localPosition : serverPosition;
+    final isLocal = localPosition >= serverPosition;
+    
+    
+    return PositionInfo(
+      position: bestPosition,
+      isLocal: isLocal,
+      localPosition: localPosition,
+      serverPosition: serverPosition,
+    );
+  }
+
+  /// Enrich a single episode with the best available position
+  static Future<PinepodsEpisode> enrichEpisodeWithBestPosition(
+    BuildContext context,
+    PinepodsService pinepodsService,
+    PinepodsEpisode episode,
+    int userId,
+  ) async {
+    final positionInfo = await getBestPosition(context, pinepodsService, episode, userId);
+    
+    // Create a new episode with updated position
+    return PinepodsEpisode(
+      podcastName: episode.podcastName,
+      episodeTitle: episode.episodeTitle,
+      episodePubDate: episode.episodePubDate,
+      episodeDescription: episode.episodeDescription,
+      episodeArtwork: episode.episodeArtwork,
+      episodeUrl: episode.episodeUrl,
+      episodeDuration: episode.episodeDuration,
+      listenDuration: positionInfo.position.round(),
+      episodeId: episode.episodeId,
+      completed: episode.completed,
+      saved: episode.saved,
+      queued: episode.queued,
+      downloaded: episode.downloaded,
+      isYoutube: episode.isYoutube,
+      podcastId: episode.podcastId,
+    );
+  }
+
+  /// Enrich a list of episodes with the best available positions
+  static Future<List<PinepodsEpisode>> enrichEpisodesWithBestPositions(
+    BuildContext context,
+    PinepodsService pinepodsService,
+    List<PinepodsEpisode> episodes,
+    int userId,
+  ) async {
+    _logger.info('PositionUtils', 'Enriching ${episodes.length} episodes with best positions');
+    
+    final enrichedEpisodes = <PinepodsEpisode>[];
+    
+    for (final episode in episodes) {
+      try {
+        final enrichedEpisode = await enrichEpisodeWithBestPosition(
+          context,
+          pinepodsService,
+          episode,
+          userId,
+        );
+        enrichedEpisodes.add(enrichedEpisode);
+      } catch (e) {
+        _logger.warning('PositionUtils', 'Failed to enrich episode ${episode.episodeTitle}, using original: ${e.toString()}');
+        enrichedEpisodes.add(episode);
+      }
+    }
+    
+    _logger.info('PositionUtils', 'Successfully enriched ${enrichedEpisodes.length} episodes');
+    return enrichedEpisodes;
+  }
+}
+
+/// Information about episode position
+class PositionInfo {
+  final double position;
+  final bool isLocal;
+  final double localPosition;
+  final double serverPosition;
+
+  PositionInfo({
+    required this.position,
+    required this.isLocal,
+    required this.localPosition,
+    required this.serverPosition,
+  });
+}