Flutter Design Patterns and Best Practices

Cover
Title_Page
Copyright and Credits
Contributors
Table of Contents
Preface
Part 1: Building Delightful User Interfaces
Chapter 1: Best Practices for Building UIs with Flutter
	Understanding the difference between declarative and imperative UI design
		Understanding the imperative paradigm
		Understanding the declarative paradigm
		Does Flutter use the declarative or imperative paradigm?
	Everything is a widget! Or is it?
		What is a widget?
		Getting to know the RenderObjectWidget and its children
		Unveiling the Element class
	Reduce, reuse, recycle!
		Pushing rebuilds down the tree
		Avoiding redundant rebuilds
		Avoiding redundant repaints
		Optimizing scroll view performance
	Summary
Chapter 2: Responsive UIs for All Devices
	Technical requirements
	Understanding the Flutter layout algorithm
		Understanding BoxConstraints
		How do constraints determine the child widget’s size?
		Understanding the limitations of the layout rule
	Designing responsive apps with Flutter
		Getting to know the user’s device with MediaQuery
		Creating adaptive layouts
		Positioning widgets relative to each other
		Building flexible layouts
		Scrollable items
		Other layouts
	Ensuring accessibility in Flutter apps
		Getting to know accessibility widgets in Flutter
		Font size and color contrast
		Dev tooling for accessibility
		Manual review
	Summary
Part 2: Connecting UI with Business Logic
Chapter 3: Vanilla State Management
	Technical requirements
		What is state?
		Understanding the difference between ephemeral and app state
	Getting to know our Candy Store app
	Managing state the vanilla Flutter way
	Lifting the state up
		Understanding the Observer pattern
	Passing around dependencies via InheritedWidget
		What is InheritedWidget?
		Understanding the .of(context) pattern
		Creating the CartProvider class
	Interacting with BuildContext in the right place, at the right time
		What is BuildContext?
		Context does not contain the widget
		Context contains the widget, but not the one you expect
		Context accessed too early!
		Context accessed too late!
	Summary
Chapter 4: State Management Patterns and Their Implementations
	Technical requirements
	Diving into the world of MVX patterns
	Defining criteria for the state management pattern
	Embracing data binding with MVVM in Flutter
		Extracting data logic into the Model
		Emitting data via the Streams API
		Encapsulating state in CartState
	Implementing the MVVM and MVI patterns with flutter_bloc
		What is a cubit?
		Understanding the MVI pattern
		Implementing MVI with BLoC
		Embracing the UDF pattern
	Implementing the Segmented State Pattern
	Avoiding bugs related to state equality and mutability
	Summary
Chapter 5: Creating Consistent Navigation
	Technical requirements
	Getting started with navigation basics in Flutter
		Understanding Navigator 1.0 and routes
	Leveling up with advanced navigation techniques
		Navigator 2.0 and declarative routing
	Comparing Navigation 1.0 and 2.0
	Summary
Part 3: Exploring Practical Design Patterns and Architecture Best Practices
Chapter 6: The Responsible Repository Pattern
	Technical requirements
	Introducing the repository pattern
		How the repository pattern works
	Setting up our first repository
		Defining responsibilities
		Creating our first repository
	Defining repository interfaces
		Why use repository interfaces?
		Implementing repository interfaces
	Building a data source
		Repository interfaces and data sources
		Setting up remote data sources
		Integrating NetworkProductRepository
	Creating a local database using Hive
		Adding Hive to your project
		Creating a local data source
		Repository interfaces
	Implementing repository data retrieval
		Enhancing our product repository
		Integrating the repository
	Integrating the repository with our business logic
	Caching strategies
		Caching strategy
	Implementing offline mode
	Understanding data synchronization
		Implementing data synchronization
		Automating synchronization
		Refactoring the CartModel
	Summary
Chapter 7: Implementing the Inversion of Control Principle
	Technical requirements
	Decoupling dependency creation from usage
		Identifying the singleton pattern
		Introducing the IoC principle
	Implementing the DI pattern via RepositoryProvider
		Injecting dependencies via a constructor
		Providing dependencies via RepositoryProvider
	Implementing SL pattern via get_it
		Bonus tip – using injectable
		Selecting the right tool for the job
	Summary
Chapter 8: Ensuring Scalability and Maintainability with Layered Architecture
	Technical requirements
	Exploring layered architecture
		Introducing multitier architecture layers
		Implementing multitier architecture in the Candy Store app
	Defining layers and features
		Implementing layer-first architecture
		Implementing feature-first architecture
		Exploring file structure organization in Flutter
		Scoping dependencies to a feature life cycle
		How to connect multiple data sources
	Following software design principles
		Deciphering the acronyms of SOLID, DRY, KISS, and YAGNI
	Summary
Chapter 9: Mastering Concurrent Programming in Dart
	Technical requirements
	Dart is single-threaded. Or is it?
		Understanding synchronous, concurrent, and parallel operations
		What is the event loop?
		Understanding blocking operations in Flutter
	Working with Future APIs in Dart
		What does the Future hold?
		Understanding the concept of async
		To chain Futures or to await, that is the question
		Handling independent Futures efficiently
	Embracing parallelism with isolates
		Implementing fuzzy search in the Candy Store app
		Understanding the concept of isolates
	Summary
Chapter 10: A Bridge to the Native Side of Development
	Technical requirements
	Understanding Flutter app architecture
		Diving into the Flutter framework layers
		How does Flutter communicate with the native layer?
		Encoding data with MessageCodec
	Working with platform channels
		Selecting the platform channel type
		Implementing the UI of the Favorites feature
		Using MethodChannel for favoriting items
		Understanding Kotlin
		Understanding Swift
		Overviewing the problems introduced by vanilla MethodChannel channels
	Ensuring type-safe communication via pigeon code generation
		Configuring a pigeon interface
		Connecting client and host via pigeon-generated code
		What else you can (and can’t) do with pigeon
	Summary
Part 4: Ensuring App Quality and Stability
Chapter 11: Unit Tests, Widget Tests, and Mocking Dependencies
	Technical requirements
	Getting started with unit testing
		Introducing a fake repository
		Creating test data
		Writing unit tests
	Widget testing fundamentals
		Implementing a golden file test
		Creating the CandyShopGoldenTestWidgetsPage widget
		Writing widget tests
	Integration testing fundamentals
		Creating a fake repository
		Displaying an item in the cart test
		Creating the widget test with interaction
	Mocking dependencies for effective testing
		Understanding mocking and mockito
		Writing the unit test with mockito
	Summary
Chapter 12: Static Code Analysis and Debugging Tools
	Technical requirements
	Following coding conventions
		Using the dart format command
		Following the Effective Dart conventions
	Ensuring consistency and preventing bugs with static code analysis
		Customizing lint rule list in analysis_options.yaml
		Exploring lint setup strategies
		Using the DCM tool
		Creating custom lints
	Exploring debugging practices and tools
		Logging – the good, the bad, and the ugly
		Using assertions to catch errors in debug mode
		Debugging code with breakpoints
		Diving into the world of Flutter DevTools
	Summary
Index
Other Books You May Enjoy