Early remote config fetch and app initialization streamlining #121
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
- Initialize HttpClient early to break circular dependency with AuthRepository - Add RemoteConfig initialization as a separate step - Fetch initial RemoteConfig before other services initialization - Adjust comments and naming for clarity
- Add detailed documentation to the App widget class - Implement initialRemoteConfig parameter in App widget constructor - Update AppBloc creation to include initialRemoteConfig and navigatorKey - Improve code readability and formatting
- Add initialRemoteConfig parameter to AppBloc constructor - Update initial state to use pre-fetched remoteConfig - Refactor user authentication and config fetching logic - Remove redundant remoteConfig fetch and update - Optimize state transitions and data flow
- Remove standalone initialization of countriesClient with DataInMemory - Directly initialize countriesClient as CountryInMemoryClient - This change simplifies the code structure and improves readability
- Add error handling for initial RemoteConfig fetch - Introduce RemoteConfig? initialRemoteConfig and HttpException? initialRemoteConfigError variables - Implement try-catch block to handle HttpException and other unexpected errors - Log errors and pass UnknownException for unexpected errors - Update App initialization to include initialRemoteConfigError
- Remove StatusPage and related loading state - Add CriticalErrorPage for handling critical errors during startup - Update exports in view.dart
- Add critical error state and page to AppBloc and UI - Update App widget to handle critical error scenario - Refactor status page logic to accommodate new error handling - Import necessary packages for error handling
- Remove initializing, configFetching, and configFetchFailed states - Add criticalError state to handle startup failures - Introduce initialRemoteConfigError in AppState to store fetch error - Update AppLifeCycleStatus and AppState constructors accordingly
- Add initialRemoteConfigError to constructor and state - Implement criticalError state for fatal fetch failures - Refactor config fetching logic to handle errors gracefully - Update state transitions and logging for various error scenarios - Remove redundant config fetching status and related comments
- Add AppLifeCycleStatus.loadingUserData status - Introduce UserContentPreferences to store user preferences - Include initialUserPreferencesError in AppState - Update AppState constructor and copyWith method
- Add AppStarted event to handle initial app start - Include optional initialUser parameter for pre-fetched user data - Update props to include initialUser
- Separate AppStarted and AppUserChanged events - Simplify initial state setup - Add UserContentPreferences fetching - Enhance error handling and reporting - Optimize demo data initialization and migration - Refactor status evaluation logic
- Add userContentPreferencesRepository to AppBloc - Dispatch AppStarted event with initial user - Implement loading state for user data - Add error handling for user preferences loading - Update CriticalErrorPage to handle different error states
- Remove duplicate error handling logic - Re-throw HttpException and other exceptions to be handled by AppBloc - Simplify settings loading process
- Restructure AppBloc constructor for better readability - Implement AppUserDataLoaded event to signal successful user data load - Add null checks for settings in theme/font-related event handlers - Update initial AppState to reflect nullable settings - Improve code formatting and consistency
This event is dispatched when user-specific data (UserAppSettings and UserContentPreferences) have been successfully loaded and updated in the AppBloc state.
- Update `AppState` class to make `settings` nullable - Adjust the order of parameters in the constructor - Add documentation comment explaining that `settings` is null until successfully fetched from the backend
- Remove unnecessary `super.key` parameter - Enhance loading state UI for user data initialization - Refine app theme configuration with null safety - Improve code readability and structure
- Remove direct theme and font properties from AppState - Implement getters for themeMode, flexScheme, fontFamily, appTextScaleFactor, and appFontWeight - Update documentation and prop list to reflect changes - Adjust copyWith method to remove direct theme and font parameters
- Add abstract base class documentation for AppEvent - Enhance existing AppEvent subclasses with additional comments - Introduce new AppSettingsChanged event for user settings updates - Replace AppConfigFetchRequested with AppPeriodicConfigFetchRequested for clarity - Remove theme-related events (AppThemeModeChanged, AppFlexSchemeChanged, etc.) - Update AppUserFeedDecoratorShown event documentation
- Remove direct theme/font/locale management from AppState - Integrate periodic remote config fetching - Consolidate user settings updates and persistence - Simplify event handling and state transitions
- Rename AppPeriodicConfigFetchRequested event - Pass navigatorKey to AppBloc in MultiBlocProvider - Adjust formatting and indentation for better readability - Use state properties for theme configuration
- Replace AppConfigFetchRequested with AppPeriodicConfigFetchRequested in app resume event handling - Update logger messages for better readability
- Deleted the AppUserDataLoaded event class from app_event.dart - This event was likely made obsolete by recent changes in the app's architecture
- Extract user data fetching logic into a private method `_fetchAndSetUserData` - Remove redundant `AppUserDataLoaded` event and its handler - Update user data fetching流程 in multiple methods to use the new centralized logic - Improve error handling and state updates
- Rename AppSettingsRefreshed to AppUserAppSettingsRefreshed - Add new event AppUserContentPreferencesRefreshed - Update documentation for new events
- Separated fetchAndSetUserData into fetchAndSetUserSettings and fetchAndSetUserContentPreferences - Created new event handlers for user app settings and content preferences refresh - Updated AppBloc to handle new events and use new fetch functions - Improved error handling and logging for user settings and content preferences fetch operations
- Replace AppSettingsRefreshed with AppUserAppSettingsRefreshed - This change ensures that the font settings page correctly triggers - the appropriate event when settings are successfully updated
- Remove userContentPreferencesRepository parameter from AccountBloc instantiation
- Introduce new AppUserContentPreferencesChanged event - This event allows the AppBloc to update user content preferences - The event carries the complete, updated UserContentPreferences object - Helps in persisting the changes and updating the app state
- Removed AppBloc import from topics_filter_bloc.dart - Removed appBloc parameter from TopicsFilterBloc constructor - Deleted _appBloc field from TopicsFilterBloc class
…ested event Removed the unused TopicsFilterApplyFollowedRequested event class from the topics filter bloc. This event was intended to apply the user's followed topics as filters but is no longer needed in the current implementation. - Deleted TopicsFilterApplyFollowedRequested class - Updated file to remove unnecessary code and improve maintainability
…ter page - Remove _countriesFilterBloc property and its initialization - Remove CountriesFilterRequested event triggering - Update context reads to use CountriesFilterBloc directly - Adjust UI logic to remove dependency on _countriesFilterBloc
- Replace TopicsFilterBloc with AppBloc for followed topics data - Simplify logic for applying followed topics filter - Remove unnecessary loading state and error handling for followed topics - Optimize UI updates and snackbar messages
- Remove AccountBloc dependency from headlines_feed_page.dart - Update logic to use AppBloc for content preferences - Simplify follow/unfollow toggle functionality - Improve code readability and maintainability
- Remove unused state variables related to followed filters - Replace manual followed filters fetching with BlocBuilder - Simplify UI logic for displaying followed filters - Remove loading and error handling for followed filters
- Define base HeadlinesFilterEvent class - Add FilterDataLoaded event for initial filter data load - Implement FilterTopicToggled, FilterSourceToggled, and FilterCountryToggled events for checkbox toggles - Add FollowedItemsFilterToggled event for followed items toggle - Implement FilterSelectionsCleared event to clear all filters
- Define HeadlinesFilterStatus enum for different fetching statuses - Create HeadlinesFilterState class to hold filter options and selections - Include properties for topics, sources, countries, and followed items - Implement copyWith method for state immutability - Add error handling for failure status
- Add new BLoC for managing centralized headlines filter feature - Implement logic for fetching filter options (topics, sources, countries) - Handle user interactions with filter UI - Integrate with AppBloc for user content preferences - Add event handlers for various filter-related actions
…rBloc - Replace CountriesFilterBloc with HeadlinesFilterBloc for centralized state management - Convert CountryFilterPage from StatefulWidget to StatelessWidget - Remove local selection state and rely on HeadlinesFilterBloc for country selections - Update UI to reflect changes in state management logic - Simplify page navigation and data handling by integrating with HeadlinesFilterBloc
- Remove unused headlinesFeedBloc variable - Remove extra parameter when navigating to filter page
…Bloc - Replace SourcesFilterBloc with HeadlinesFilterBloc for state management - Remove local state and data loading logic from SourceFilterPage - Update UI to reflect new state management approach - Improve performance and reduce complexity
…terBloc - Replace TopicsFilterBloc with HeadlinesFilterBloc for topic management - Convert TopicFilterPage from StatefulWidget to StatelessWidget - Remove local topic selection management, use centralized HeadlinesFilterBloc - Update UI to reflect changes in state from HeadlinesFilterBloc - Simplify follow filter logic, integrate with HeadlinesFilterBloc - Remove unnecessary scroll controller and pagination logic
…agement - Replace local state management with HeadlinesFilterBloc - Remove temporary filter selection variables and logic - Add loading and failure states handling - Update UI to reflect new state management approach - Refactor filter tile building and selection logic
- Add new localization strings for both Arabic and English - Introduce "headlinesFeedFilterLoadingHeadline" for loading state on headlines filter page - Update corresponding description for both language files
- Remove BlocProvider from TopicFilterPage and SourceFilterPage - Simplify CountryFilterPage by removing unnecessary BlocProvider - Improve code readability and reduce complexity in feed filter routes
… and code quality - Add comprehensive documentation for HeadlinesSearchBloc using dartdoc - Optimize code for fetching user settings from AppBloc - Improve method documentation for search-related functions - Make code more concise and easier to understand
- Convert HeadlinesSearchPage from StatelessWidget to StatefulWidget - Remove unnecessary _HeadlinesSearchView widget - Simplify state management and UI building logic - Enhance code readability and maintainability
- Remove BlocProvider.value(value: accountBloc) from multiple places in the router - This change removes unnecessary duplication of the AccountBloc provider - The AccountBloc should be provided higher up in the widget tree (e.g., in AppShell or App) - This refactor simplifies the router configuration and improves performance
- Change appEnvironment from AppEnvironment.demo to AppEnvironment.production in main.dart
Modified `lib/app/bloc/app_bloc.dart` to correctly initialize the `AppBloc`'s lifecycle status based on the presence of an initial user. This prevents the "Loading Settings" screen from appearing for unauthenticated users before they are directed to the authentication page, ensuring a more accurate and intuitive startup flow.
![gemini-code-assist[bot]](https://avatars.githubusercontent.com/in/956858?s=60&v=4){kind=small}
There was a problem hiding this comment.
Summary of Changes
Hello @fulleni, I'm Gemini Code Assist1! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!
This pull request significantly refactors the application's core state management and initialization processes. The primary goal is to centralize application-wide data, including user preferences and remote configurations, into a single AppBloc. This change streamlines data flow, simplifies UI interactions with user settings and content preferences, and enhances the robustness of the app's startup sequence by introducing explicit error handling for critical initialization steps.
Highlights
- Centralized App State Management: The
AppBlocnow serves as the single source of truth for all application-wide state, including user authentication, app settings, and user content preferences (followed topics, sources, countries, and saved headlines). This change eliminates the separateAccountBloc. - Streamlined App Initialization: Remote configuration is now fetched earlier in the bootstrap process to enable immediate evaluation of global app status (e.g., maintenance mode, update requirements). The root
Appwidget andAppBlochave been refactored to explicitly manage initial data loading and critical startup error states. - Refactored Headline Filter System: A new
HeadlinesFilterBlochas been introduced to centralize all headline filtering logic (topics, sources, countries). This replaces multiple individual filter BLoCs, simplifying the management of filter selections and their interaction with user preferences. - Simplified UI Data Access: UI components across the application now access display settings (like theme, font, text scale, and headline image style) and user content preferences directly from top-level properties of
AppBloc.state, reducing nested property access and improving code readability. - Improved Critical Error Handling: A dedicated
CriticalErrorPagehas been added to provide a clear user interface and retry mechanism for unrecoverable startup errors, such as failures in fetching remote configuration or initial user data. This enhances the application's robustness during critical initialization phases.
Using Gemini Code Assist
The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.
Invoking Gemini
You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.
| Feature | Command | Description |
|---|---|---|
| Code Review | /gemini review |
Performs a code review for the current pull request in its current state. |
| Pull Request Summary | /gemini summary |
Provides a summary of the current pull request in its current state. |
| Comment | @gemini-code-assist | Responds in comments when explicitly tagged, both in pull request comments and review comments. |
| Help | /gemini help |
Displays a list of available commands. |
Customization
To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.
Limitations & Feedback
Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.
You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.
Footnotes
-
Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩
There was a problem hiding this comment.
Code Review
This is a significant and well-executed refactoring that greatly simplifies the app's state management and startup logic. Centralizing user preferences and other global state into AppBloc and removing AccountBloc is a major improvement. The introduction of a more robust bootstrap process, where RemoteConfig is fetched early, enhances reliability. The consolidation of filter-related BLoCs into a single HeadlinesFilterBloc is also a great simplification. I've found a couple of critical issues related to the new implementation that need to be addressed, along with a minor point about the environment configuration.
- Replace List.of with List.from for creating a shallow copy of savedHeadlines list - This change improves code readability and follows the more common practice in the Flutter community
- Update loading condition to check for `loadingUserData` status - Add comments to explain the loading state logic - Wrap LoadingStateWidget in a Builder to potentially improve widget tree structure
- Change appEnvironment from production to demo in main.dart
fulleni
deleted the
Early-RemoteConfig-Fetch-and-App-Initialization-Streamlining
branch
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Status
READY
Description
This pull request significantly refactors the application's core state management and initialization processes. The primary goal is to centralize application-wide data, including user preferences and remote configurations, into a single AppBloc. This change streamlines data flow, simplifies UI interactions with user settings and content preferences, and enhances the robustness of the app's startup sequence by introducing explicit error handling for critical initialization steps.
Type of Change