commit 144720f80e4703e9651a097a4600212aed2dd9dc · bretton.dev/coves-mobile

lib/main.dart

···

       11
       11
        
       import 'screens/auth/login_screen.dart';

     

       12
       12
        
       import 'screens/home/main_shell_screen.dart';

     

       13
       13
        
       import 'screens/landing_screen.dart';

     

       14
       14
       +
       import 'services/streamable_service.dart';

     

       14
       15
        
       import 'services/vote_service.dart';

     

       15
       16
        
       

     

       16
       17
        
       void main() async {

     
···

       64
       65
        
                       );

     

       65
       66
        
                 },

     

       66
       67
        
               ),

     

       68
       68
       +
               // StreamableService for video embeds

     

       69
       69
       +
               Provider<StreamableService>(create: (_) => StreamableService()),

     

       67
       70
        
             ],

     

       68
       71
        
             child: const CovesApp(),

     

       69
       72
        
           ),

+21

lib/models/post.dart

···

       197
       197
        
           this.description,

     

       198
       198
        
           this.thumb,

     

       199
       199
        
           this.domain,

     

       200
       200
       +
           this.embedType,

     

       201
       201
       +
           this.provider,

     

       202
       202
       +
           this.images,

     

       203
       203
       +
           this.totalCount,

     

       200
       204
        
         });

     

       201
       205
        
       

     

       202
       206
        
         factory ExternalEmbed.fromJson(Map<String, dynamic> json) {

     

       207
       207
       +
           // Thumb is always a string URL (backend transforms blob refs before sending)

     

       208
       208
       +
       

     

       209
       209
       +
           // Handle images array if present

     

       210
       210
       +
           List<Map<String, dynamic>>? imagesList;

     

       211
       211
       +
           if (json['images'] != null && json['images'] is List) {

     

       212
       212
       +
             imagesList =

     

       213
       213
       +
                 (json['images'] as List).whereType<Map<String, dynamic>>().toList();

     

       214
       214
       +
           }

     

       215
       215
       +
       

     

       203
       216
        
           return ExternalEmbed(

     

       204
       217
        
             uri: json['uri'] as String,

     

       205
       218
        
             title: json['title'] as String?,

     

       206
       219
        
             description: json['description'] as String?,

     

       207
       220
        
             thumb: json['thumb'] as String?,

     

       208
       221
        
             domain: json['domain'] as String?,

     

       222
       222
       +
             embedType: json['embedType'] as String?,

     

       223
       223
       +
             provider: json['provider'] as String?,

     

       224
       224
       +
             images: imagesList,

     

       225
       225
       +
             totalCount: json['totalCount'] as int?,

     

       209
       226
        
           );

     

       210
       227
        
         }

     

       211
       228
        
         final String uri;

     
···

       213
       230
        
         final String? description;

     

       214
       231
        
         final String? thumb;

     

       215
       232
        
         final String? domain;

     

       233
       233
       +
         final String? embedType;

     

       234
       234
       +
         final String? provider;

     

       235
       235
       +
         final List<Map<String, dynamic>>? images;

     

       236
       236
       +
         final int? totalCount;

     

       216
       237
        
       }

     

       217
       238
        
       

     

       218
       239
        
       class PostFacet {

+151

lib/services/streamable_service.dart

···

       1
       1
       +
       import 'package:dio/dio.dart';

     

       2
       2
       +
       import 'package:flutter/foundation.dart';

     

       3
       3
       +
       

     

       4
       4
       +
       /// Service for interacting with Streamable API

     

       5
       5
       +
       ///

     

       6
       6
       +
       /// Fetches video data from Streamable to get direct MP4 URLs

     

       7
       7
       +
       /// for in-app video playback.

     

       8
       8
       +
       ///

     

       9
       9
       +
       /// Implements caching to reduce API calls for recently accessed videos.

     

       10
       10
       +
       class StreamableService {

     

       11
       11
       +
         StreamableService({Dio? dio}) : _dio = dio ?? _sharedDio;

     

       12
       12
       +
       

     

       13
       13
       +
         // Singleton Dio instance for efficient connection reuse

     

       14
       14
       +
         static final Dio _sharedDio = Dio(

     

       15
       15
       +
           BaseOptions(

     

       16
       16
       +
             connectTimeout: const Duration(seconds: 10),

     

       17
       17
       +
             receiveTimeout: const Duration(seconds: 10),

     

       18
       18
       +
             sendTimeout: const Duration(seconds: 10),

     

       19
       19
       +
           ),

     

       20
       20
       +
         );

     

       21
       21
       +
       

     

       22
       22
       +
         final Dio _dio;

     

       23
       23
       +
       

     

       24
       24
       +
         // Cache for video URLs (shortcode -> {url, timestamp})

     

       25
       25
       +
         // Short-lived cache (5 min) to reduce API calls

     

       26
       26
       +
         final Map<String, ({String url, DateTime cachedAt})> _urlCache = {};

     

       27
       27
       +
         static const Duration _cacheDuration = Duration(minutes: 5);

     

       28
       28
       +
       

     

       29
       29
       +
         /// Extracts the Streamable shortcode from a URL

     

       30
       30
       +
         ///

     

       31
       31
       +
         /// Examples:

     

       32
       32
       +
         /// - https://streamable.com/7kpdft -> 7kpdft

     

       33
       33
       +
         /// - https://streamable.com/e/abc123 -> abc123

     

       34
       34
       +
         /// - streamable.com/abc123 -> abc123

     

       35
       35
       +
         static String? extractShortcode(String url) {

     

       36
       36
       +
           try {

     

       37
       37
       +
             // Handle URLs without scheme

     

       38
       38
       +
             var urlToParse = url;

     

       39
       39
       +
             if (!url.contains('://')) {

     

       40
       40
       +
               urlToParse = 'https://$url';

     

       41
       41
       +
             }

     

       42
       42
       +
       

     

       43
       43
       +
             final uri = Uri.parse(urlToParse);

     

       44
       44
       +
             final path = uri.path;

     

       45
       45
       +
       

     

       46
       46
       +
             // Get the last non-empty path segment (handles /e/ prefix and other cases)

     

       47
       47
       +
             final segments = path.split('/').where((s) => s.isNotEmpty).toList();

     

       48
       48
       +
             if (segments.isEmpty) {

     

       49
       49
       +
               return null;

     

       50
       50
       +
             }

     

       51
       51
       +
       

     

       52
       52
       +
             final shortcode = segments.last;

     

       53
       53
       +
       

     

       54
       54
       +
             if (shortcode.isEmpty) {

     

       55
       55
       +
               return null;

     

       56
       56
       +
             }

     

       57
       57
       +
       

     

       58
       58
       +
             return shortcode;

     

       59
       59
       +
           } on FormatException catch (e) {

     

       60
       60
       +
             if (kDebugMode) {

     

       61
       61
       +
               debugPrint('Error extracting Streamable shortcode: $e');

     

       62
       62
       +
             }

     

       63
       63
       +
             return null;

     

       64
       64
       +
           }

     

       65
       65
       +
         }

     

       66
       66
       +
       

     

       67
       67
       +
         /// Fetches the MP4 video URL for a Streamable video

     

       68
       68
       +
         ///

     

       69
       69
       +
         /// Returns the direct MP4 URL or null if the video cannot be fetched.

     

       70
       70
       +
         /// Uses a 5-minute cache to reduce API calls for repeated access.

     

       71
       71
       +
         Future<String?> getVideoUrl(String streamableUrl) async {

     

       72
       72
       +
           try {

     

       73
       73
       +
             final shortcode = extractShortcode(streamableUrl);

     

       74
       74
       +
             if (shortcode == null) {

     

       75
       75
       +
               if (kDebugMode) {

     

       76
       76
       +
                 debugPrint('Failed to extract shortcode from: $streamableUrl');

     

       77
       77
       +
               }

     

       78
       78
       +
               return null;

     

       79
       79
       +
             }

     

       80
       80
       +
       

     

       81
       81
       +
             // Check cache first

     

       82
       82
       +
             final cached = _urlCache[shortcode];

     

       83
       83
       +
             if (cached != null) {

     

       84
       84
       +
               final age = DateTime.now().difference(cached.cachedAt);

     

       85
       85
       +
               if (age < _cacheDuration) {

     

       86
       86
       +
                 if (kDebugMode) {

     

       87
       87
       +
                   debugPrint('Using cached URL for shortcode: $shortcode');

     

       88
       88
       +
                 }

     

       89
       89
       +
                 return cached.url;

     

       90
       90
       +
               }

     

       91
       91
       +
               // Cache expired, remove it

     

       92
       92
       +
               _urlCache.remove(shortcode);

     

       93
       93
       +
             }

     

       94
       94
       +
       

     

       95
       95
       +
             // Fetch video data from Streamable API

     

       96
       96
       +
             final response = await _dio.get<Map<String, dynamic>>(

     

       97
       97
       +
               'https://api.streamable.com/videos/$shortcode',

     

       98
       98
       +
             );

     

       99
       99
       +
       

     

       100
       100
       +
             if (response.statusCode == 200 && response.data != null) {

     

       101
       101
       +
               final data = response.data!;

     

       102
       102
       +
       

     

       103
       103
       +
               // Extract MP4 URL from response

     

       104
       104
       +
               // Response structure: { "files": { "mp4": { "url": "//..." } } }

     

       105
       105
       +
               final files = data['files'] as Map<String, dynamic>?;

     

       106
       106
       +
               if (files == null) {

     

       107
       107
       +
                 if (kDebugMode) {

     

       108
       108
       +
                   debugPrint('No files found in Streamable response');

     

       109
       109
       +
                 }

     

       110
       110
       +
                 return null;

     

       111
       111
       +
               }

     

       112
       112
       +
       

     

       113
       113
       +
               final mp4 = files['mp4'] as Map<String, dynamic>?;

     

       114
       114
       +
               if (mp4 == null) {

     

       115
       115
       +
                 if (kDebugMode) {

     

       116
       116
       +
                   debugPrint('No MP4 file found in Streamable response');

     

       117
       117
       +
                 }

     

       118
       118
       +
                 return null;

     

       119
       119
       +
               }

     

       120
       120
       +
       

     

       121
       121
       +
               var videoUrl = mp4['url'] as String?;

     

       122
       122
       +
               if (videoUrl == null) {

     

       123
       123
       +
                 if (kDebugMode) {

     

       124
       124
       +
                   debugPrint('No URL found in MP4 data');

     

       125
       125
       +
                 }

     

       126
       126
       +
                 return null;

     

       127
       127
       +
               }

     

       128
       128
       +
       

     

       129
       129
       +
               // Prepend https: if URL is protocol-relative

     

       130
       130
       +
               if (videoUrl.startsWith('//')) {

     

       131
       131
       +
                 videoUrl = 'https:$videoUrl';

     

       132
       132
       +
               }

     

       133
       133
       +
       

     

       134
       134
       +
               // Cache the URL for future requests

     

       135
       135
       +
               _urlCache[shortcode] = (url: videoUrl, cachedAt: DateTime.now());

     

       136
       136
       +
       

     

       137
       137
       +
               return videoUrl;

     

       138
       138
       +
             }

     

       139
       139
       +
       

     

       140
       140
       +
             if (kDebugMode) {

     

       141
       141
       +
               debugPrint('Failed to fetch Streamable video: ${response.statusCode}');

     

       142
       142
       +
             }

     

       143
       143
       +
             return null;

     

       144
       144
       +
           } on DioException catch (e) {

     

       145
       145
       +
             if (kDebugMode) {

     

       146
       146
       +
               debugPrint('Error fetching Streamable video URL: $e');

     

       147
       147
       +
             }

     

       148
       148
       +
             return null;

     

       149
       149
       +
           }

     

       150
       150
       +
         }

     

       151
       151
       +
       }

+172

lib/widgets/fullscreen_video_player.dart

···

       1
       1
       +
       import 'package:flutter/foundation.dart';

     

       2
       2
       +
       import 'package:flutter/material.dart';

     

       3
       3
       +
       import 'package:video_player/video_player.dart';

     

       4
       4
       +
       

     

       5
       5
       +
       import '../constants/app_colors.dart';

     

       6
       6
       +
       import 'minimal_video_controls.dart';

     

       7
       7
       +
       

     

       8
       8
       +
       /// Fullscreen video player with swipe-to-dismiss gesture

     

       9
       9
       +
       ///

     

       10
       10
       +
       /// Displays the video player in fullscreen with a black background.

     

       11
       11
       +
       /// Supports vertical swipe-down gesture to dismiss (like Instagram/TikTok).

     

       12
       12
       +
       class FullscreenVideoPlayer extends StatefulWidget {

     

       13
       13
       +
         const FullscreenVideoPlayer({required this.videoUrl, super.key});

     

       14
       14
       +
       

     

       15
       15
       +
         final String videoUrl;

     

       16
       16
       +
       

     

       17
       17
       +
         @override

     

       18
       18
       +
         State<FullscreenVideoPlayer> createState() => _FullscreenVideoPlayerState();

     

       19
       19
       +
       }

     

       20
       20
       +
       

     

       21
       21
       +
       class _FullscreenVideoPlayerState extends State<FullscreenVideoPlayer>

     

       22
       22
       +
           with WidgetsBindingObserver {

     

       23
       23
       +
         double _dragOffsetX = 0;

     

       24
       24
       +
         double _dragOffsetY = 0;

     

       25
       25
       +
         bool _isDragging = false;

     

       26
       26
       +
         VideoPlayerController? _videoController;

     

       27
       27
       +
         bool _isInitializing = true;

     

       28
       28
       +
       

     

       29
       29
       +
         @override

     

       30
       30
       +
         void initState() {

     

       31
       31
       +
           super.initState();

     

       32
       32
       +
           WidgetsBinding.instance.addObserver(this);

     

       33
       33
       +
           _initializePlayer();

     

       34
       34
       +
         }

     

       35
       35
       +
       

     

       36
       36
       +
         @override

     

       37
       37
       +
         void dispose() {

     

       38
       38
       +
           WidgetsBinding.instance.removeObserver(this);

     

       39
       39
       +
           _videoController?.dispose();

     

       40
       40
       +
           super.dispose();

     

       41
       41
       +
         }

     

       42
       42
       +
       

     

       43
       43
       +
         @override

     

       44
       44
       +
         void didChangeAppLifecycleState(AppLifecycleState state) {

     

       45
       45
       +
           // Pause video when app goes to background

     

       46
       46
       +
           if (state == AppLifecycleState.paused ||

     

       47
       47
       +
               state == AppLifecycleState.inactive) {

     

       48
       48
       +
             _videoController?.pause();

     

       49
       49
       +
           }

     

       50
       50
       +
         }

     

       51
       51
       +
       

     

       52
       52
       +
         Future<void> _initializePlayer() async {

     

       53
       53
       +
           try {

     

       54
       54
       +
             _videoController = VideoPlayerController.networkUrl(

     

       55
       55
       +
               Uri.parse(widget.videoUrl),

     

       56
       56
       +
             );

     

       57
       57
       +
       

     

       58
       58
       +
             await _videoController!.initialize();

     

       59
       59
       +
             await _videoController!.play();

     

       60
       60
       +
       

     

       61
       61
       +
             if (mounted) {

     

       62
       62
       +
               setState(() {

     

       63
       63
       +
                 _isInitializing = false;

     

       64
       64
       +
               });

     

       65
       65
       +
             }

     

       66
       66
       +
           } on Exception catch (e) {

     

       67
       67
       +
             if (kDebugMode) {

     

       68
       68
       +
               debugPrint('Error initializing video: $e');

     

       69
       69
       +
             }

     

       70
       70
       +
             if (mounted) {

     

       71
       71
       +
               setState(() {

     

       72
       72
       +
                 _isInitializing = false;

     

       73
       73
       +
               });

     

       74
       74
       +
             }

     

       75
       75
       +
           }

     

       76
       76
       +
         }

     

       77
       77
       +
       

     

       78
       78
       +
         void _onPanUpdate(DragUpdateDetails details) {

     

       79
       79
       +
           setState(() {

     

       80
       80
       +
             _isDragging = true;

     

       81
       81
       +
             // Track both horizontal and vertical movement

     

       82
       82
       +
             _dragOffsetX += details.delta.dx;

     

       83
       83
       +
             _dragOffsetY += details.delta.dy;

     

       84
       84
       +
           });

     

       85
       85
       +
         }

     

       86
       86
       +
       

     

       87
       87
       +
         void _onPanEnd(DragEndDetails details) {

     

       88
       88
       +
           // If dragged more than 100 pixels vertically, dismiss

     

       89
       89
       +
           if (_dragOffsetY.abs() > 100) {

     

       90
       90
       +
             Navigator.of(context).pop();

     

       91
       91
       +
           } else {

     

       92
       92
       +
             // Otherwise, animate back to original position

     

       93
       93
       +
             setState(() {

     

       94
       94
       +
               _dragOffsetX = 0.0;

     

       95
       95
       +
               _dragOffsetY = 0.0;

     

       96
       96
       +
               _isDragging = false;

     

       97
       97
       +
             });

     

       98
       98
       +
           }

     

       99
       99
       +
         }

     

       100
       100
       +
       

     

       101
       101
       +
         void _togglePlayPause() {

     

       102
       102
       +
           if (_videoController == null || !_videoController!.value.isInitialized) {

     

       103
       103
       +
             return;

     

       104
       104
       +
           }

     

       105
       105
       +
       

     

       106
       106
       +
           setState(() {

     

       107
       107
       +
             if (_videoController!.value.isPlaying) {

     

       108
       108
       +
               _videoController!.pause();

     

       109
       109
       +
             } else {

     

       110
       110
       +
               _videoController!.play();

     

       111
       111
       +
             }

     

       112
       112
       +
           });

     

       113
       113
       +
         }

     

       114
       114
       +
       

     

       115
       115
       +
         @override

     

       116
       116
       +
         Widget build(BuildContext context) {

     

       117
       117
       +
           // Calculate opacity based on drag offset (fade out as user drags)

     

       118
       118
       +
           final opacity = (1.0 - (_dragOffsetY.abs() / 300)).clamp(0.0, 1.0);

     

       119
       119
       +
       

     

       120
       120
       +
           return Scaffold(

     

       121
       121
       +
             backgroundColor: Colors.black.withValues(alpha: opacity),

     

       122
       122
       +
             body: GestureDetector(

     

       123
       123
       +
               onPanUpdate: _onPanUpdate,

     

       124
       124
       +
               onPanEnd: _onPanEnd,

     

       125
       125
       +
               onTap: _togglePlayPause,

     

       126
       126
       +
               child: Stack(

     

       127
       127
       +
                 children: [

     

       128
       128
       +
                   // Video player - fills entire screen and moves with drag

     

       129
       129
       +
                   AnimatedContainer(

     

       130
       130
       +
                     duration:

     

       131
       131
       +
                         _isDragging

     

       132
       132
       +
                             ? Duration.zero

     

       133
       133
       +
                             : const Duration(milliseconds: 200),

     

       134
       134
       +
                     curve: Curves.easeOut,

     

       135
       135
       +
                     transform: Matrix4.translationValues(

     

       136
       136
       +
                       _dragOffsetX,

     

       137
       137
       +
                       _dragOffsetY,

     

       138
       138
       +
                       0,

     

       139
       139
       +
                     ),

     

       140
       140
       +
                     child: SizedBox.expand(

     

       141
       141
       +
                       child:

     

       142
       142
       +
                           _isInitializing || _videoController == null

     

       143
       143
       +
                               ? const Center(

     

       144
       144
       +
                                 child: CircularProgressIndicator(

     

       145
       145
       +
                                   color: AppColors.loadingIndicator,

     

       146
       146
       +
                                 ),

     

       147
       147
       +
                               )

     

       148
       148
       +
                               : Center(

     

       149
       149
       +
                                 child: AspectRatio(

     

       150
       150
       +
                                   aspectRatio: _videoController!.value.aspectRatio,

     

       151
       151
       +
                                   child: VideoPlayer(_videoController!),

     

       152
       152
       +
                                 ),

     

       153
       153
       +
                               ),

     

       154
       154
       +
                     ),

     

       155
       155
       +
                   ),

     

       156
       156
       +
                   // Minimal controls at bottom (scrubber only)

     

       157
       157
       +
                   if (_videoController != null &&

     

       158
       158
       +
                       _videoController!.value.isInitialized)

     

       159
       159
       +
                     Positioned(

     

       160
       160
       +
                       bottom: 0,

     

       161
       161
       +
                       left: 0,

     

       162
       162
       +
                       right: 0,

     

       163
       163
       +
                       child: SafeArea(

     

       164
       164
       +
                         child: MinimalVideoControls(controller: _videoController!),

     

       165
       165
       +
                       ),

     

       166
       166
       +
                     ),

     

       167
       167
       +
                 ],

     

       168
       168
       +
               ),

     

       169
       169
       +
             ),

     

       170
       170
       +
           );

     

       171
       171
       +
         }

     

       172
       172
       +
       }

+144

lib/widgets/minimal_video_controls.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       import 'package:video_player/video_player.dart';

     

       3
       3
       +
       

     

       4
       4
       +
       import '../constants/app_colors.dart';

     

       5
       5
       +
       

     

       6
       6
       +
       /// Minimal video controls showing only a scrubber/progress bar

     

       7
       7
       +
       ///

     

       8
       8
       +
       /// Always visible at the bottom of the video, positioned above

     

       9
       9
       +
       /// the Android navigation bar using SafeArea.

     

       10
       10
       +
       class MinimalVideoControls extends StatefulWidget {

     

       11
       11
       +
         const MinimalVideoControls({

     

       12
       12
       +
           required this.controller,

     

       13
       13
       +
           super.key,

     

       14
       14
       +
         });

     

       15
       15
       +
       

     

       16
       16
       +
         final VideoPlayerController controller;

     

       17
       17
       +
       

     

       18
       18
       +
         @override

     

       19
       19
       +
         State<MinimalVideoControls> createState() => _MinimalVideoControlsState();

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       class _MinimalVideoControlsState extends State<MinimalVideoControls> {

     

       23
       23
       +
         double _sliderValue = 0;

     

       24
       24
       +
         bool _isUserDragging = false;

     

       25
       25
       +
       

     

       26
       26
       +
         @override

     

       27
       27
       +
         void initState() {

     

       28
       28
       +
           super.initState();

     

       29
       29
       +
           widget.controller.addListener(_updateSlider);

     

       30
       30
       +
         }

     

       31
       31
       +
       

     

       32
       32
       +
         @override

     

       33
       33
       +
         void dispose() {

     

       34
       34
       +
           widget.controller.removeListener(_updateSlider);

     

       35
       35
       +
           super.dispose();

     

       36
       36
       +
         }

     

       37
       37
       +
       

     

       38
       38
       +
         void _updateSlider() {

     

       39
       39
       +
           if (!_isUserDragging && mounted) {

     

       40
       40
       +
             final position =

     

       41
       41
       +
                 widget.controller.value.position.inMilliseconds.toDouble();

     

       42
       42
       +
             final duration =

     

       43
       43
       +
                 widget.controller.value.duration.inMilliseconds.toDouble();

     

       44
       44
       +
       

     

       45
       45
       +
             if (duration > 0) {

     

       46
       46
       +
               setState(() {

     

       47
       47
       +
                 _sliderValue = position / duration;

     

       48
       48
       +
               });

     

       49
       49
       +
             }

     

       50
       50
       +
           }

     

       51
       51
       +
         }

     

       52
       52
       +
       

     

       53
       53
       +
         void _onSliderChanged(double value) {

     

       54
       54
       +
           setState(() {

     

       55
       55
       +
             _sliderValue = value;

     

       56
       56
       +
           });

     

       57
       57
       +
         }

     

       58
       58
       +
       

     

       59
       59
       +
         void _onSliderChangeStart(double value) {

     

       60
       60
       +
           _isUserDragging = true;

     

       61
       61
       +
         }

     

       62
       62
       +
       

     

       63
       63
       +
         void _onSliderChangeEnd(double value) {

     

       64
       64
       +
           _isUserDragging = false;

     

       65
       65
       +
           final duration = widget.controller.value.duration;

     

       66
       66
       +
           final position = duration * value;

     

       67
       67
       +
           widget.controller.seekTo(position);

     

       68
       68
       +
         }

     

       69
       69
       +
       

     

       70
       70
       +
         String _formatDuration(Duration duration) {

     

       71
       71
       +
           final minutes = duration.inMinutes;

     

       72
       72
       +
           final seconds = duration.inSeconds % 60;

     

       73
       73
       +
           return '${minutes.toString().padLeft(1, '0')}:'

     

       74
       74
       +
               '${seconds.toString().padLeft(2, '0')}';

     

       75
       75
       +
         }

     

       76
       76
       +
       

     

       77
       77
       +
         @override

     

       78
       78
       +
         Widget build(BuildContext context) {

     

       79
       79
       +
           final position = widget.controller.value.position;

     

       80
       80
       +
           final duration = widget.controller.value.duration;

     

       81
       81
       +
       

     

       82
       82
       +
           return Container(

     

       83
       83
       +
             padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),

     

       84
       84
       +
             decoration: BoxDecoration(

     

       85
       85
       +
               gradient: LinearGradient(

     

       86
       86
       +
                 begin: Alignment.bottomCenter,

     

       87
       87
       +
                 end: Alignment.topCenter,

     

       88
       88
       +
                 colors: [

     

       89
       89
       +
                   Colors.black.withValues(alpha: 0.7),

     

       90
       90
       +
                   Colors.black.withValues(alpha: 0),

     

       91
       91
       +
                 ],

     

       92
       92
       +
               ),

     

       93
       93
       +
             ),

     

       94
       94
       +
             child: Column(

     

       95
       95
       +
               mainAxisSize: MainAxisSize.min,

     

       96
       96
       +
               children: [

     

       97
       97
       +
                 // Scrubber slider

     

       98
       98
       +
                 SliderTheme(

     

       99
       99
       +
                   data: SliderThemeData(

     

       100
       100
       +
                     trackHeight: 3,

     

       101
       101
       +
                     thumbShape:

     

       102
       102
       +
                         const RoundSliderThumbShape(enabledThumbRadius: 6),

     

       103
       103
       +
                     overlayShape:

     

       104
       104
       +
                         const RoundSliderOverlayShape(overlayRadius: 12),

     

       105
       105
       +
                     activeTrackColor: AppColors.primary,

     

       106
       106
       +
                     inactiveTrackColor: Colors.white.withValues(alpha: 0.3),

     

       107
       107
       +
                     thumbColor: AppColors.primary,

     

       108
       108
       +
                     overlayColor: AppColors.primary.withValues(alpha: 0.3),

     

       109
       109
       +
                   ),

     

       110
       110
       +
                   child: Slider(

     

       111
       111
       +
                     value: _sliderValue.clamp(0, 1.0),

     

       112
       112
       +
                     onChanged: _onSliderChanged,

     

       113
       113
       +
                     onChangeStart: _onSliderChangeStart,

     

       114
       114
       +
                     onChangeEnd: _onSliderChangeEnd,

     

       115
       115
       +
                   ),

     

       116
       116
       +
                 ),

     

       117
       117
       +
                 // Time labels

     

       118
       118
       +
                 Padding(

     

       119
       119
       +
                   padding: const EdgeInsets.symmetric(horizontal: 8),

     

       120
       120
       +
                   child: Row(

     

       121
       121
       +
                     mainAxisAlignment: MainAxisAlignment.spaceBetween,

     

       122
       122
       +
                     children: [

     

       123
       123
       +
                       Text(

     

       124
       124
       +
                         _formatDuration(position),

     

       125
       125
       +
                         style: const TextStyle(

     

       126
       126
       +
                           color: Colors.white,

     

       127
       127
       +
                           fontSize: 12,

     

       128
       128
       +
                         ),

     

       129
       129
       +
                       ),

     

       130
       130
       +
                       Text(

     

       131
       131
       +
                         _formatDuration(duration),

     

       132
       132
       +
                         style: TextStyle(

     

       133
       133
       +
                           color: Colors.white.withValues(alpha: 0.7),

     

       134
       134
       +
                           fontSize: 12,

     

       135
       135
       +
                         ),

     

       136
       136
       +
                       ),

     

       137
       137
       +
                     ],

     

       138
       138
       +
                   ),

     

       139
       139
       +
                 ),

     

       140
       140
       +
               ],

     

       141
       141
       +
             ),

     

       142
       142
       +
           );

     

       143
       143
       +
         }

     

       144
       144
       +
       }

+121 -6

lib/widgets/post_card.dart

···

       1
       1
        
       import 'package:cached_network_image/cached_network_image.dart';

     

       2
       2
        
       import 'package:flutter/foundation.dart';

     

       3
       3
        
       import 'package:flutter/material.dart';

     

       4
       4
       +
       import 'package:provider/provider.dart';

     

       4
       5
        
       

     

       5
       6
        
       import '../constants/app_colors.dart';

     

       6
       7
        
       import '../models/post.dart';

     

       8
       8
       +
       import '../services/streamable_service.dart';

     

       7
       9
        
       import '../utils/community_handle_utils.dart';

     

       8
       10
        
       import '../utils/date_time_utils.dart';

     

       9
       11
        
       import 'external_link_bar.dart';

     

       12
       12
       +
       import 'fullscreen_video_player.dart';

     

       10
       13
        
       import 'post_card_actions.dart';

     

       11
       14
        
       

     

       12
       15
        
       /// Post card widget for displaying feed posts

     
···

       98
       101
        
       

     

       99
       102
        
                   // Embed (link preview)

     

       100
       103
        
                   if (post.post.embed?.external != null) ...[

     

       101
       101
       -
                     _EmbedCard(embed: post.post.embed!.external!),

     

       104
       104
       +
                     _EmbedCard(

     

       105
       105
       +
                       embed: post.post.embed!.external!,

     

       106
       106
       +
                       streamableService: context.read<StreamableService>(),

     

       107
       107
       +
                     ),

     

       102
       108
        
                     const SizedBox(height: 8),

     

       103
       109
        
                   ],

     

       104
       110
        
       

     
···

       220
       226
        
       /// Embed card widget for displaying link previews

     

       221
       227
        
       ///

     

       222
       228
        
       /// Shows a thumbnail image for external embeds with loading and error states.

     

       223
       223
       -
       class _EmbedCard extends StatelessWidget {

     

       224
       224
       -
         const _EmbedCard({required this.embed});

     

       229
       229
       +
       /// For video embeds (Streamable), displays a play button overlay and opens

     

       230
       230
       +
       /// a video player dialog when tapped.

     

       231
       231
       +
       class _EmbedCard extends StatefulWidget {

     

       232
       232
       +
         const _EmbedCard({required this.embed, required this.streamableService});

     

       225
       233
        
       

     

       226
       234
        
         final ExternalEmbed embed;

     

       235
       235
       +
         final StreamableService streamableService;

     

       236
       236
       +
       

     

       237
       237
       +
         @override

     

       238
       238
       +
         State<_EmbedCard> createState() => _EmbedCardState();

     

       239
       239
       +
       }

     

       240
       240
       +
       

     

       241
       241
       +
       class _EmbedCardState extends State<_EmbedCard> {

     

       242
       242
       +
         bool _isLoadingVideo = false;

     

       243
       243
       +
       

     

       244
       244
       +
         /// Checks if this embed is a video

     

       245
       245
       +
         bool get _isVideo {

     

       246
       246
       +
           final embedType = widget.embed.embedType;

     

       247
       247
       +
           return embedType == 'video' || embedType == 'video-stream';

     

       248
       248
       +
         }

     

       249
       249
       +
       

     

       250
       250
       +
         /// Checks if this is a Streamable video

     

       251
       251
       +
         bool get _isStreamableVideo {

     

       252
       252
       +
           return _isVideo && widget.embed.provider?.toLowerCase() == 'streamable';

     

       253
       253
       +
         }

     

       254
       254
       +
       

     

       255
       255
       +
         /// Shows the video player in fullscreen with swipe-to-dismiss

     

       256
       256
       +
         Future<void> _showVideoPlayer(BuildContext context) async {

     

       257
       257
       +
           // Capture context-dependent objects before async gap

     

       258
       258
       +
           final messenger = ScaffoldMessenger.of(context);

     

       259
       259
       +
           final navigator = Navigator.of(context);

     

       260
       260
       +
       

     

       261
       261
       +
           setState(() {

     

       262
       262
       +
             _isLoadingVideo = true;

     

       263
       263
       +
           });

     

       264
       264
       +
       

     

       265
       265
       +
           try {

     

       266
       266
       +
             // Fetch the MP4 URL from Streamable using the injected service

     

       267
       267
       +
             final videoUrl = await widget.streamableService.getVideoUrl(

     

       268
       268
       +
               widget.embed.uri,

     

       269
       269
       +
             );

     

       270
       270
       +
       

     

       271
       271
       +
             if (!mounted) {

     

       272
       272
       +
               return;

     

       273
       273
       +
             }

     

       274
       274
       +
       

     

       275
       275
       +
             if (videoUrl == null) {

     

       276
       276
       +
               // Show error if we couldn't get the video URL

     

       277
       277
       +
               messenger.showSnackBar(

     

       278
       278
       +
                 SnackBar(

     

       279
       279
       +
                   content: Text(

     

       280
       280
       +
                     'Failed to load video',

     

       281
       281
       +
                     style: TextStyle(

     

       282
       282
       +
                       color: AppColors.textPrimary.withValues(alpha: 0.9),

     

       283
       283
       +
                     ),

     

       284
       284
       +
                   ),

     

       285
       285
       +
                   backgroundColor: AppColors.backgroundSecondary,

     

       286
       286
       +
                 ),

     

       287
       287
       +
               );

     

       288
       288
       +
               return;

     

       289
       289
       +
             }

     

       290
       290
       +
       

     

       291
       291
       +
             // Navigate to fullscreen video player

     

       292
       292
       +
             await navigator.push<void>(

     

       293
       293
       +
               MaterialPageRoute(

     

       294
       294
       +
                 builder: (context) => FullscreenVideoPlayer(videoUrl: videoUrl),

     

       295
       295
       +
                 fullscreenDialog: true,

     

       296
       296
       +
               ),

     

       297
       297
       +
             );

     

       298
       298
       +
           } finally {

     

       299
       299
       +
             if (mounted) {

     

       300
       300
       +
               setState(() {

     

       301
       301
       +
                 _isLoadingVideo = false;

     

       302
       302
       +
               });

     

       303
       303
       +
             }

     

       304
       304
       +
           }

     

       305
       305
       +
         }

     

       227
       306
        
       

     

       228
       307
        
         @override

     

       229
       308
        
         Widget build(BuildContext context) {

     

       230
       309
        
           // Only show image if thumbnail exists

     

       231
       231
       -
           if (embed.thumb == null) {

     

       310
       310
       +
           if (widget.embed.thumb == null) {

     

       232
       311
        
             return const SizedBox.shrink();

     

       233
       312
        
           }

     

       234
       313
        
       

     

       235
       235
       -
           return Container(

     

       314
       314
       +
           // Build the thumbnail image

     

       315
       315
       +
           final thumbnailWidget = Container(

     

       236
       316
        
             decoration: BoxDecoration(

     

       237
       317
        
               borderRadius: BorderRadius.circular(8),

     

       238
       318
        
               border: Border.all(color: AppColors.border),

     

       239
       319
        
             ),

     

       240
       320
        
             clipBehavior: Clip.antiAlias,

     

       241
       321
        
             child: CachedNetworkImage(

     

       242
       242
       -
               imageUrl: embed.thumb!,

     

       322
       322
       +
               imageUrl: widget.embed.thumb!,

     

       243
       323
        
               width: double.infinity,

     

       244
       324
        
               height: 180,

     

       245
       325
        
               fit: BoxFit.cover,

     
···

       272
       352
        
               },

     

       273
       353
        
             ),

     

       274
       354
        
           );

     

       355
       355
       +
       

     

       356
       356
       +
           // If this is a Streamable video, add play button overlay and tap handler

     

       357
       357
       +
           if (_isStreamableVideo) {

     

       358
       358
       +
             return GestureDetector(

     

       359
       359
       +
               onTap: _isLoadingVideo ? null : () => _showVideoPlayer(context),

     

       360
       360
       +
               child: Stack(

     

       361
       361
       +
                 alignment: Alignment.center,

     

       362
       362
       +
                 children: [

     

       363
       363
       +
                   thumbnailWidget,

     

       364
       364
       +
                   // Semi-transparent play button or loading indicator overlay

     

       365
       365
       +
                   Container(

     

       366
       366
       +
                     width: 64,

     

       367
       367
       +
                     height: 64,

     

       368
       368
       +
                     decoration: BoxDecoration(

     

       369
       369
       +
                       color: AppColors.background.withValues(alpha: 0.7),

     

       370
       370
       +
                       shape: BoxShape.circle,

     

       371
       371
       +
                     ),

     

       372
       372
       +
                     child:

     

       373
       373
       +
                         _isLoadingVideo

     

       374
       374
       +
                             ? const CircularProgressIndicator(

     

       375
       375
       +
                               color: AppColors.loadingIndicator,

     

       376
       376
       +
                             )

     

       377
       377
       +
                             : const Icon(

     

       378
       378
       +
                               Icons.play_arrow,

     

       379
       379
       +
                               color: AppColors.textPrimary,

     

       380
       380
       +
                               size: 48,

     

       381
       381
       +
                             ),

     

       382
       382
       +
                   ),

     

       383
       383
       +
                 ],

     

       384
       384
       +
               ),

     

       385
       385
       +
             );

     

       386
       386
       +
           }

     

       387
       387
       +
       

     

       388
       388
       +
           // For non-video embeds, just return the thumbnail

     

       389
       389
       +
           return thumbnailWidget;

     

       275
       390
        
         }

     

       276
       391
        
       }

macos/Flutter/GeneratedPluginRegistrant.swift

···

       12
       12
        
       import shared_preferences_foundation

     

       13
       13
        
       import sqflite_darwin

     

       14
       14
        
       import url_launcher_macos

     

       15
       15
       +
       import video_player_avfoundation

     

       15
       16
        
       import window_to_front

     

       16
       17
        
       

     

       17
       18
        
       func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) {

     
···

       22
       23
        
         SharedPreferencesPlugin.register(with: registry.registrar(forPlugin: "SharedPreferencesPlugin"))

     

       23
       24
        
         SqflitePlugin.register(with: registry.registrar(forPlugin: "SqflitePlugin"))

     

       24
       25
        
         UrlLauncherPlugin.register(with: registry.registrar(forPlugin: "UrlLauncherPlugin"))

     

       26
       26
       +
         FVPVideoPlayerPlugin.register(with: registry.registrar(forPlugin: "FVPVideoPlayerPlugin"))

     

       25
       27
        
         WindowToFrontPlugin.register(with: registry.registrar(forPlugin: "WindowToFrontPlugin"))

     

       26
       28
        
       }

+72

pubspec.lock

···

       176
       176
        
             url: "https://pub.dev"

     

       177
       177
        
           source: hosted

     

       178
       178
        
           version: "3.0.6"

     

       179
       179
       +
         csslib:

     

       180
       180
       +
           dependency: transitive

     

       181
       181
       +
           description:

     

       182
       182
       +
             name: csslib

     

       183
       183
       +
             sha256: "09bad715f418841f976c77db72d5398dc1253c21fb9c0c7f0b0b985860b2d58e"

     

       184
       184
       +
             url: "https://pub.dev"

     

       185
       185
       +
           source: hosted

     

       186
       186
       +
           version: "1.0.2"

     

       179
       187
        
         cupertino_icons:

     

       180
       188
        
           dependency: "direct main"

     

       181
       189
        
           description:

     
···

       375
       383
        
             url: "https://pub.dev"

     

       376
       384
        
           source: hosted

     

       377
       385
        
           version: "2.3.2"

     

       386
       386
       +
         html:

     

       387
       387
       +
           dependency: transitive

     

       388
       388
       +
           description:

     

       389
       389
       +
             name: html

     

       390
       390
       +
             sha256: "6d1264f2dffa1b1101c25a91dff0dc2daee4c18e87cd8538729773c073dbf602"

     

       391
       391
       +
             url: "https://pub.dev"

     

       392
       392
       +
           source: hosted

     

       393
       393
       +
           version: "0.15.6"

     

       378
       394
        
         http:

     

       379
       395
        
           dependency: "direct dev"

     

       380
       396
        
           description:

     
···

       383
       399
        
             url: "https://pub.dev"

     

       384
       400
        
           source: hosted

     

       385
       401
        
           version: "1.5.0"

     

       402
       402
       +
         http_mock_adapter:

     

       403
       403
       +
           dependency: "direct dev"

     

       404
       404
       +
           description:

     

       405
       405
       +
             name: http_mock_adapter

     

       406
       406
       +
             sha256: "46399c78bd4a0af071978edd8c502d7aeeed73b5fb9860bca86b5ed647a63c1b"

     

       407
       407
       +
             url: "https://pub.dev"

     

       408
       408
       +
           source: hosted

     

       409
       409
       +
           version: "0.6.1"

     

       386
       410
        
         http_multi_server:

     

       387
       411
        
           dependency: transitive

     

       388
       412
        
           description:

     
···

       455
       479
        
             url: "https://pub.dev"

     

       456
       480
        
           source: hosted

     

       457
       481
        
           version: "6.0.0"

     

       482
       482
       +
         logger:

     

       483
       483
       +
           dependency: transitive

     

       484
       484
       +
           description:

     

       485
       485
       +
             name: logger

     

       486
       486
       +
             sha256: a7967e31b703831a893bbc3c3dd11db08126fe5f369b5c648a36f821979f5be3

     

       487
       487
       +
             url: "https://pub.dev"

     

       488
       488
       +
           source: hosted

     

       489
       489
       +
           version: "2.6.2"

     

       458
       490
        
         logging:

     

       459
       491
        
           dependency: transitive

     

       460
       492
        
           description:

     
···

       972
       1004
        
             url: "https://pub.dev"

     

       973
       1005
        
           source: hosted

     

       974
       1006
        
           version: "2.2.0"

     

       1007
       1007
       +
         video_player:

     

       1008
       1008
       +
           dependency: "direct main"

     

       1009
       1009
       +
           description:

     

       1010
       1010
       +
             name: video_player

     

       1011
       1011
       +
             sha256: "0d55b1f1a31e5ad4c4967bfaa8ade0240b07d20ee4af1dfef5f531056512961a"

     

       1012
       1012
       +
             url: "https://pub.dev"

     

       1013
       1013
       +
           source: hosted

     

       1014
       1014
       +
           version: "2.10.0"

     

       1015
       1015
       +
         video_player_android:

     

       1016
       1016
       +
           dependency: transitive

     

       1017
       1017
       +
           description:

     

       1018
       1018
       +
             name: video_player_android

     

       1019
       1019
       +
             sha256: cf768d02924b91e333e2bc1ff928528f57d686445874f383bafab12d0bdfc340

     

       1020
       1020
       +
             url: "https://pub.dev"

     

       1021
       1021
       +
           source: hosted

     

       1022
       1022
       +
           version: "2.8.17"

     

       1023
       1023
       +
         video_player_avfoundation:

     

       1024
       1024
       +
           dependency: transitive

     

       1025
       1025
       +
           description:

     

       1026
       1026
       +
             name: video_player_avfoundation

     

       1027
       1027
       +
             sha256: "19ed1162a7a5520e7d7791e0b7b73ba03161b6a69428b82e4689e435b325432d"

     

       1028
       1028
       +
             url: "https://pub.dev"

     

       1029
       1029
       +
           source: hosted

     

       1030
       1030
       +
           version: "2.8.5"

     

       1031
       1031
       +
         video_player_platform_interface:

     

       1032
       1032
       +
           dependency: transitive

     

       1033
       1033
       +
           description:

     

       1034
       1034
       +
             name: video_player_platform_interface

     

       1035
       1035
       +
             sha256: "57c5d73173f76d801129d0531c2774052c5a7c11ccb962f1830630decd9f24ec"

     

       1036
       1036
       +
             url: "https://pub.dev"

     

       1037
       1037
       +
           source: hosted

     

       1038
       1038
       +
           version: "6.6.0"

     

       1039
       1039
       +
         video_player_web:

     

       1040
       1040
       +
           dependency: transitive

     

       1041
       1041
       +
           description:

     

       1042
       1042
       +
             name: video_player_web

     

       1043
       1043
       +
             sha256: "9f3c00be2ef9b76a95d94ac5119fb843dca6f2c69e6c9968f6f2b6c9e7afbdeb"

     

       1044
       1044
       +
             url: "https://pub.dev"

     

       1045
       1045
       +
           source: hosted

     

       1046
       1046
       +
           version: "2.4.0"

     

       975
       1047
        
         vm_service:

     

       976
       1048
        
           dependency: transitive

     

       977
       1049
        
           description:

+3 -1

pubspec.yaml

···

       45
       45
        
         dio: ^5.9.0

     

       46
       46
        
         cached_network_image: ^3.4.1

     

       47
       47
        
         url_launcher: ^6.3.1

     

       48
       48
       +
         video_player: ^2.8.7  # Pinned for stability

     

       48
       49
        
       

     

       49
       50
        
       dev_dependencies:

     

       50
       51
        
         flutter_test:

     
···

       61
       62
        
         # Testing dependencies

     

       62
       63
        
         mockito: ^5.4.4

     

       63
       64
        
         build_runner: ^2.4.13

     

       65
       65
       +
         http: any

     

       66
       66
       +
         http_mock_adapter: ^0.6.1

     

       64
       67
        
       

     

       65
       68
        
       # For information on the generic Dart part of this file, see the

     

       66
       69
        
       # following page: https://dart.dev/tools/pub/pubspec

     

       67
       70
        
       

     

       68
       71
        
       # The following section is specific to Flutter packages.

     

       69
       69
       -
         http: any

     

       70
       72
        
       flutter:

     

       71
       73
        
       

     

       72
       74
        
         # The following line ensures that the Material Icons font is

+280

test/services/streamable_service_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/services/streamable_service.dart';

     

       2
       2
       +
       import 'package:dio/dio.dart';

     

       3
       3
       +
       import 'package:flutter_test/flutter_test.dart';

     

       4
       4
       +
       import 'package:http_mock_adapter/http_mock_adapter.dart';

     

       5
       5
       +
       

     

       6
       6
       +
       void main() {

     

       7
       7
       +
         group('StreamableService', () {

     

       8
       8
       +
           late Dio dio;

     

       9
       9
       +
           late DioAdapter dioAdapter;

     

       10
       10
       +
           late StreamableService service;

     

       11
       11
       +
       

     

       12
       12
       +
           setUp(() {

     

       13
       13
       +
             dio = Dio();

     

       14
       14
       +
             dioAdapter = DioAdapter(dio: dio);

     

       15
       15
       +
             service = StreamableService(dio: dio);

     

       16
       16
       +
           });

     

       17
       17
       +
       

     

       18
       18
       +
           group('extractShortcode', () {

     

       19
       19
       +
             test('extracts shortcode from standard URL', () {

     

       20
       20
       +
               expect(

     

       21
       21
       +
                 StreamableService.extractShortcode('https://streamable.com/abc123'),

     

       22
       22
       +
                 'abc123',

     

       23
       23
       +
               );

     

       24
       24
       +
             });

     

       25
       25
       +
       

     

       26
       26
       +
             test('extracts shortcode from /e/ URL', () {

     

       27
       27
       +
               expect(

     

       28
       28
       +
                 StreamableService.extractShortcode('https://streamable.com/e/abc123'),

     

       29
       29
       +
                 'abc123',

     

       30
       30
       +
               );

     

       31
       31
       +
             });

     

       32
       32
       +
       

     

       33
       33
       +
             test('extracts shortcode from URL without scheme', () {

     

       34
       34
       +
               expect(

     

       35
       35
       +
                 StreamableService.extractShortcode('streamable.com/xyz789'),

     

       36
       36
       +
                 'xyz789',

     

       37
       37
       +
               );

     

       38
       38
       +
             });

     

       39
       39
       +
       

     

       40
       40
       +
             test('extracts shortcode from /e/ URL without scheme', () {

     

       41
       41
       +
               expect(

     

       42
       42
       +
                 StreamableService.extractShortcode('streamable.com/e/xyz789'),

     

       43
       43
       +
                 'xyz789',

     

       44
       44
       +
               );

     

       45
       45
       +
             });

     

       46
       46
       +
       

     

       47
       47
       +
             test('returns null for empty path', () {

     

       48
       48
       +
               expect(

     

       49
       49
       +
                 StreamableService.extractShortcode('https://streamable.com/'),

     

       50
       50
       +
                 null,

     

       51
       51
       +
               );

     

       52
       52
       +
             });

     

       53
       53
       +
       

     

       54
       54
       +
             test('returns null for invalid URL', () {

     

       55
       55
       +
               expect(StreamableService.extractShortcode('not a url'), null);

     

       56
       56
       +
             });

     

       57
       57
       +
       

     

       58
       58
       +
             test('handles URL with query parameters', () {

     

       59
       59
       +
               expect(

     

       60
       60
       +
                 StreamableService.extractShortcode(

     

       61
       61
       +
                   'https://streamable.com/abc123?autoplay=1',

     

       62
       62
       +
                 ),

     

       63
       63
       +
                 'abc123',

     

       64
       64
       +
               );

     

       65
       65
       +
             });

     

       66
       66
       +
       

     

       67
       67
       +
             test('handles /e/ URL with query parameters', () {

     

       68
       68
       +
               expect(

     

       69
       69
       +
                 StreamableService.extractShortcode(

     

       70
       70
       +
                   'https://streamable.com/e/abc123?autoplay=1',

     

       71
       71
       +
                 ),

     

       72
       72
       +
                 'abc123',

     

       73
       73
       +
               );

     

       74
       74
       +
             });

     

       75
       75
       +
           });

     

       76
       76
       +
       

     

       77
       77
       +
           group('getVideoUrl', () {

     

       78
       78
       +
             test('fetches and returns MP4 URL successfully', () async {

     

       79
       79
       +
               const shortcode = 'abc123';

     

       80
       80
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/abc123.mp4';

     

       81
       81
       +
       

     

       82
       82
       +
               dioAdapter.onGet(

     

       83
       83
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       84
       84
       +
                 (server) => server.reply(200, {

     

       85
       85
       +
                   'files': {

     

       86
       86
       +
                     'mp4': {'url': videoUrl},

     

       87
       87
       +
                   },

     

       88
       88
       +
                 }),

     

       89
       89
       +
               );

     

       90
       90
       +
       

     

       91
       91
       +
               final result = await service.getVideoUrl(

     

       92
       92
       +
                 'https://streamable.com/$shortcode',

     

       93
       93
       +
               );

     

       94
       94
       +
       

     

       95
       95
       +
               expect(result, 'https:$videoUrl');

     

       96
       96
       +
             });

     

       97
       97
       +
       

     

       98
       98
       +
             test('handles /e/ URL format', () async {

     

       99
       99
       +
               const shortcode = 'xyz789';

     

       100
       100
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/xyz789.mp4';

     

       101
       101
       +
       

     

       102
       102
       +
               dioAdapter.onGet(

     

       103
       103
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       104
       104
       +
                 (server) => server.reply(200, {

     

       105
       105
       +
                   'files': {

     

       106
       106
       +
                     'mp4': {'url': videoUrl},

     

       107
       107
       +
                   },

     

       108
       108
       +
                 }),

     

       109
       109
       +
               );

     

       110
       110
       +
       

     

       111
       111
       +
               final result = await service.getVideoUrl(

     

       112
       112
       +
                 'https://streamable.com/e/$shortcode',

     

       113
       113
       +
               );

     

       114
       114
       +
       

     

       115
       115
       +
               expect(result, 'https:$videoUrl');

     

       116
       116
       +
             });

     

       117
       117
       +
       

     

       118
       118
       +
             test('caches video URLs', () async {

     

       119
       119
       +
               const shortcode = 'cached123';

     

       120
       120
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/cached123.mp4';

     

       121
       121
       +
       

     

       122
       122
       +
               dioAdapter.onGet(

     

       123
       123
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       124
       124
       +
                 (server) => server.reply(200, {

     

       125
       125
       +
                   'files': {

     

       126
       126
       +
                     'mp4': {'url': videoUrl},

     

       127
       127
       +
                   },

     

       128
       128
       +
                 }),

     

       129
       129
       +
               );

     

       130
       130
       +
       

     

       131
       131
       +
               // First call - should hit the API

     

       132
       132
       +
               final result1 = await service.getVideoUrl(

     

       133
       133
       +
                 'https://streamable.com/$shortcode',

     

       134
       134
       +
               );

     

       135
       135
       +
               expect(result1, 'https:$videoUrl');

     

       136
       136
       +
       

     

       137
       137
       +
               // Second call - should use cache (no additional network request)

     

       138
       138
       +
               final result2 = await service.getVideoUrl(

     

       139
       139
       +
                 'https://streamable.com/$shortcode',

     

       140
       140
       +
               );

     

       141
       141
       +
               expect(result2, 'https:$videoUrl');

     

       142
       142
       +
             });

     

       143
       143
       +
       

     

       144
       144
       +
             test('returns null for invalid shortcode', () async {

     

       145
       145
       +
               const shortcode = 'invalid';

     

       146
       146
       +
       

     

       147
       147
       +
               dioAdapter.onGet(

     

       148
       148
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       149
       149
       +
                 (server) => server.reply(404, {'error': 'Not found'}),

     

       150
       150
       +
               );

     

       151
       151
       +
       

     

       152
       152
       +
               final result = await service.getVideoUrl(

     

       153
       153
       +
                 'https://streamable.com/$shortcode',

     

       154
       154
       +
               );

     

       155
       155
       +
       

     

       156
       156
       +
               expect(result, null);

     

       157
       157
       +
             });

     

       158
       158
       +
       

     

       159
       159
       +
             test('returns null when files field is missing', () async {

     

       160
       160
       +
               const shortcode = 'nofiles123';

     

       161
       161
       +
       

     

       162
       162
       +
               dioAdapter.onGet(

     

       163
       163
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       164
       164
       +
                 (server) => server.reply(200, {'status': 'ok'}),

     

       165
       165
       +
               );

     

       166
       166
       +
       

     

       167
       167
       +
               final result = await service.getVideoUrl(

     

       168
       168
       +
                 'https://streamable.com/$shortcode',

     

       169
       169
       +
               );

     

       170
       170
       +
       

     

       171
       171
       +
               expect(result, null);

     

       172
       172
       +
             });

     

       173
       173
       +
       

     

       174
       174
       +
             test('returns null when mp4 field is missing', () async {

     

       175
       175
       +
               const shortcode = 'nomp4123';

     

       176
       176
       +
       

     

       177
       177
       +
               dioAdapter.onGet(

     

       178
       178
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       179
       179
       +
                 (server) => server.reply(200, {

     

       180
       180
       +
                   'files': {'webm': {}},

     

       181
       181
       +
                 }),

     

       182
       182
       +
               );

     

       183
       183
       +
       

     

       184
       184
       +
               final result = await service.getVideoUrl(

     

       185
       185
       +
                 'https://streamable.com/$shortcode',

     

       186
       186
       +
               );

     

       187
       187
       +
       

     

       188
       188
       +
               expect(result, null);

     

       189
       189
       +
             });

     

       190
       190
       +
       

     

       191
       191
       +
             test('returns null when URL field is missing', () async {

     

       192
       192
       +
               const shortcode = 'nourl123';

     

       193
       193
       +
       

     

       194
       194
       +
               dioAdapter.onGet(

     

       195
       195
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       196
       196
       +
                 (server) => server.reply(200, {

     

       197
       197
       +
                   'files': {

     

       198
       198
       +
                     'mp4': {'status': 'processing'},

     

       199
       199
       +
                   },

     

       200
       200
       +
                 }),

     

       201
       201
       +
               );

     

       202
       202
       +
       

     

       203
       203
       +
               final result = await service.getVideoUrl(

     

       204
       204
       +
                 'https://streamable.com/$shortcode',

     

       205
       205
       +
               );

     

       206
       206
       +
       

     

       207
       207
       +
               expect(result, null);

     

       208
       208
       +
             });

     

       209
       209
       +
       

     

       210
       210
       +
             test('returns null on network error', () async {

     

       211
       211
       +
               const shortcode = 'error500';

     

       212
       212
       +
       

     

       213
       213
       +
               dioAdapter.onGet(

     

       214
       214
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       215
       215
       +
                 (server) => server.throws(

     

       216
       216
       +
                   500,

     

       217
       217
       +
                   DioException(

     

       218
       218
       +
                     requestOptions: RequestOptions(

     

       219
       219
       +
                       path: 'https://api.streamable.com/videos/$shortcode',

     

       220
       220
       +
                     ),

     

       221
       221
       +
                   ),

     

       222
       222
       +
                 ),

     

       223
       223
       +
               );

     

       224
       224
       +
       

     

       225
       225
       +
               final result = await service.getVideoUrl(

     

       226
       226
       +
                 'https://streamable.com/$shortcode',

     

       227
       227
       +
               );

     

       228
       228
       +
       

     

       229
       229
       +
               expect(result, null);

     

       230
       230
       +
             });

     

       231
       231
       +
       

     

       232
       232
       +
             test('returns null when shortcode extraction fails', () async {

     

       233
       233
       +
               final result = await service.getVideoUrl('invalid-url');

     

       234
       234
       +
               expect(result, null);

     

       235
       235
       +
             });

     

       236
       236
       +
       

     

       237
       237
       +
             test('prepends https to protocol-relative URLs', () async {

     

       238
       238
       +
               const shortcode = 'protocol123';

     

       239
       239
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/protocol123.mp4';

     

       240
       240
       +
       

     

       241
       241
       +
               dioAdapter.onGet(

     

       242
       242
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       243
       243
       +
                 (server) => server.reply(200, {

     

       244
       244
       +
                   'files': {

     

       245
       245
       +
                     'mp4': {'url': videoUrl},

     

       246
       246
       +
                   },

     

       247
       247
       +
                 }),

     

       248
       248
       +
               );

     

       249
       249
       +
       

     

       250
       250
       +
               final result = await service.getVideoUrl(

     

       251
       251
       +
                 'https://streamable.com/$shortcode',

     

       252
       252
       +
               );

     

       253
       253
       +
       

     

       254
       254
       +
               expect(result, startsWith('https://'));

     

       255
       255
       +
               expect(result, 'https:$videoUrl');

     

       256
       256
       +
             });

     

       257
       257
       +
       

     

       258
       258
       +
             test('does not modify URLs that already have protocol', () async {

     

       259
       259
       +
               const shortcode = 'hasprotocol123';

     

       260
       260
       +
               const videoUrl =

     

       261
       261
       +
                   'https://cdn.streamable.com/video/mp4/hasprotocol123.mp4';

     

       262
       262
       +
       

     

       263
       263
       +
               dioAdapter.onGet(

     

       264
       264
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       265
       265
       +
                 (server) => server.reply(200, {

     

       266
       266
       +
                   'files': {

     

       267
       267
       +
                     'mp4': {'url': videoUrl},

     

       268
       268
       +
                   },

     

       269
       269
       +
                 }),

     

       270
       270
       +
               );

     

       271
       271
       +
       

     

       272
       272
       +
               final result = await service.getVideoUrl(

     

       273
       273
       +
                 'https://streamable.com/$shortcode',

     

       274
       274
       +
               );

     

       275
       275
       +
       

     

       276
       276
       +
               expect(result, videoUrl);

     

       277
       277
       +
             });

     

       278
       278
       +
           });

     

       279
       279
       +
         });

     

       280
       280
       +
       }

+368 -180

test/widgets/post_card_test.dart

···

       1
       1
        
       import 'package:coves_flutter/models/post.dart';

     

       2
       2
       +
       import 'package:coves_flutter/services/streamable_service.dart';

     

       2
       3
        
       import 'package:coves_flutter/widgets/post_card.dart';

     

       4
       4
       +
       import 'package:dio/dio.dart';

     

       3
       5
        
       import 'package:flutter/material.dart';

     

       4
       6
        
       import 'package:flutter_test/flutter_test.dart';

     

       7
       7
       +
       import 'package:http_mock_adapter/http_mock_adapter.dart';

     

       5
       8
        
       import 'package:provider/provider.dart';

     

       6
       9
        
       

     

       7
       10
        
       import '../test_helpers/mock_providers.dart';

     
···

       15
       18
        
           mockVoteProvider = MockVoteProvider();

     

       16
       19
        
         });

     

       17
       20
        
       

     

       18
       18
       -
         Widget createTestWidget(FeedViewPost post) {

     

       21
       21
       +
         Widget createTestWidget(

     

       22
       22
       +
           FeedViewPost post, {

     

       23
       23
       +
           StreamableService? streamableService,

     

       24
       24
       +
         }) {

     

       19
       25
        
           return MultiProvider(

     

       20
       26
        
             providers: [

     

       21
       27
        
               // ignore: argument_type_not_assignable

     

       22
       28
        
               ChangeNotifierProvider<MockAuthProvider>.value(value: mockAuthProvider),

     

       23
       29
        
               // ignore: argument_type_not_assignable

     

       24
       30
        
               ChangeNotifierProvider<MockVoteProvider>.value(value: mockVoteProvider),

     

       31
       31
       +
               Provider<StreamableService>.value(

     

       32
       32
       +
                 value: streamableService ?? StreamableService(),

     

       33
       33
       +
               ),

     

       25
       34
        
             ],

     

       26
       35
        
             child: MaterialApp(home: Scaffold(body: PostCard(post: post))),

     

       27
       36
        
           );

     

       28
       37
        
         }

     

       29
       38
        
       

     

       30
       30
       -
         group('PostCard', skip: 'Provider type compatibility issues - needs mock refactoring', () {

     

       31
       31
       -
           testWidgets('renders all basic components', (tester) async {

     

       32
       32
       -
             final post = FeedViewPost(

     

       33
       33
       -
               post: PostView(

     

       34
       34
       -
                 uri: 'at://did:example/post/123',

     

       35
       35
       -
                 cid: 'cid123',

     

       36
       36
       -
                 rkey: '123',

     

       37
       37
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       38
       38
       -
                 community: CommunityRef(

     

       39
       39
       -
                   did: 'did:plc:community',

     

       40
       40
       -
                   name: 'test-community',

     

       41
       41
       -
                 ),

     

       42
       42
       -
                 createdAt: DateTime(2024, 1, 1),

     

       43
       43
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       44
       44
       -
                 text: 'Test post content',

     

       45
       45
       -
                 title: 'Test Post Title',

     

       46
       46
       -
                 stats: PostStats(

     

       47
       47
       -
                   upvotes: 10,

     

       48
       48
       -
                   downvotes: 2,

     

       49
       49
       -
                   score: 8,

     

       50
       50
       -
                   commentCount: 5,

     

       39
       39
       +
         group(

     

       40
       40
       +
           'PostCard',

     

       41
       41
       +
           skip: 'Provider type compatibility issues - needs mock refactoring',

     

       42
       42
       +
           () {

     

       43
       43
       +
             testWidgets('renders all basic components', (tester) async {

     

       44
       44
       +
               final post = FeedViewPost(

     

       45
       45
       +
                 post: PostView(

     

       46
       46
       +
                   uri: 'at://did:example/post/123',

     

       47
       47
       +
                   cid: 'cid123',

     

       48
       48
       +
                   rkey: '123',

     

       49
       49
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       50
       50
       +
                   community: CommunityRef(

     

       51
       51
       +
                     did: 'did:plc:community',

     

       52
       52
       +
                     name: 'test-community',

     

       53
       53
       +
                   ),

     

       54
       54
       +
                   createdAt: DateTime(2024, 1, 1),

     

       55
       55
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       56
       56
       +
                   text: 'Test post content',

     

       57
       57
       +
                   title: 'Test Post Title',

     

       58
       58
       +
                   stats: PostStats(

     

       59
       59
       +
                     upvotes: 10,

     

       60
       60
       +
                     downvotes: 2,

     

       61
       61
       +
                     score: 8,

     

       62
       62
       +
                     commentCount: 5,

     

       63
       63
       +
                   ),

     

       51
       64
        
                 ),

     

       52
       52
       -
               ),

     

       53
       53
       -
             );

     

       65
       65
       +
               );

     

       54
       66
        
       

     

       55
       55
       -
             await tester.pumpWidget(createTestWidget(post));

     

       67
       67
       +
               await tester.pumpWidget(createTestWidget(post));

     

       56
       68
        
       

     

       57
       57
       -
             // Verify title is displayed

     

       58
       58
       -
             expect(find.text('Test Post Title'), findsOneWidget);

     

       69
       69
       +
               // Verify title is displayed

     

       70
       70
       +
               expect(find.text('Test Post Title'), findsOneWidget);

     

       59
       71
        
       

     

       60
       60
       -
             // Verify community name is displayed

     

       61
       61
       -
             expect(find.text('c/test-community'), findsOneWidget);

     

       72
       72
       +
               // Verify community name is displayed

     

       73
       73
       +
               expect(find.text('c/test-community'), findsOneWidget);

     

       62
       74
        
       

     

       63
       63
       -
             // Verify author handle is displayed

     

       64
       64
       -
             expect(find.text('@author.test'), findsOneWidget);

     

       75
       75
       +
               // Verify author handle is displayed

     

       76
       76
       +
               expect(find.text('@author.test'), findsOneWidget);

     

       65
       77
        
       

     

       66
       66
       -
             // Verify text content is displayed

     

       67
       67
       -
             expect(find.text('Test post content'), findsOneWidget);

     

       78
       78
       +
               // Verify text content is displayed

     

       79
       79
       +
               expect(find.text('Test post content'), findsOneWidget);

     

       68
       80
        
       

     

       69
       69
       -
             // Verify stats are displayed

     

       70
       70
       -
             expect(find.text('8'), findsOneWidget); // score

     

       71
       71
       -
             expect(find.text('5'), findsOneWidget); // comment count

     

       72
       72
       -
           });

     

       81
       81
       +
               // Verify stats are displayed

     

       82
       82
       +
               expect(find.text('8'), findsOneWidget); // score

     

       83
       83
       +
               expect(find.text('5'), findsOneWidget); // comment count

     

       84
       84
       +
             });

     

       73
       85
        
       

     

       74
       74
       -
           testWidgets('displays community avatar when available', (tester) async {

     

       75
       75
       -
             final post = FeedViewPost(

     

       76
       76
       -
               post: PostView(

     

       77
       77
       -
                 uri: 'at://did:example/post/123',

     

       78
       78
       -
                 cid: 'cid123',

     

       79
       79
       -
                 rkey: '123',

     

       80
       80
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       81
       81
       -
                 community: CommunityRef(

     

       82
       82
       -
                   did: 'did:plc:community',

     

       83
       83
       -
                   name: 'test-community',

     

       84
       84
       -
                   avatar: 'https://example.com/avatar.jpg',

     

       86
       86
       +
             testWidgets('displays community avatar when available', (tester) async {

     

       87
       87
       +
               final post = FeedViewPost(

     

       88
       88
       +
                 post: PostView(

     

       89
       89
       +
                   uri: 'at://did:example/post/123',

     

       90
       90
       +
                   cid: 'cid123',

     

       91
       91
       +
                   rkey: '123',

     

       92
       92
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       93
       93
       +
                   community: CommunityRef(

     

       94
       94
       +
                     did: 'did:plc:community',

     

       95
       95
       +
                     name: 'test-community',

     

       96
       96
       +
                     avatar: 'https://example.com/avatar.jpg',

     

       97
       97
       +
                   ),

     

       98
       98
       +
                   createdAt: DateTime(2024, 1, 1),

     

       99
       99
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       100
       100
       +
                   text: '',

     

       101
       101
       +
                   stats: PostStats(

     

       102
       102
       +
                     upvotes: 0,

     

       103
       103
       +
                     downvotes: 0,

     

       104
       104
       +
                     score: 0,

     

       105
       105
       +
                     commentCount: 0,

     

       106
       106
       +
                   ),

     

       85
       107
        
                 ),

     

       86
       86
       -
                 createdAt: DateTime(2024, 1, 1),

     

       87
       87
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       88
       88
       -
                 text: '',

     

       89
       89
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       90
       90
       -
               ),

     

       91
       91
       -
             );

     

       108
       108
       +
               );

     

       92
       109
        
       

     

       93
       93
       -
             await tester.pumpWidget(createTestWidget(post));

     

       94
       94
       -
             await tester.pumpAndSettle();

     

       110
       110
       +
               await tester.pumpWidget(createTestWidget(post));

     

       111
       111
       +
               await tester.pumpAndSettle();

     

       95
       112
        
       

     

       96
       96
       -
             // Avatar image should be present

     

       97
       97
       -
             expect(find.byType(Image), findsWidgets);

     

       98
       98
       -
           });

     

       113
       113
       +
               // Avatar image should be present

     

       114
       114
       +
               expect(find.byType(Image), findsWidgets);

     

       115
       115
       +
             });

     

       99
       116
        
       

     

       100
       100
       -
           testWidgets('shows fallback avatar when no avatar URL', (tester) async {

     

       101
       101
       -
             final post = FeedViewPost(

     

       102
       102
       -
               post: PostView(

     

       103
       103
       -
                 uri: 'at://did:example/post/123',

     

       104
       104
       -
                 cid: 'cid123',

     

       105
       105
       -
                 rkey: '123',

     

       106
       106
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       107
       107
       -
                 community: CommunityRef(

     

       108
       108
       -
                   did: 'did:plc:community',

     

       109
       109
       -
                   name: 'TestCommunity',

     

       117
       117
       +
             testWidgets('shows fallback avatar when no avatar URL', (tester) async {

     

       118
       118
       +
               final post = FeedViewPost(

     

       119
       119
       +
                 post: PostView(

     

       120
       120
       +
                   uri: 'at://did:example/post/123',

     

       121
       121
       +
                   cid: 'cid123',

     

       122
       122
       +
                   rkey: '123',

     

       123
       123
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       124
       124
       +
                   community: CommunityRef(

     

       125
       125
       +
                     did: 'did:plc:community',

     

       126
       126
       +
                     name: 'TestCommunity',

     

       127
       127
       +
                   ),

     

       128
       128
       +
                   createdAt: DateTime(2024, 1, 1),

     

       129
       129
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       130
       130
       +
                   text: '',

     

       131
       131
       +
                   stats: PostStats(

     

       132
       132
       +
                     upvotes: 0,

     

       133
       133
       +
                     downvotes: 0,

     

       134
       134
       +
                     score: 0,

     

       135
       135
       +
                     commentCount: 0,

     

       136
       136
       +
                   ),

     

       110
       137
        
                 ),

     

       111
       111
       -
                 createdAt: DateTime(2024, 1, 1),

     

       112
       112
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       113
       113
       -
                 text: '',

     

       114
       114
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       115
       115
       -
               ),

     

       116
       116
       -
             );

     

       138
       138
       +
               );

     

       117
       139
        
       

     

       118
       118
       -
             await tester.pumpWidget(createTestWidget(post));

     

       140
       140
       +
               await tester.pumpWidget(createTestWidget(post));

     

       119
       141
        
       

     

       120
       120
       -
             // Verify fallback shows first letter

     

       121
       121
       -
             expect(find.text('T'), findsOneWidget);

     

       122
       122
       -
           });

     

       142
       142
       +
               // Verify fallback shows first letter

     

       143
       143
       +
               expect(find.text('T'), findsOneWidget);

     

       144
       144
       +
             });

     

       123
       145
        
       

     

       124
       124
       -
           testWidgets('displays external link bar when embed present', (

     

       125
       125
       -
             tester,

     

       126
       126
       -
           ) async {

     

       127
       127
       -
             final post = FeedViewPost(

     

       128
       128
       -
               post: PostView(

     

       129
       129
       -
                 uri: 'at://did:example/post/123',

     

       130
       130
       -
                 cid: 'cid123',

     

       131
       131
       -
                 rkey: '123',

     

       132
       132
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       133
       133
       -
                 community: CommunityRef(

     

       134
       134
       -
                   did: 'did:plc:community',

     

       135
       135
       -
                   name: 'test-community',

     

       136
       136
       -
                 ),

     

       137
       137
       -
                 createdAt: DateTime(2024, 1, 1),

     

       138
       138
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       139
       139
       -
                 text: '',

     

       140
       140
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       141
       141
       -
                 embed: PostEmbed(

     

       142
       142
       -
                   type: 'social.coves.embed.external',

     

       143
       143
       -
                   external: ExternalEmbed(

     

       144
       144
       -
                     uri: 'https://example.com/article',

     

       145
       145
       -
                     domain: 'example.com',

     

       146
       146
       -
                     title: 'Example Article',

     

       146
       146
       +
             testWidgets('displays external link bar when embed present', (

     

       147
       147
       +
               tester,

     

       148
       148
       +
             ) async {

     

       149
       149
       +
               final post = FeedViewPost(

     

       150
       150
       +
                 post: PostView(

     

       151
       151
       +
                   uri: 'at://did:example/post/123',

     

       152
       152
       +
                   cid: 'cid123',

     

       153
       153
       +
                   rkey: '123',

     

       154
       154
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       155
       155
       +
                   community: CommunityRef(

     

       156
       156
       +
                     did: 'did:plc:community',

     

       157
       157
       +
                     name: 'test-community',

     

       158
       158
       +
                   ),

     

       159
       159
       +
                   createdAt: DateTime(2024, 1, 1),

     

       160
       160
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       161
       161
       +
                   text: '',

     

       162
       162
       +
                   stats: PostStats(

     

       163
       163
       +
                     upvotes: 0,

     

       164
       164
       +
                     downvotes: 0,

     

       165
       165
       +
                     score: 0,

     

       166
       166
       +
                     commentCount: 0,

     

       167
       167
       +
                   ),

     

       168
       168
       +
                   embed: PostEmbed(

     

       169
       169
       +
                     type: 'social.coves.embed.external',

     

       170
       170
       +
                     external: ExternalEmbed(

     

       171
       171
       +
                       uri: 'https://example.com/article',

     

       172
       172
       +
                       domain: 'example.com',

     

       173
       173
       +
                       title: 'Example Article',

     

       174
       174
       +
                     ),

     

       175
       175
       +
                     data: const {},

     

       147
       176
        
                   ),

     

       148
       148
       -
                   data: const {},

     

       149
       177
        
                 ),

     

       150
       150
       -
               ),

     

       151
       151
       -
             );

     

       178
       178
       +
               );

     

       152
       179
        
       

     

       153
       153
       -
             await tester.pumpWidget(createTestWidget(post));

     

       180
       180
       +
               await tester.pumpWidget(createTestWidget(post));

     

       154
       181
        
       

     

       155
       155
       -
             // Verify external link bar is present

     

       156
       156
       -
             expect(find.text('example.com'), findsOneWidget);

     

       157
       157
       -
             expect(find.byIcon(Icons.open_in_new), findsOneWidget);

     

       158
       158
       -
           });

     

       182
       182
       +
               // Verify external link bar is present

     

       183
       183
       +
               expect(find.text('example.com'), findsOneWidget);

     

       184
       184
       +
               expect(find.byIcon(Icons.open_in_new), findsOneWidget);

     

       185
       185
       +
             });

     

       159
       186
        
       

     

       160
       160
       -
           testWidgets('displays embed image when available', (tester) async {

     

       161
       161
       -
             final post = FeedViewPost(

     

       162
       162
       -
               post: PostView(

     

       163
       163
       -
                 uri: 'at://did:example/post/123',

     

       164
       164
       -
                 cid: 'cid123',

     

       165
       165
       -
                 rkey: '123',

     

       166
       166
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       167
       167
       -
                 community: CommunityRef(

     

       168
       168
       -
                   did: 'did:plc:community',

     

       169
       169
       -
                   name: 'test-community',

     

       187
       187
       +
             testWidgets('displays embed image when available', (tester) async {

     

       188
       188
       +
               final post = FeedViewPost(

     

       189
       189
       +
                 post: PostView(

     

       190
       190
       +
                   uri: 'at://did:example/post/123',

     

       191
       191
       +
                   cid: 'cid123',

     

       192
       192
       +
                   rkey: '123',

     

       193
       193
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       194
       194
       +
                   community: CommunityRef(

     

       195
       195
       +
                     did: 'did:plc:community',

     

       196
       196
       +
                     name: 'test-community',

     

       197
       197
       +
                   ),

     

       198
       198
       +
                   createdAt: DateTime(2024, 1, 1),

     

       199
       199
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       200
       200
       +
                   text: '',

     

       201
       201
       +
                   stats: PostStats(

     

       202
       202
       +
                     upvotes: 0,

     

       203
       203
       +
                     downvotes: 0,

     

       204
       204
       +
                     score: 0,

     

       205
       205
       +
                     commentCount: 0,

     

       206
       206
       +
                   ),

     

       207
       207
       +
                   embed: PostEmbed(

     

       208
       208
       +
                     type: 'social.coves.embed.external',

     

       209
       209
       +
                     external: ExternalEmbed(

     

       210
       210
       +
                       uri: 'https://example.com/article',

     

       211
       211
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       212
       212
       +
                     ),

     

       213
       213
       +
                     data: const {},

     

       214
       214
       +
                   ),

     

       170
       215
        
                 ),

     

       171
       171
       -
                 createdAt: DateTime(2024, 1, 1),

     

       172
       172
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       173
       173
       -
                 text: '',

     

       174
       174
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       175
       175
       -
                 embed: PostEmbed(

     

       176
       176
       -
                   type: 'social.coves.embed.external',

     

       177
       177
       -
                   external: ExternalEmbed(

     

       178
       178
       -
                     uri: 'https://example.com/article',

     

       179
       179
       -
                     thumb: 'https://example.com/thumb.jpg',

     

       216
       216
       +
               );

     

       217
       217
       +
       

     

       218
       218
       +
               await tester.pumpWidget(createTestWidget(post));

     

       219
       219
       +
               await tester.pump();

     

       220
       220
       +
       

     

       221
       221
       +
               // Embed image should be loading/present

     

       222
       222
       +
               expect(find.byType(Image), findsWidgets);

     

       223
       223
       +
             });

     

       224
       224
       +
       

     

       225
       225
       +
             testWidgets('renders without title', (tester) async {

     

       226
       226
       +
               final post = FeedViewPost(

     

       227
       227
       +
                 post: PostView(

     

       228
       228
       +
                   uri: 'at://did:example/post/123',

     

       229
       229
       +
                   cid: 'cid123',

     

       230
       230
       +
                   rkey: '123',

     

       231
       231
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       232
       232
       +
                   community: CommunityRef(

     

       233
       233
       +
                     did: 'did:plc:community',

     

       234
       234
       +
                     name: 'test-community',

     

       235
       235
       +
                   ),

     

       236
       236
       +
                   createdAt: DateTime(2024, 1, 1),

     

       237
       237
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       238
       238
       +
                   text: 'Just body text',

     

       239
       239
       +
                   stats: PostStats(

     

       240
       240
       +
                     upvotes: 0,

     

       241
       241
       +
                     downvotes: 0,

     

       242
       242
       +
                     score: 0,

     

       243
       243
       +
                     commentCount: 0,

     

       180
       244
        
                   ),

     

       181
       181
       -
                   data: const {},

     

       182
       245
        
                 ),

     

       183
       183
       -
               ),

     

       184
       184
       -
             );

     

       246
       246
       +
               );

     

       185
       247
        
       

     

       186
       186
       -
             await tester.pumpWidget(createTestWidget(post));

     

       187
       187
       -
             await tester.pump();

     

       248
       248
       +
               await tester.pumpWidget(createTestWidget(post));

     

       188
       249
        
       

     

       189
       189
       -
             // Embed image should be loading/present

     

       190
       190
       -
             expect(find.byType(Image), findsWidgets);

     

       191
       191
       -
           });

     

       250
       250
       +
               // Should render without errors

     

       251
       251
       +
               expect(find.text('Just body text'), findsOneWidget);

     

       252
       252
       +
               expect(find.text('c/test-community'), findsOneWidget);

     

       253
       253
       +
             });

     

       192
       254
        
       

     

       193
       193
       -
           testWidgets('renders without title', (tester) async {

     

       194
       194
       -
             final post = FeedViewPost(

     

       195
       195
       -
               post: PostView(

     

       196
       196
       -
                 uri: 'at://did:example/post/123',

     

       197
       197
       -
                 cid: 'cid123',

     

       198
       198
       -
                 rkey: '123',

     

       199
       199
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       200
       200
       -
                 community: CommunityRef(

     

       201
       201
       -
                   did: 'did:plc:community',

     

       202
       202
       -
                   name: 'test-community',

     

       255
       255
       +
             testWidgets('has action buttons', (tester) async {

     

       256
       256
       +
               final post = FeedViewPost(

     

       257
       257
       +
                 post: PostView(

     

       258
       258
       +
                   uri: 'at://did:example/post/123',

     

       259
       259
       +
                   cid: 'cid123',

     

       260
       260
       +
                   rkey: '123',

     

       261
       261
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       262
       262
       +
                   community: CommunityRef(

     

       263
       263
       +
                     did: 'did:plc:community',

     

       264
       264
       +
                     name: 'test-community',

     

       265
       265
       +
                   ),

     

       266
       266
       +
                   createdAt: DateTime(2024, 1, 1),

     

       267
       267
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       268
       268
       +
                   text: '',

     

       269
       269
       +
                   stats: PostStats(

     

       270
       270
       +
                     upvotes: 0,

     

       271
       271
       +
                     downvotes: 0,

     

       272
       272
       +
                     score: 0,

     

       273
       273
       +
                     commentCount: 0,

     

       274
       274
       +
                   ),

     

       203
       275
        
                 ),

     

       204
       204
       -
                 createdAt: DateTime(2024, 1, 1),

     

       205
       205
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       206
       206
       -
                 text: 'Just body text',

     

       207
       207
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       208
       208
       -
               ),

     

       209
       209
       -
             );

     

       276
       276
       +
               );

     

       210
       277
        
       

     

       211
       211
       -
             await tester.pumpWidget(createTestWidget(post));

     

       278
       278
       +
               await tester.pumpWidget(createTestWidget(post));

     

       212
       279
        
       

     

       213
       213
       -
             // Should render without errors

     

       214
       214
       -
             expect(find.text('Just body text'), findsOneWidget);

     

       215
       215
       -
             expect(find.text('c/test-community'), findsOneWidget);

     

       216
       216
       -
           });

     

       280
       280
       +
               // Verify action buttons are present

     

       281
       281
       +
               expect(find.byIcon(Icons.more_horiz), findsOneWidget); // menu

     

       282
       282
       +
               // Share, comment, and heart icons are custom widgets, verify by count

     

       283
       283
       +
               expect(find.byType(InkWell), findsWidgets);

     

       284
       284
       +
             });

     

       217
       285
        
       

     

       218
       218
       -
           testWidgets('has action buttons', (tester) async {

     

       219
       219
       -
             final post = FeedViewPost(

     

       220
       220
       -
               post: PostView(

     

       221
       221
       -
                 uri: 'at://did:example/post/123',

     

       222
       222
       -
                 cid: 'cid123',

     

       223
       223
       -
                 rkey: '123',

     

       224
       224
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       225
       225
       -
                 community: CommunityRef(

     

       226
       226
       -
                   did: 'did:plc:community',

     

       227
       227
       -
                   name: 'test-community',

     

       286
       286
       +
             testWidgets('displays play button overlay for Streamable videos', (

     

       287
       287
       +
               tester,

     

       288
       288
       +
             ) async {

     

       289
       289
       +
               final post = FeedViewPost(

     

       290
       290
       +
                 post: PostView(

     

       291
       291
       +
                   uri: 'at://did:example/post/123',

     

       292
       292
       +
                   cid: 'cid123',

     

       293
       293
       +
                   rkey: '123',

     

       294
       294
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       295
       295
       +
                   community: CommunityRef(

     

       296
       296
       +
                     did: 'did:plc:community',

     

       297
       297
       +
                     name: 'test-community',

     

       298
       298
       +
                   ),

     

       299
       299
       +
                   createdAt: DateTime(2024, 1, 1),

     

       300
       300
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       301
       301
       +
                   text: '',

     

       302
       302
       +
                   stats: PostStats(

     

       303
       303
       +
                     upvotes: 0,

     

       304
       304
       +
                     downvotes: 0,

     

       305
       305
       +
                     score: 0,

     

       306
       306
       +
                     commentCount: 0,

     

       307
       307
       +
                   ),

     

       308
       308
       +
                   embed: PostEmbed(

     

       309
       309
       +
                     type: 'social.coves.embed.external',

     

       310
       310
       +
                     external: ExternalEmbed(

     

       311
       311
       +
                       uri: 'https://streamable.com/abc123',

     

       312
       312
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       313
       313
       +
                       embedType: 'video',

     

       314
       314
       +
                       provider: 'streamable',

     

       315
       315
       +
                     ),

     

       316
       316
       +
                     data: const {},

     

       317
       317
       +
                   ),

     

       228
       318
        
                 ),

     

       229
       229
       -
                 createdAt: DateTime(2024, 1, 1),

     

       230
       230
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       231
       231
       -
                 text: '',

     

       232
       232
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       233
       233
       -
               ),

     

       319
       319
       +
               );

     

       320
       320
       +
       

     

       321
       321
       +
               await tester.pumpWidget(createTestWidget(post));

     

       322
       322
       +
               await tester.pump();

     

       323
       323
       +
       

     

       324
       324
       +
               // Verify play button is displayed

     

       325
       325
       +
               expect(find.byIcon(Icons.play_arrow), findsOneWidget);

     

       326
       326
       +
             });

     

       327
       327
       +
       

     

       328
       328
       +
             testWidgets(

     

       329
       329
       +
               'shows loading indicator when fetching video URL for Streamable',

     

       330
       330
       +
               (tester) async {

     

       331
       331
       +
                 final dio = Dio(BaseOptions(baseUrl: 'https://api.streamable.com'));

     

       332
       332
       +
                 final dioAdapter = DioAdapter(dio: dio);

     

       333
       333
       +
                 final streamableService = StreamableService(dio: dio);

     

       334
       334
       +
       

     

       335
       335
       +
                 // Delay the response to test loading state

     

       336
       336
       +
                 dioAdapter.onGet(

     

       337
       337
       +
                   '/videos/abc123',

     

       338
       338
       +
                   (server) => server.reply(200, {

     

       339
       339
       +
                     'files': {

     

       340
       340
       +
                       'mp4': {'url': '//cdn.streamable.com/video.mp4'},

     

       341
       341
       +
                     },

     

       342
       342
       +
                   }, delay: const Duration(milliseconds: 500)),

     

       343
       343
       +
                 );

     

       344
       344
       +
       

     

       345
       345
       +
                 final post = FeedViewPost(

     

       346
       346
       +
                   post: PostView(

     

       347
       347
       +
                     uri: 'at://did:example/post/123',

     

       348
       348
       +
                     cid: 'cid123',

     

       349
       349
       +
                     rkey: '123',

     

       350
       350
       +
                     author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       351
       351
       +
                     community: CommunityRef(

     

       352
       352
       +
                       did: 'did:plc:community',

     

       353
       353
       +
                       name: 'test-community',

     

       354
       354
       +
                     ),

     

       355
       355
       +
                     createdAt: DateTime(2024, 1, 1),

     

       356
       356
       +
                     indexedAt: DateTime(2024, 1, 1),

     

       357
       357
       +
                     text: '',

     

       358
       358
       +
                     stats: PostStats(

     

       359
       359
       +
                       upvotes: 0,

     

       360
       360
       +
                       downvotes: 0,

     

       361
       361
       +
                       score: 0,

     

       362
       362
       +
                       commentCount: 0,

     

       363
       363
       +
                     ),

     

       364
       364
       +
                     embed: PostEmbed(

     

       365
       365
       +
                       type: 'social.coves.embed.external',

     

       366
       366
       +
                       external: ExternalEmbed(

     

       367
       367
       +
                         uri: 'https://streamable.com/abc123',

     

       368
       368
       +
                         thumb: 'https://example.com/thumb.jpg',

     

       369
       369
       +
                         embedType: 'video',

     

       370
       370
       +
                         provider: 'streamable',

     

       371
       371
       +
                       ),

     

       372
       372
       +
                       data: const {},

     

       373
       373
       +
                     ),

     

       374
       374
       +
                   ),

     

       375
       375
       +
                 );

     

       376
       376
       +
       

     

       377
       377
       +
                 await tester.pumpWidget(

     

       378
       378
       +
                   createTestWidget(post, streamableService: streamableService),

     

       379
       379
       +
                 );

     

       380
       380
       +
                 await tester.pump();

     

       381
       381
       +
       

     

       382
       382
       +
                 // Tap the play button

     

       383
       383
       +
                 await tester.tap(find.byIcon(Icons.play_arrow));

     

       384
       384
       +
                 await tester.pump();

     

       385
       385
       +
       

     

       386
       386
       +
                 // Verify loading indicator is displayed

     

       387
       387
       +
                 expect(find.byType(CircularProgressIndicator), findsOneWidget);

     

       388
       388
       +
               },

     

       234
       389
        
             );

     

       235
       390
        
       

     

       236
       236
       -
             await tester.pumpWidget(createTestWidget(post));

     

       391
       391
       +
             testWidgets('does not show play button for non-video embeds', (

     

       392
       392
       +
               tester,

     

       393
       393
       +
             ) async {

     

       394
       394
       +
               final post = FeedViewPost(

     

       395
       395
       +
                 post: PostView(

     

       396
       396
       +
                   uri: 'at://did:example/post/123',

     

       397
       397
       +
                   cid: 'cid123',

     

       398
       398
       +
                   rkey: '123',

     

       399
       399
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       400
       400
       +
                   community: CommunityRef(

     

       401
       401
       +
                     did: 'did:plc:community',

     

       402
       402
       +
                     name: 'test-community',

     

       403
       403
       +
                   ),

     

       404
       404
       +
                   createdAt: DateTime(2024, 1, 1),

     

       405
       405
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       406
       406
       +
                   text: '',

     

       407
       407
       +
                   stats: PostStats(

     

       408
       408
       +
                     upvotes: 0,

     

       409
       409
       +
                     downvotes: 0,

     

       410
       410
       +
                     score: 0,

     

       411
       411
       +
                     commentCount: 0,

     

       412
       412
       +
                   ),

     

       413
       413
       +
                   embed: PostEmbed(

     

       414
       414
       +
                     type: 'social.coves.embed.external',

     

       415
       415
       +
                     external: ExternalEmbed(

     

       416
       416
       +
                       uri: 'https://example.com/article',

     

       417
       417
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       418
       418
       +
                     ),

     

       419
       419
       +
                     data: const {},

     

       420
       420
       +
                   ),

     

       421
       421
       +
                 ),

     

       422
       422
       +
               );

     

       237
       423
        
       

     

       238
       238
       -
             // Verify action buttons are present

     

       239
       239
       -
             expect(find.byIcon(Icons.more_horiz), findsOneWidget); // menu

     

       240
       240
       -
             // Share, comment, and heart icons are custom widgets, verify by count

     

       241
       241
       -
             expect(find.byType(InkWell), findsWidgets);

     

       242
       242
       -
           });

     

       243
       243
       -
         });

     

       424
       424
       +
               await tester.pumpWidget(createTestWidget(post));

     

       425
       425
       +
               await tester.pump();

     

       426
       426
       +
       

     

       427
       427
       +
               // Verify play button is NOT displayed

     

       428
       428
       +
               expect(find.byIcon(Icons.play_arrow), findsNothing);

     

       429
       429
       +
             });

     

       430
       430
       +
           },

     

       431
       431
       +
         );

     

       244
       432
        
       }