commit 93d292e733ef490a5f48388e99222bfd5b863ac4 · bretton.dev/coves-mobile

+17 -12

lib/main.dart

···

       64
       64
        
                       authProvider: authProvider,

     

       65
       65
        
                     ),

     

       66
       66
        
               ),

     

       67
       67
       -
               ChangeNotifierProxyProvider2<AuthProvider, VoteProvider,

     

       68
       68
       -
                   MultiFeedProvider>(

     

       67
       67
       +
               ChangeNotifierProxyProvider2<

     

       68
       68
       +
                 AuthProvider,

     

       69
       69
       +
                 VoteProvider,

     

       70
       70
       +
                 MultiFeedProvider

     

       71
       71
       +
               >(

     

       69
       72
        
                 create:

     

       70
       73
        
                     (context) => MultiFeedProvider(

     

       71
       74
        
                       authProvider,

     
···

       79
       82
        
               // CommentsProviderCache manages per-post CommentsProvider instances

     

       80
       83
        
               // with LRU eviction and sign-out cleanup

     

       81
       84
        
               ProxyProvider2<AuthProvider, VoteProvider, CommentsProviderCache>(

     

       82
       82
       -
                 create: (context) => CommentsProviderCache(

     

       83
       83
       -
                   authProvider: authProvider,

     

       84
       84
       -
                   voteProvider: context.read<VoteProvider>(),

     

       85
       85
       -
                   commentService: commentService,

     

       86
       86
       -
                 ),

     

       85
       85
       +
                 create:

     

       86
       86
       +
                     (context) => CommentsProviderCache(

     

       87
       87
       +
                       authProvider: authProvider,

     

       88
       88
       +
                       voteProvider: context.read<VoteProvider>(),

     

       89
       89
       +
                       commentService: commentService,

     

       90
       90
       +
                     ),

     

       87
       91
        
                 update: (context, auth, vote, previous) {

     

       88
       92
        
                   // Reuse existing cache

     

       89
       89
       -
                   return previous ?? CommentsProviderCache(

     

       90
       90
       -
                     authProvider: auth,

     

       91
       91
       -
                     voteProvider: vote,

     

       92
       92
       -
                     commentService: commentService,

     

       93
       93
       -
                   );

     

       93
       93
       +
                   return previous ??

     

       94
       94
       +
                       CommentsProviderCache(

     

       95
       95
       +
                         authProvider: auth,

     

       96
       96
       +
                         voteProvider: vote,

     

       97
       97
       +
                         commentService: commentService,

     

       98
       98
       +
                       );

     

       94
       99
        
                 },

     

       95
       100
        
                 dispose: (_, cache) => cache.dispose(),

     

       96
       101
        
               ),

+4 -3

lib/models/feed_state.dart

···

       71
       71
        
             isLoadingMore: isLoadingMore ?? this.isLoadingMore,

     

       72
       72
        
             error: error == _sentinel ? this.error : error as String?,

     

       73
       73
        
             scrollPosition: scrollPosition ?? this.scrollPosition,

     

       74
       74
       -
             lastRefreshTime: lastRefreshTime == _sentinel

     

       75
       75
       -
                 ? this.lastRefreshTime

     

       76
       76
       -
                 : lastRefreshTime as DateTime?,

     

       74
       74
       +
             lastRefreshTime:

     

       75
       75
       +
                 lastRefreshTime == _sentinel

     

       76
       76
       +
                     ? this.lastRefreshTime

     

       77
       77
       +
                     : lastRefreshTime as DateTime?,

     

       77
       78
        
           );

     

       78
       79
        
         }

     

       79
       80
        
       }

+16 -18

lib/providers/multi_feed_provider.dart

···

       33
       33
        
           // Use injected service (for testing) or create new one (for production)

     

       34
       34
        
           // Pass token getter, refresh handler, and sign out handler to API service

     

       35
       35
        
           // for automatic fresh token retrieval and automatic token refresh on 401

     

       36
       36
       -
           _apiService = apiService ??

     

       36
       36
       +
           _apiService =

     

       37
       37
       +
               apiService ??

     

       37
       38
        
               CovesApiService(

     

       38
       39
        
                 tokenGetter: _authProvider.getAccessToken,

     

       39
       40
        
                 tokenRefresher: _authProvider.refreshToken,

     
···

       228
       229
        
           try {

     

       229
       230
        
             if (refresh) {

     

       230
       231
        
               // Start loading, keep existing data visible

     

       231
       231
       -
               _feedStates[type] = currentState.copyWith(

     

       232
       232
       -
                 isLoading: true,

     

       233
       233
       -
                 error: null,

     

       234
       234
       -
               );

     

       232
       232
       +
               _feedStates[type] = currentState.copyWith(isLoading: true, error: null);

     

       235
       233
        
             } else {

     

       236
       234
        
               // Pagination

     

       237
       237
       -
               _feedStates[type] = currentState.copyWith(

     

       238
       238
       -
                 isLoadingMore: true,

     

       239
       239
       -
               );

     

       235
       235
       +
               _feedStates[type] = currentState.copyWith(isLoadingMore: true);

     

       240
       236
        
             }

     

       241
       237
        
             notifyListeners();

     

       242
       238
        
       

     
···

       342
       338
        
           return _fetchFeed(

     

       343
       339
        
             type: type,

     

       344
       340
        
             refresh: refresh,

     

       345
       345
       -
             fetcher: () => _apiService.getTimeline(

     

       346
       346
       -
               sort: _sort,

     

       347
       347
       -
               timeframe: _timeframe,

     

       348
       348
       -
               cursor: refresh ? null : currentState.cursor,

     

       349
       349
       -
             ),

     

       341
       341
       +
             fetcher:

     

       342
       342
       +
                 () => _apiService.getTimeline(

     

       343
       343
       +
                   sort: _sort,

     

       344
       344
       +
                   timeframe: _timeframe,

     

       345
       345
       +
                   cursor: refresh ? null : currentState.cursor,

     

       346
       346
       +
                 ),

     

       350
       347
        
             feedName: 'Timeline',

     

       351
       348
        
           );

     

       352
       349
        
         }

     
···

       361
       358
        
           return _fetchFeed(

     

       362
       359
        
             type: type,

     

       363
       360
        
             refresh: refresh,

     

       364
       364
       -
             fetcher: () => _apiService.getDiscover(

     

       365
       365
       -
               sort: _sort,

     

       366
       366
       -
               timeframe: _timeframe,

     

       367
       367
       -
               cursor: refresh ? null : currentState.cursor,

     

       368
       368
       -
             ),

     

       361
       361
       +
             fetcher:

     

       362
       362
       +
                 () => _apiService.getDiscover(

     

       363
       363
       +
                   sort: _sort,

     

       364
       364
       +
                   timeframe: _timeframe,

     

       365
       365
       +
                   cursor: refresh ? null : currentState.cursor,

     

       366
       366
       +
                 ),

     

       369
       367
        
             feedName: 'Discover',

     

       370
       368
        
           );

     

       371
       369
        
         }

+9 -7

lib/screens/home/feed_screen.dart

···

       286
       286
        
       

     

       287
       287
        
         /// Switch to a feed type and animate PageView

     

       288
       288
        
         void _switchToFeedType(FeedType type, int pageIndex) {

     

       289
       289
       -
           final provider = context.read<MultiFeedProvider>();

     

       290
       290
       -
           provider.setCurrentFeed(type);

     

       289
       289
       +
           context.read<MultiFeedProvider>().setCurrentFeed(type);

     

       291
       290
        
       

     

       292
       291
        
           // Animate to the corresponding page

     

       293
       292
        
           _pageController.animateToPage(

     
···

       321
       320
        
         void _restoreScrollPosition(FeedType type) {

     

       322
       321
        
           // Wait for the next frame to ensure the controller has clients

     

       323
       322
        
           WidgetsBinding.instance.addPostFrameCallback((_) {

     

       324
       324
       -
             if (!mounted) return;

     

       323
       323
       +
             if (!mounted) {

     

       324
       324
       +
               return;

     

       325
       325
       +
             }

     

       325
       326
        
       

     

       326
       327
        
             final controller = _scrollControllers[type];

     

       327
       328
        
             if (controller != null && controller.hasClients) {

     
···

       379
       380
        
                 scrollController: _getOrCreateScrollController(feedType),

     

       380
       381
        
                 onRefresh: () => provider.loadFeed(feedType, refresh: true),

     

       381
       382
        
                 onRetry: () => provider.retry(feedType),

     

       382
       382
       -
                 onClearErrorAndLoadMore: () {

     

       383
       383
       -
                   provider.clearError(feedType);

     

       384
       384
       -
                   provider.loadMore(feedType);

     

       385
       385
       -
                 },

     

       383
       383
       +
                 onClearErrorAndLoadMore:

     

       384
       384
       +
                     () =>

     

       385
       385
       +
                         provider

     

       386
       386
       +
                           ..clearError(feedType)

     

       387
       387
       +
                           ..loadMore(feedType),

     

       386
       388
        
                 isAuthenticated: isAuthenticated,

     

       387
       389
        
                 currentTime: provider.currentTime,

     

       388
       390
        
               );

+2 -1

lib/widgets/feed_page.dart

···

       151
       151
        
                             const SizedBox(height: 8),

     

       152
       152
        
                             Text(

     

       153
       153
        
                               widget.isAuthenticated

     

       154
       154
       -
                                   ? 'Subscribe to communities to see posts in your feed'

     

       154
       154
       +
                                   ? 'Subscribe to communities to see '

     

       155
       155
       +
                                       'posts in your feed'

     

       155
       156
        
                                   : 'Check back later for new posts',

     

       156
       157
        
                               style: const TextStyle(

     

       157
       158
        
                                 fontSize: 14,

+3 -2

test/widgets/feed_screen_test.dart

···

       362
       362
        
             tester,

     

       363
       363
        
           ) async {

     

       364
       364
        
             fakeAuthProvider.setAuthenticated(value: true);

     

       365
       365
       -
             fakeFeedProvider.setPosts(FeedType.discover, [_createMockPost('Post 1')]);

     

       366
       366
       -
             fakeFeedProvider.setPosts(FeedType.forYou, [_createMockPost('Post 2')]);

     

       365
       365
       +
             fakeFeedProvider

     

       366
       366
       +
               ..setPosts(FeedType.discover, [_createMockPost('Post 1')])

     

       367
       367
       +
               ..setPosts(FeedType.forYou, [_createMockPost('Post 2')]);

     

       367
       368
        
       

     

       368
       369
        
             await tester.pumpWidget(createTestWidget());

     

       369
       370
        
             await tester.pumpAndSettle();