Advanced Flutter: MVVM with Provider, Riverpod | BLoC

Discover how MVVM organizes Flutter apps by connecting the view, ViewModel, and Model through a repository, local data or API, and state management for scalable UI.

Create a flutter project via the terminal or Android Studio UI. Name it MVVM state management and decide to keep or remove boilerplate comments with the -E flag.

Builds an mvvm-based Flutter project structure with folders for view, screens, widgets, a view models directory, a repository, services, utils, and models, wiring api services and json serialization.

Add common packages from pub.dev for four state management approaches (set state, provider, riverpod, bloc) and set up a base movies screen with cached_network_image, http, flutter_dotenv, and shared_preferences.

Create the app theme by defining theme data and a colors file for light and dark themes, app bar styling, and surface color.

Create a movies screen with an app bar, action buttons, and a list view of movie items, using a reusable cached network image widget and a global image url constant.

Explore starting the movies widget in an MVVM setup, building a reusable dynamic widget that shows a cached image, title, rating, genres, and release date with inkwell and error handling.

Implement a reusable favorite button widget in Flutter as a stateless widget, set the icon size to 20, wire it into the movie widget, and prepare for favorite state management.

Build a dynamic genres list widget with a wrap layout, render from a genres list using list.generate, and style with padding and theme colors.

Implement the favorites page in Flutter by creating favorites_screen.dart, duplicating the movies screen, adjusting the title to 'favorite movies', adding a delete button, and refining padding for consistency.

Implement a movie details screen with a stacked, scrollable user interface featuring a cached image, back button, title, rating, release date, genres, and description.

Implement the splash screen and a global error widget to handle loading favorites and genres. Map genre IDs and explore mvvm navigation with futurebuilder and async notifier topics later.

Explore clean navigation in flutter with MVVM architecture and a reusable navigation service. Implement push, push replacement, and named routes using a global navigator key and GetIt for singleton access.

Implement a Flutter navigation service with a navigate function using a navigator key, push and push replacement, routing to the favorite screen and movie detail screen.

Learn to implement a clean dialogue in Flutter using show adaptive dialogue, with platform-specific UI for iOS and Android, and manage context and navigation.

Implement a clean snackbar flow using scaffold messenger to hide any existing snackbar before showing a new one, with an optional action. Test on the movies screen.

Learn API integration in MVVM using the movies db API, including creating an account, obtaining an API key, and reviewing the documentation for state management across Flutter projects.

Explore the movie database api documentation to fetch the movies list and genres, and understand bearer token, api key, pagination, and json modeling for flutter state management.

Create a movie model with a results field, and implement from JSON and to JSON constructors to transform API responses into a model and save favorites as JSON.

Explain why we map genre ids to names via the genre API, showing how ids correspond to genres like action and adventure, and why fetch the list at startup.

Create an API constants class to hold the base URL, bearer token, API key, and headers for consistent API calls, and implement a reusable authorization header in Flutter.

Secure api keys and tokens in flutter by using the flutter_dotenv package, creating a .env file, loading it in main, and guarding access via dotenv and gitignore.

Create an API service in Flutter, send a get request with http, handle the URI and headers, decode JSON, and fetch movie data into the app.

Override the toString method in the MoviesModel to customize what prints for each item, using the override keyword and data values from the model to show movie details.

Implement the movie genres model and api calls within an MVVM flutter setup, creating from json factory, fetching genres, testing in the movie screen, and preparing for repository integration.

Implement a movies repository using the API service to fetch movies and genres, wiring the constructor and methods for clean REST API integration and practical testing.

Identify whether data is needed by a single widget or across screens, and choose ephemeral state with setState or global state management with provider, Riverport, or BLoC.

Examine the drawbacks of setState and compare it with provider, riverpod, and BLoC for scalable movie pagination. Implement bottom scroll fetch, loading indicators, and repository data to append results.

Pass the movie model to the widgets, and display the correct title, vote average, release date, and backdrop or poster image on the details screen.

Animate the image in the movie detail view by using a hero widget tagged with the image id, caching the image, wrapping in a center, and previewing the animated transition.

Fetch genres on app startup via the splash screen, use a movie repository, handle loading and errors, and navigate to the movies screen to map and display genres.

Fetch genres and cache them, then map genre IDs to names for each movie and display the correct genres on screen.

Test the retry button in error handling to verify the loading indicator appears and navigation succeeds after retry, ensuring the flow works as intended.

Implement the favorite button with setState, store favorites via shared preferences, and learn why this approach fails for app-wide state, paving the way to provider, Riverpod, or BLoC.

Apply toStringAsFixed(1) to the average rating in the movies widget and details screen. The lecture previews future state management changes.

Refactor a base flutter ui to remove setstate and support bloc, provider, and riverpod state management. Convert widgets to stateless, modular components and update imports.

Explain provider state management in theory, showing how to access shared state up the widget tree with listener and consumer, and how change notifier triggers UI updates.

Explore how to implement dark and light themes with provider state management in Flutter, toggle themes, and persist the choice with shared preferences for future sessions.

Harness the consumer widget to efficiently rebuild only parts of the UI with a theme provider, using child to prevent unnecessary rebuilds when switching between dark and light modes.

Load the last saved theme with the theme provider, default to light if nothing is stored, and apply dark or light mode by a saved boolean and notify listeners.

Create a movies provider in flutter mvvm using provider to fetch genres and movies with pagination, track current page, and handle loading and errors via notify listeners.

Implement a splash screen using provider, initialize the movies provider, and fetch genres and movies with a future builder before navigating to the movies screen.

Explore how the app connects via mvvm using a movies provider, repository, and api service, then binds data to the ui through the view model and notify listeners.

Test error handling in the splash screen by using async/await, mounted checks, and a retry flow with a loading spinner, FutureBuilder, and provider-based state management.

Implement pagination with provider state management by wrapping the list in a consumer, using a notification listener to fetch more movies when reaching the bottom, handling loading, empty, and errors.

Learn how to display movie information on screen using a new provider-based approach with change notifier provider, wiring a movie model to update ui and handle data changes.

Define a movie provider to fetch and display the correct genres on the screen, including action, comedy, and science fiction; implement the favorite button and mechanism for practice.

Implement a favorites provider for the movie screen with change notifier, managing a MovieModel favorites list with add or remove and persisting to shared preferences via json encode and decode.

Implement a favorite feature with provider and consumer widgets to add or remove movies from favorites, reflect changes with icons and colors, and fetch favorites on app restart.

Load and display favorite movies on app start by using the favorites provider, ensuring Deadpool and Inside Out appear after restart, with steps to show them on the favorites screen.

Display and manage the favorites list on the favorites screen using provider state management, including listing, reversing order, deleting items, and showing an empty state.

Discover Riverpod state management as a modern alternative to provider, covering theme handling, dependency injection, and multi-provider usage, with pub.dev setup and package installation.

Create a theme provider using Riverpod state notifier, load and toggle light and dark themes with shared preferences. Explore enums for scalable theming in an advanced Flutter mvvm course.

Wrap the app with a provider scope and define a state notifier provider for theme, using Riverpod to read and watch the theme state and toggle modes.

Recap how we implemented the theme provider with riverpod state management, using theme enums, shared preference, and a provider scope to toggle dark and light themes via a consumer widget.

Master Riverpod's consumer widget with a builder using context and ref to access href, avoid unnecessary rebuilds, and improve performance by splitting code into smaller widgets.

Define a dedicated movies state class for the River pod package, initializing current page, movies list, genres, and loading and error flags. Create a constructor to initialize the state.

Implement a copyWith function on the movies state to update specific fields in a provider-based MVVM setup, preserving current values when null and enabling targeted state changes.

Create a movies provider with Riverpod by implementing a state notifier, managing loading state, fetching and appending movies, and updating current page and errors within MVVM architecture.

Implement a splash screen with a future builder in a Riverpod MVVM setup, wire a movies provider, and debug infinite loops.

Learn to implement a splash screen in Flutter using Riverpod future provider and async notifier, replacing the future builder, with loading and error handling and data-driven navigation.

Test error handling in the splash screen by turning off wifi, restarting the app, and retrying after connectivity returns to verify resilience using Riverpod.

Avoid setState error by deferring updates with add post frame callback during build, and wrap the user interface in a scaffold to prevent black screens while data loads through provider.

Master Riverpod lifecycle by using autoDispose with ref.keepAlive to control a provider started in the splash screen, ensuring memory efficiency, avoiding reinitialization, and keeping state alive as needed.

Fetch movies on the movies screen using provider and Riverpod, with a consumer widget accessing the movies provider and pagination that loads more at the list end.

Use Riverpod family to locate the current movie by index, access the movie model from state, and display the correct image and title in the movies list and details page.

Fix the duplicated movies bug by guarding the fetch when reaching the bottom with a loading check, ensuring get movie runs only once per page as the user scrolls.

Implement a favorites state and provider in flutter using mvvm architecture, persisting favorite items with shared preferences, and wire up state management to add, remove, and load favorites.

Harness Riverpod provider patterns to add and remove movies from favorites, using select to read the favorite movie list and copyWith to immutably update it.

Load the favorites at app start using Riverpod state management, initialize preferences, and update the favorites list with copyWith to display saved items on launch.

Wire the favorites state with riverpod and provider; use consumer widget, pass the movie model to show favorites, and use notifiers to add, remove, and clear while handling empty lists.

Learn how to use stream provider with Riverpod to emit continuous weather data from a custom weather repo, replacing streams unavailable from an API, and display updates every two seconds.

Explore the Riverpod logging observer to track provider lifecycle events such as did add, update, and dispose, and implement an observer to log stream and theme provider updates for debugging.

Explore the consumer stateful widget in Riverpod and how ref, watch, and context enable provider access inside and outside build, contrasting it with stateless consumers.

Learn to display the correct movie genres by accessing the movie state, using a provider with a consumer widget, and wiring the movie model and ids to the genres list.

Explain the theory of bloc within the mvvm framework, showing how a bloc, its events, and its state collaborate to toggle themes via streams and update the UI.

Add the flutter bloc and equatable packages to enable bloc state management in your app. Copy the packages into pubspec.yaml and read the install instructions on pub.dev.

Learn how the Equatable package simplifies object comparison by extending Equatable, overriding props and hashCode, and importing from pub.dev for use with state management.

Create a theme bloc using Riverpod and bloc concepts, converting load and toggle theme functions into events, and defining light, dark, and error theme states.

Implement the theme bloc in Riverpod with provider, adding load theme and toggle theme events, emitting dark and light theme states using shared preferences and a theme data constant.

Finalize a theme provider in Flutter MVVM with Provider, Riverpod, and Bloc by wiring MultiProvider, building a BlocBuilder, and applying light or dark themes.

Enable theme toggling in a Flutter app by dispatching a toggle event to the theme bloc from the button and updating the icon with bloc builder based on dark state.

Explore using GetIt to manage the theme block in a Flutter MVVM setup with BLoC, replacing context-based access for memory efficiency and simpler state management.

Create a movies bloc using riverpod provider by defining movie states and two events—fetch movies and fetch more movies—handling loading, errors, pagination, and genres.

Create the movies bloc functions, applying MVVM-style state management to fetch genres and movies, handle loading and errors, and support pagination with Riverpod.

Introduce the bloc listener and use it to react to state changes, navigate on movies loaded, and show snack bars for errors within the splash screen flow.

Test error handling in the splash screen with BLoC, showing a snack bar error message and a retry button that triggers loading after each retry.

Implement movie list pagination with BLoC and Riverpod, switch to a block builder, manage loading, loading more, and errors, and show a bottom circular progress indicator while fetching more movies.

Learn to display the correct movies data in a flutter app using MVVM with Provider, Riverpod, and BLoC by wiring the movies model to the UI.

Display the correct genres for each movie by mapping genre IDs to titles using Riverpod and Bloc, with a block builder handling loaded and loading states.

Implement the favorites feature with bloc by defining load, add, remove, and clear events and states (loading, loaded list, error) using movie models.

Implement the favorites bloc: add, remove, load, and clear favorites, save to shared preferences via json, and emit updated states based on events.

Learn to add and remove items from favorites in a Flutter mvvm app using a favorites block and a block builder to refresh the user interface with provider and riverpod.

Introduce the MultiBlocListener widget to load favorites on splash, coordinating favorite and movie states and navigating once both are loaded.

Fix the add or remove from favorites bug by examining the favorites state, logging the list length, and adding missing equatable props to events and states.

Display and manage the favorite movies list in Flutter using bloc, provider, and Riverpod, including loading states, error handling, and clearing items.

Introduce the bloc consumer widget, integrate builder and listener logic, and handle errors with snackbars using a unified approach alongside multi bloc listener considerations.