Learn to build scalable Flutter apps with BLoC

Build a scalable task app with block by organizing ui code into separate files and folders, learning block basics, implementing the block pattern, and using internal repositories with dependency injection.

Learn how to separate UI into files and folders in a Flutter app, organize main.dart, lib/pages, and lib/views, and wrap home view with block providers using two stateless widgets.

Learn to separate the UI into reusable widgets, such as category cards and a floating action button, and organize files with snake_case imports to improve modularity in a Flutter app.

Discover how to separate UI code into distinct widgets and files, like text input and status cards, to keep Flutter apps scalable and easier to manage.

Discover how to separate ui code by using constructor values for text and color, create reusable status cards, and organize widgets into constant files for a scalable Flutter BLoC app.

Discover how BLoC manages state with events, emits new states, and triggers UI rebuilds, while using repositories and dependency injection (get it package) to build scalable Flutter apps.

Learn to create internal Flutter packages within your project by adding a packages folder and using flutter create with a package template for a task repository, including its pubspec.yaml.

Create an internal package with a task repository and export src in lib, using repositories that connect to APIs and Firebase Firestore via the Bloc pattern from the Block Library.

Define a task model with a status enum and export it from the internal package. Create a broadcast stream controller for task lists and expose a getter to stream it.

Explore using the block pattern to manage an in-memory task list with a controller, implementing add, edit, and delete methods, updating the stream with new task states and IDs.

Demonstrates creating an internal task repository package to delete, add, and edit tasks, update the task stream, and wire the package via pubspec.yaml in a scalable Flutter BLoC app.

Learn how to create internal packages for flutter projects, including an app ui package and reusable styles, and how to copy and customize external repositories as internal packages for reuse.

Generate a home screen bloc by creating a task block with its state, event, and bloc files. See how events emit new states and the ui rebuilds per screen.

Define a BLoC state class with two properties: selected category and list of todos, driven by a TaskCategory enum (done, pending, all); default to all and an empty list.

Build scalable Flutter apps with BLoC by handling events like select category and get all tasks; ensure the BLoC processes events, emits new states, and the UI rebuilds accordingly.

Create a task bloc that extends bloc base with task event and state types, initializes with an empty task list, and registers callbacks for get all tasks and select category.

Create a Flutter bloc that fetches all tasks from a task repository, listens to the task stream, and emits a new task state with the updated task list.

Explore handling the select category callback in a Flutter app using BLoC, updating the task state with the new category, and emitting the updated state for a responsive UI.

Explore how to implement a copyWith method in Flutter BLoC to create a new task state from optional parameters like task list and selected category, preserving existing values.

Wrap the home view with a block provider to connect the task block to the user interface. Initialize dependencies to register a singleton task repository for use across blocks.

Access a block only within its screen or card, and create a new block for new pages to keep tasks isolated when navigating to other screens.

Connects the task block to the homepage and uses block builder to rebuild the UI as the selected category changes, emitting states on tap to show done or pending tasks.

Tap the category card to dispatch a select category event to the bloc, update the selected category, and trigger a bloc builder to rebuild with updated todos, pending, and done.

Compute and display the number of tasks per category in a Flutter BLoC app, filtering by category and status, and show the result in the category card.

Learn to build scalable Flutter apps with bloc by implementing a dynamic to-do list that filters tasks by selected category and handles empty states.

Explore adding a task bloc in a Flutter BLoC app, building UI for todos, and managing state with task status (pending, done), form status (initial, success, error), and is loading.

Use the copy with function pattern to standardize block state handling, ensuring the status and new block state are both done across blocks.

Implement the add task bloc to handle change task value, change task status, and submit events using the task repository to add new tasks and show loading during submission.

Wrap up the bloc by wiring task view to the task block and pass the task repository via GetIt, deriving color and text from task status with a reusable function.

Tap the todo button to reveal an outline only when it is selected. Use a gesture detector to dispatch a change task status event between to do, pending, and done.

Implement and test adding a new task in a Bloc-based app using a text form field, change task value events, submit handling, and automatic navigation on success.

Learn to implement the equitable package in Flutter to compare add task state objects by their properties, using props and override for accurate state equality across memory addresses.

Learn how to implement a delete task feature in a Flutter app using BLoC, dispatch delete task events with a task id, and update the home page and task card.

Edit an existing task within a Flutter app using BLoC by passing a nullable task to the edit page, initializing the text input, and updating status and details on submit.

Learn to structure Flutter apps by separating user interface into folders, create an internal task repository package, and implement dependency injection with bloc, bloc builder, and listeners.

Learn to bootstrap scalable flutter apps using a starter cli with bloc integration, featuring localization, logging, tests, and a consistent folder structure, and how to install the tool.

Explore scaffolding a Flutter app using the very good cli starter template, including multiple flavors (development and production), localization setup, bloc state logging, and a modular pages structure.

Learn how to implement light and dark themes in a flutter app by configuring ThemeData brightness, wiring a theme cubit with BlocBuilder, and auto updating the UI through state changes.

Create a theme system with an abstract app theme and light and dark subclasses, switch by brightness, and apply background and text colors including the primary color.

Learn to build a Flutter app with a bottom navigation bar and an indexed stack, and manage the tab state with a BLoC.

Apply indexed stack navigation with a home tab bloc, start at index zero, handle change tap events to emit a new index, and render updates via a bloc builder.

Explore adding BlocBuilder to connect the navigation bar to the home tab block state, syncing state.index with tab changes and preserving navigation across tabs.

Implement onGenerateRoute in a Flutter BLoC app by creating a router file with global navigation keys, route names, and material page routes for multiple pages, including a default invalid route.

Learn to implement Flutter navigation using a navigator widget, app router, and nav key to set the app home and enable navigate widget transitions.

Learn to implement nested navigation in Flutter using the navigator widget, initial route and navigator key, with separate home, notifications, and settings tabs whose navigation persists across tab switches.

Build a Flutter API client, set up base URLs and paths, and integrate API requests with token support. Define data state models for success and error to manage responses.

Create an auth repo for a Flutter app, wire the API client and storage, implement sign up and login, token persistence, and logout with models and exports.

Register a locator with get_it to perform dependency injection, and register storage, api client, and repositories as singletons. Initialize dependencies in the bootstrap before runApp for app-wide access.

Explore building a register flow using form validation with formz in flutter, wiring email and password inputs to a register block while running and testing a backend server.

Develop a register BLoC by defining register state with email input, password input, and form submission status, plus a copyWith function and three events: change email, change password, and submit.

Wrap the register view with a bloc provider, dispatch onChanged for email and password, and use a static get error message to display validation errors from the block state.

Add a bloc listener on the register screen to show a snackbar for submission errors and success, including user created successfully please login, and display a loading indicator during submission.

Develop a login screen in a flutter app using bloc, with email and password inputs, login event, form validation and loading indicator, and navigate to the home page on success.

Build a Flutter bloc for home notifications, extract a notification card widget, and implement a get notifications event to fetch data from the API.

Build a home screen with bloc by wiring notifications, a list view builder, and a refresh indicator, plus a get notifications event and splash auto redirect.

Convert the splash screen to a stateful widget and use init state to add a brief delay, then navigate to home screen if signed in, or to login screen.

Review the section contents: running the backend server, accessing the public repo and resources, and practicing login, sign up, splash screen behavior, and notifications.