commit a4dda188183f8f6f41d0cb1b4c2ba46d7544fbcc · bretton.dev/coves-mobile

+2 -2

android/app/src/main/res/xml/network_security_config.xml

···

       14
       14
        
               This is ONLY acceptable for local development against localhost.

     

       15
       15
        
           -->

     

       16
       16
        
           <domain-config cleartextTrafficPermitted="true">

     

       17
       17
       -
               <!-- Local IP addresses for development -->

     

       17
       17
       +
               <!-- Local development addresses only -->

     

       18
       18
        
               <domain includeSubdomains="true">192.168.1.7</domain>

     

       19
       19
        
               <domain includeSubdomains="true">localhost</domain>

     

       20
       20
        
               <domain includeSubdomains="true">127.0.0.1</domain>

     

       21
       21
       -
               <domain includeSubdomains="true">10.0.2.2</domain>

     

       21
       21
       +
               <domain includeSubdomains="true">10.0.2.2</domain> <!-- Android emulator -->

     

       22
       22
        
           </domain-config>

     

       23
       23
        
       </network-security-config>

+14 -10

lib/providers/auth_provider.dart

···

       21
       21
        
         AuthProvider({OAuthService? oauthService})

     

       22
       22
        
             : _oauthService = oauthService ?? OAuthService();

     

       23
       23
        
       

     

       24
       24
       -
         // SharedPreferences key for storing the current user's DID

     

       25
       25
       -
         // The DID is public information (like a username), so SharedPreferences is fine

     

       24
       24
       +
         // SharedPreferences keys for storing session info

     

       25
       25
       +
         // The DID and handle are public information, so SharedPreferences is fine

     

       26
       26
        
         // The actual tokens are stored securely by the atproto_oauth_flutter package

     

       27
       27
        
         static const String _prefKeyDid = 'current_user_did';

     

       28
       28
       +
         static const String _prefKeyHandle = 'current_user_handle';

     

       28
       29
        
       

     

       29
       30
        
         // Session state

     

       30
       31
        
         OAuthSession? _session;

     
···

       87
       88
        
             // Check if we have a stored DID from a previous session

     

       88
       89
        
             final prefs = await SharedPreferences.getInstance();

     

       89
       90
        
             final storedDid = prefs.getString(_prefKeyDid);

     

       91
       91
       +
             final storedHandle = prefs.getString(_prefKeyHandle);

     

       90
       92
        
       

     

       91
       93
        
             if (storedDid != null) {

     

       92
       94
        
               if (kDebugMode) {

     

       93
       95
        
                 print('Found stored DID: $storedDid');

     

       96
       96
       +
                 print('Found stored handle: $storedHandle');

     

       94
       97
        
               }

     

       95
       98
        
       

     

       96
       99
        
               // Try to restore the session

     
···

       101
       104
        
                 _session = restoredSession;

     

       102
       105
        
                 _isAuthenticated = true;

     

       103
       106
        
                 _did = restoredSession.sub;

     

       104
       104
       -
       

     

       105
       105
       -
                 // Extract handle from session metadata if available

     

       106
       106
       -
                 // The handle might be in the session metadata or we can store it separately

     

       107
       107
       -
                 _handle = storedDid; // TODO: Store handle separately if needed

     

       107
       107
       +
                 _handle = storedHandle; // Restore handle from preferences

     

       108
       108
        
       

     

       109
       109
        
                 if (kDebugMode) {

     

       110
       110
        
                   print('✅ Successfully restored session');

     

       111
       111
        
                   print('   DID: ${restoredSession.sub}');

     

       112
       112
       +
                   print('   Handle: $storedHandle');

     

       112
       113
        
                 }

     

       113
       114
        
               } else {

     

       114
       114
       -
                 // Failed to restore - clear the stored DID

     

       115
       115
       +
                 // Failed to restore - clear the stored data

     

       115
       116
        
                 await prefs.remove(_prefKeyDid);

     

       117
       117
       +
                 await prefs.remove(_prefKeyHandle);

     

       116
       118
        
                 if (kDebugMode) {

     

       117
       117
       -
                   print('⚠️ Could not restore session - cleared stored DID');

     

       119
       119
       +
                   print('⚠️ Could not restore session - cleared stored data');

     

       118
       120
        
                 }

     

       119
       121
        
               }

     

       120
       122
        
             } else {

     
···

       166
       168
        
             _did = session.sub;

     

       167
       169
        
             _handle = trimmedHandle;

     

       168
       170
        
       

     

       169
       169
       -
             // Store the DID in SharedPreferences so we can restore on next launch

     

       171
       171
       +
             // Store the DID and handle in SharedPreferences so we can restore on next launch

     

       170
       172
        
             final prefs = await SharedPreferences.getInstance();

     

       171
       173
        
             await prefs.setString(_prefKeyDid, session.sub);

     

       174
       174
       +
             await prefs.setString(_prefKeyHandle, trimmedHandle);

     

       172
       175
        
       

     

       173
       176
        
             if (kDebugMode) {

     

       174
       177
        
               print('✅ Successfully signed in');

     
···

       214
       217
        
               await _oauthService.signOut(currentDid);

     

       215
       218
        
             }

     

       216
       219
        
       

     

       217
       217
       -
             // Clear the stored DID from SharedPreferences

     

       220
       220
       +
             // Clear the stored DID and handle from SharedPreferences

     

       218
       221
        
             final prefs = await SharedPreferences.getInstance();

     

       219
       222
        
             await prefs.remove(_prefKeyDid);

     

       223
       223
       +
             await prefs.remove(_prefKeyHandle);

     

       220
       224
        
       

     

       221
       225
        
             // Clear state

     

       222
       226
        
             _session = null;

+24

lib/providers/feed_provider.dart

···

       17
       17
        
           // Pass token getter to API service for automatic fresh token retrieval

     

       18
       18
        
           _apiService = apiService ??

     

       19
       19
        
               CovesApiService(tokenGetter: _authProvider.getAccessToken);

     

       20
       20
       +
       

     

       21
       21
       +
           // [P0 FIX] Listen to auth state changes and clear feed on sign-out

     

       22
       22
       +
           // This prevents privacy bug where logged-out users see their private timeline

     

       23
       23
       +
           // until they manually refresh.

     

       24
       24
       +
           _authProvider.addListener(_onAuthChanged);

     

       25
       25
       +
         }

     

       26
       26
       +
       

     

       27
       27
       +
         /// Handle authentication state changes

     

       28
       28
       +
         ///

     

       29
       29
       +
         /// When the user signs out (isAuthenticated becomes false), immediately

     

       30
       30
       +
         /// clear the feed to prevent showing personalized content to logged-out users.

     

       31
       31
       +
         /// This fixes a privacy bug where token refresh failures would sign out the user

     

       32
       32
       +
         /// but leave their private timeline visible until manual refresh.

     

       33
       33
       +
         void _onAuthChanged() {

     

       34
       34
       +
           if (!_authProvider.isAuthenticated && _posts.isNotEmpty) {

     

       35
       35
       +
             if (kDebugMode) {

     

       36
       36
       +
               debugPrint('🔒 Auth state changed to unauthenticated - clearing feed');

     

       37
       37
       +
             }

     

       38
       38
       +
             reset();

     

       39
       39
       +
             // Automatically load the public discover feed

     

       40
       40
       +
             loadFeed(refresh: true);

     

       41
       41
       +
           }

     

       20
       42
        
         }

     

       21
       43
        
         final AuthProvider _authProvider;

     

       22
       44
        
         late final CovesApiService _apiService;

     
···

       169
       191
        
       

     

       170
       192
        
         @override

     

       171
       193
        
         void dispose() {

     

       194
       194
       +
           // Remove auth listener to prevent memory leaks

     

       195
       195
       +
           _authProvider.removeListener(_onAuthChanged);

     

       172
       196
        
           _apiService.dispose();

     

       173
       197
        
           super.dispose();

     

       174
       198
        
         }

+65 -13

lib/screens/home/feed_screen.dart

···

       58
       58
        
       

     

       59
       59
        
         @override

     

       60
       60
        
         Widget build(BuildContext context) {

     

       61
       61
       -
           // Use select to only rebuild when specific fields change

     

       61
       61
       +
           // Optimized: Use select to only rebuild when specific fields change

     

       62
       62
       +
           // This prevents unnecessary rebuilds when unrelated provider fields change

     

       62
       63
        
           final isAuthenticated = context.select<AuthProvider, bool>(

     

       63
       64
        
             (p) => p.isAuthenticated,

     

       64
       65
        
           );

     

       65
       65
       -
           final feedProvider = Provider.of<FeedProvider>(context);

     

       66
       66
       +
           final isLoading = context.select<FeedProvider, bool>((p) => p.isLoading);

     

       67
       67
       +
           final error = context.select<FeedProvider, String?>((p) => p.error);

     

       68
       68
       +
           final posts = context.select<FeedProvider, List<FeedViewPost>>(

     

       69
       69
       +
             (p) => p.posts,

     

       70
       70
       +
           );

     

       71
       71
       +
           final isLoadingMore = context.select<FeedProvider, bool>(

     

       72
       72
       +
             (p) => p.isLoadingMore,

     

       73
       73
       +
           );

     

       66
       74
        
       

     

       67
       75
        
           return Scaffold(

     

       68
       76
        
             backgroundColor: const Color(0xFF0B0F14),

     
···

       72
       80
        
               title: Text(isAuthenticated ? 'Feed' : 'Explore'),

     

       73
       81
        
               automaticallyImplyLeading: false,

     

       74
       82
        
             ),

     

       75
       75
       -
             body: SafeArea(child: _buildBody(feedProvider, isAuthenticated)),

     

       83
       83
       +
             body: SafeArea(

     

       84
       84
       +
               child: _buildBody(

     

       85
       85
       +
                 isLoading: isLoading,

     

       86
       86
       +
                 error: error,

     

       87
       87
       +
                 posts: posts,

     

       88
       88
       +
                 isLoadingMore: isLoadingMore,

     

       89
       89
       +
                 isAuthenticated: isAuthenticated,

     

       90
       90
       +
               ),

     

       91
       91
       +
             ),

     

       76
       92
        
           );

     

       77
       93
        
         }

     

       78
       94
        
       

     

       79
       79
       -
         Widget _buildBody(FeedProvider feedProvider, bool isAuthenticated) {

     

       95
       95
       +
         Widget _buildBody({

     

       96
       96
       +
           required bool isLoading,

     

       97
       97
       +
           required String? error,

     

       98
       98
       +
           required List<FeedViewPost> posts,

     

       99
       99
       +
           required bool isLoadingMore,

     

       100
       100
       +
           required bool isAuthenticated,

     

       101
       101
       +
         }) {

     

       80
       102
        
           // Loading state

     

       81
       81
       -
           if (feedProvider.isLoading) {

     

       103
       103
       +
           if (isLoading) {

     

       82
       104
        
             return const Center(

     

       83
       105
        
               child: CircularProgressIndicator(color: Color(0xFFFF6B35)),

     

       84
       106
        
             );

     

       85
       107
        
           }

     

       86
       108
        
       

     

       87
       109
        
           // Error state

     

       88
       88
       -
           if (feedProvider.error != null) {

     

       110
       110
       +
           if (error != null) {

     

       89
       111
        
             return Center(

     

       90
       112
        
               child: Padding(

     

       91
       113
        
                 padding: const EdgeInsets.all(24),

     
···

       108
       130
        
                     ),

     

       109
       131
        
                     const SizedBox(height: 8),

     

       110
       132
        
                     Text(

     

       111
       111
       -
                       feedProvider.error!,

     

       133
       133
       +
                       _getUserFriendlyError(error),

     

       112
       134
        
                       style: const TextStyle(fontSize: 14, color: Color(0xFFB6C2D2)),

     

       113
       135
        
                       textAlign: TextAlign.center,

     

       114
       136
        
                     ),

     

       115
       137
        
                     const SizedBox(height: 24),

     

       116
       138
        
                     ElevatedButton(

     

       117
       117
       -
                       onPressed: () => feedProvider.retry(),

     

       139
       139
       +
                       onPressed: () {

     

       140
       140
       +
                         final feedProvider = Provider.of<FeedProvider>(

     

       141
       141
       +
                           context,

     

       142
       142
       +
                           listen: false,

     

       143
       143
       +
                         );

     

       144
       144
       +
                         feedProvider.retry();

     

       145
       145
       +
                       },

     

       118
       146
        
                       style: ElevatedButton.styleFrom(

     

       119
       147
        
                         backgroundColor: const Color(0xFFFF6B35),

     

       120
       148
        
                       ),

     
···

       127
       155
        
           }

     

       128
       156
        
       

     

       129
       157
        
           // Empty state

     

       130
       130
       -
           if (feedProvider.posts.isEmpty) {

     

       158
       158
       +
           if (posts.isEmpty) {

     

       131
       159
        
             return Center(

     

       132
       160
        
               child: Padding(

     

       133
       161
        
                 padding: const EdgeInsets.all(24),

     
···

       164
       192
        
             color: const Color(0xFFFF6B35),

     

       165
       193
        
             child: ListView.builder(

     

       166
       194
        
               controller: _scrollController,

     

       167
       167
       -
               itemCount:

     

       168
       168
       -
                   feedProvider.posts.length + (feedProvider.isLoadingMore ? 1 : 0),

     

       195
       195
       +
               itemCount: posts.length + (isLoadingMore ? 1 : 0),

     

       169
       196
        
               itemBuilder: (context, index) {

     

       170
       170
       -
                 if (index == feedProvider.posts.length) {

     

       197
       197
       +
                 if (index == posts.length) {

     

       171
       198
        
                   return const Center(

     

       172
       199
        
                     child: Padding(

     

       173
       200
        
                       padding: EdgeInsets.all(16),

     
···

       176
       203
        
                   );

     

       177
       204
        
                 }

     

       178
       205
        
       

     

       179
       179
       -
                 final post = feedProvider.posts[index];

     

       206
       206
       +
                 final post = posts[index];

     

       180
       207
        
                 return Semantics(

     

       181
       208
        
                   label:

     

       182
       209
        
                       'Feed post in ${post.post.community.name} by ${post.post.author.displayName ?? post.post.author.handle}. ${post.post.title ?? ""}',

     
···

       186
       213
        
               },

     

       187
       214
        
             ),

     

       188
       215
        
           );

     

       216
       216
       +
         }

     

       217
       217
       +
       

     

       218
       218
       +
         /// Transform technical error messages into user-friendly ones

     

       219
       219
       +
         String _getUserFriendlyError(String error) {

     

       220
       220
       +
           final lowerError = error.toLowerCase();

     

       221
       221
       +
       

     

       222
       222
       +
           if (lowerError.contains('socketexception') ||

     

       223
       223
       +
               lowerError.contains('network') ||

     

       224
       224
       +
               lowerError.contains('connection refused')) {

     

       225
       225
       +
             return 'Please check your internet connection';

     

       226
       226
       +
           } else if (lowerError.contains('timeoutexception') ||

     

       227
       227
       +
               lowerError.contains('timeout')) {

     

       228
       228
       +
             return 'Request timed out. Please try again';

     

       229
       229
       +
           } else if (lowerError.contains('401') ||

     

       230
       230
       +
               lowerError.contains('unauthorized')) {

     

       231
       231
       +
             return 'Authentication failed. Please sign in again';

     

       232
       232
       +
           } else if (lowerError.contains('404') || lowerError.contains('not found')) {

     

       233
       233
       +
             return 'Content not found';

     

       234
       234
       +
           } else if (lowerError.contains('500') ||

     

       235
       235
       +
               lowerError.contains('internal server')) {

     

       236
       236
       +
             return 'Server error. Please try again later';

     

       237
       237
       +
           }

     

       238
       238
       +
       

     

       239
       239
       +
           // Fallback to generic message for unknown errors

     

       240
       240
       +
           return 'Something went wrong. Please try again';

     

       189
       241
        
         }

     

       190
       242
        
       }

     

       191
       243

+51

lib/services/api_exceptions.dart

···

       1
       1
       +
       /// API Exception Types

     

       2
       2
       +
       ///

     

       3
       3
       +
       /// Custom exception classes for different types of API failures.

     

       4
       4
       +
       /// This allows better error handling and user-friendly error messages.

     

       5
       5
       +
       

     

       6
       6
       +
       /// Base class for all API exceptions

     

       7
       7
       +
       class ApiException implements Exception {

     

       8
       8
       +
         final String message;

     

       9
       9
       +
         final int? statusCode;

     

       10
       10
       +
         final dynamic originalError;

     

       11
       11
       +
       

     

       12
       12
       +
         ApiException(this.message, {this.statusCode, this.originalError});

     

       13
       13
       +
       

     

       14
       14
       +
         @override

     

       15
       15
       +
         String toString() => message;

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       /// Authentication failure (401)

     

       19
       19
       +
       /// Token expired, invalid, or missing

     

       20
       20
       +
       class AuthenticationException extends ApiException {

     

       21
       21
       +
         AuthenticationException(String message, {dynamic originalError})

     

       22
       22
       +
             : super(message, statusCode: 401, originalError: originalError);

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       /// Resource not found (404)

     

       26
       26
       +
       /// PDS, community, post, or user not found

     

       27
       27
       +
       class NotFoundException extends ApiException {

     

       28
       28
       +
         NotFoundException(String message, {dynamic originalError})

     

       29
       29
       +
             : super(message, statusCode: 404, originalError: originalError);

     

       30
       30
       +
       }

     

       31
       31
       +
       

     

       32
       32
       +
       /// Server error (500+)

     

       33
       33
       +
       /// Backend or PDS server failure

     

       34
       34
       +
       class ServerException extends ApiException {

     

       35
       35
       +
         ServerException(String message, {int? statusCode, dynamic originalError})

     

       36
       36
       +
             : super(message, statusCode: statusCode, originalError: originalError);

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       /// Network connectivity failure

     

       40
       40
       +
       /// No internet, connection refused, timeout

     

       41
       41
       +
       class NetworkException extends ApiException {

     

       42
       42
       +
         NetworkException(String message, {dynamic originalError})

     

       43
       43
       +
             : super(message, statusCode: null, originalError: originalError);

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       /// Federation error

     

       47
       47
       +
       /// atProto PDS unreachable or DID resolution failure

     

       48
       48
       +
       class FederationException extends ApiException {

     

       49
       49
       +
         FederationException(String message, {dynamic originalError})

     

       50
       50
       +
             : super(message, statusCode: null, originalError: originalError);

     

       51
       51
       +
       }

+92 -7

lib/services/coves_api_service.dart

···

       3
       3
        
       

     

       4
       4
        
       import '../config/oauth_config.dart';

     

       5
       5
        
       import '../models/post.dart';

     

       6
       6
       +
       import 'api_exceptions.dart';

     

       6
       7
        
       

     

       7
       8
        
       /// Coves API Service

     

       8
       9
        
       ///

     
···

       125
       126
        
       

     

       126
       127
        
             return TimelineResponse.fromJson(response.data as Map<String, dynamic>);

     

       127
       128
        
           } on DioException catch (e) {

     

       128
       128
       -
             if (kDebugMode) {

     

       129
       129
       -
               debugPrint('❌ Failed to fetch timeline: ${e.message}');

     

       130
       130
       -
             }

     

       131
       131
       -
             rethrow;

     

       129
       129
       +
             _handleDioException(e, 'timeline');

     

       132
       130
        
           }

     

       133
       131
        
         }

     

       134
       132
        
       

     
···

       170
       168
        
       

     

       171
       169
        
             return TimelineResponse.fromJson(response.data as Map<String, dynamic>);

     

       172
       170
        
           } on DioException catch (e) {

     

       173
       173
       -
             if (kDebugMode) {

     

       174
       174
       -
               debugPrint('❌ Failed to fetch discover feed: ${e.message}');

     

       171
       171
       +
             _handleDioException(e, 'discover feed');

     

       172
       172
       +
           }

     

       173
       173
       +
         }

     

       174
       174
       +
       

     

       175
       175
       +
         /// Handle Dio exceptions with specific error types

     

       176
       176
       +
         ///

     

       177
       177
       +
         /// Converts generic DioException into specific typed exceptions

     

       178
       178
       +
         /// for better error handling throughout the app.

     

       179
       179
       +
         Never _handleDioException(DioException e, String operation) {

     

       180
       180
       +
           if (kDebugMode) {

     

       181
       181
       +
             debugPrint('❌ Failed to fetch $operation: ${e.message}');

     

       182
       182
       +
             if (e.response != null) {

     

       183
       183
       +
               debugPrint('   Status: ${e.response?.statusCode}');

     

       184
       184
       +
               debugPrint('   Data: ${e.response?.data}');

     

       185
       185
       +
             }

     

       186
       186
       +
           }

     

       187
       187
       +
       

     

       188
       188
       +
           // Handle specific HTTP status codes

     

       189
       189
       +
           if (e.response != null) {

     

       190
       190
       +
             final statusCode = e.response!.statusCode;

     

       191
       191
       +
             final message = e.response!.data?['error'] ?? e.response!.data?['message'];

     

       192
       192
       +
       

     

       193
       193
       +
             if (statusCode != null) {

     

       194
       194
       +
               if (statusCode == 401) {

     

       195
       195
       +
                 throw AuthenticationException(

     

       196
       196
       +
                   message?.toString() ?? 'Authentication failed. Token expired or invalid',

     

       197
       197
       +
                   originalError: e,

     

       198
       198
       +
                 );

     

       199
       199
       +
               } else if (statusCode == 404) {

     

       200
       200
       +
                 throw NotFoundException(

     

       201
       201
       +
                   message?.toString() ?? 'Resource not found. PDS or content may not exist',

     

       202
       202
       +
                   originalError: e,

     

       203
       203
       +
                 );

     

       204
       204
       +
               } else if (statusCode >= 500) {

     

       205
       205
       +
                 throw ServerException(

     

       206
       206
       +
                   message?.toString() ?? 'Server error. Please try again later',

     

       207
       207
       +
                   statusCode: statusCode,

     

       208
       208
       +
                   originalError: e,

     

       209
       209
       +
                 );

     

       210
       210
       +
               } else {

     

       211
       211
       +
                 // Other HTTP errors

     

       212
       212
       +
                 throw ApiException(

     

       213
       213
       +
                   message?.toString() ?? 'Request failed: ${e.message}',

     

       214
       214
       +
                   statusCode: statusCode,

     

       215
       215
       +
                   originalError: e,

     

       216
       216
       +
                 );

     

       217
       217
       +
               }

     

       218
       218
       +
             } else {

     

       219
       219
       +
               // No status code in response

     

       220
       220
       +
               throw ApiException(

     

       221
       221
       +
                 message?.toString() ?? 'Request failed: ${e.message}',

     

       222
       222
       +
                 originalError: e,

     

       223
       223
       +
               );

     

       175
       224
        
             }

     

       176
       176
       -
             rethrow;

     

       225
       225
       +
           }

     

       226
       226
       +
       

     

       227
       227
       +
           // Handle network-level errors (no response from server)

     

       228
       228
       +
           switch (e.type) {

     

       229
       229
       +
             case DioExceptionType.connectionTimeout:

     

       230
       230
       +
             case DioExceptionType.sendTimeout:

     

       231
       231
       +
             case DioExceptionType.receiveTimeout:

     

       232
       232
       +
               throw NetworkException(

     

       233
       233
       +
                 'Connection timeout. Please check your internet connection',

     

       234
       234
       +
                 originalError: e,

     

       235
       235
       +
               );

     

       236
       236
       +
             case DioExceptionType.connectionError:

     

       237
       237
       +
               // Could be federation issue if it's a PDS connection failure

     

       238
       238
       +
               if (e.message?.contains('Failed host lookup') ?? false) {

     

       239
       239
       +
                 throw FederationException(

     

       240
       240
       +
                   'Failed to connect to PDS. Server may be unreachable',

     

       241
       241
       +
                   originalError: e,

     

       242
       242
       +
                 );

     

       243
       243
       +
               }

     

       244
       244
       +
               throw NetworkException(

     

       245
       245
       +
                 'Network error. Please check your internet connection',

     

       246
       246
       +
                 originalError: e,

     

       247
       247
       +
               );

     

       248
       248
       +
             case DioExceptionType.badResponse:

     

       249
       249
       +
               // Already handled above by response status code check

     

       250
       250
       +
               throw ApiException(

     

       251
       251
       +
                 'Bad response from server: ${e.message}',

     

       252
       252
       +
                 statusCode: e.response?.statusCode,

     

       253
       253
       +
                 originalError: e,

     

       254
       254
       +
               );

     

       255
       255
       +
             case DioExceptionType.cancel:

     

       256
       256
       +
               throw ApiException('Request cancelled', originalError: e);

     

       257
       257
       +
             default:

     

       258
       258
       +
               throw ApiException(

     

       259
       259
       +
                 'Unknown error: ${e.message}',

     

       260
       260
       +
                 originalError: e,

     

       261
       261
       +
               );

     

       177
       262
        
           }

     

       178
       263
        
         }

     

       179
       264

+2 -2

test/providers/feed_provider_test.dart

···

       445
       445
        
               did: 'did:plc:community',

     

       446
       446
        
               name: 'test-community',

     

       447
       447
        
             ),

     

       448
       448
       -
             createdAt: DateTime.now(),

     

       449
       449
       -
             indexedAt: DateTime.now(),

     

       448
       448
       +
             createdAt: DateTime.parse('2025-01-01T12:00:00Z'),

     

       449
       449
       +
             indexedAt: DateTime.parse('2025-01-01T12:00:00Z'),

     

       450
       450
        
             text: 'Test body',

     

       451
       451
        
             title: 'Test Post',

     

       452
       452
        
             stats: PostStats(

+4 -3

test/widgets/feed_screen_test.dart

···

       135
       135
        
             await tester.pumpWidget(createTestWidget());

     

       136
       136
        
       

     

       137
       137
        
             expect(find.text('Failed to load feed'), findsOneWidget);

     

       138
       138
       -
             expect(find.text('Network error'), findsOneWidget);

     

       138
       138
       +
             // Error message is transformed to user-friendly message

     

       139
       139
       +
             expect(find.text('Please check your internet connection'), findsOneWidget);

     

       139
       140
        
             expect(find.text('Retry'), findsOneWidget);

     

       140
       141
        
       

     

       141
       142
        
             // Test retry button

     
···

       337
       338
        
               did: 'did:plc:community',

     

       338
       339
        
               name: 'test-community',

     

       339
       340
        
             ),

     

       340
       340
       -
             createdAt: DateTime.now(),

     

       341
       341
       -
             indexedAt: DateTime.now(),

     

       341
       341
       +
             createdAt: DateTime.parse('2025-01-01T12:00:00Z'),

     

       342
       342
       +
             indexedAt: DateTime.parse('2025-01-01T12:00:00Z'),

     

       342
       343
        
             text: 'Test body',

     

       343
       344
        
             title: title,

     

       344
       345
        
             stats: PostStats(