دانلود کتاب Flutter Design Patterns and Best Practices: Build scalable, maintainable, and production-ready apps using effective

فهرست مطالب :

Flutter Design Patterns and Best Practices
Contributors
About the authors
About the reviewer
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Share Your Thoughts
Download a free PDF copy of this book
Part 1: Building Delightful User Interfaces
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
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
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
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
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
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
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
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
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
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
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
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
Why subscribe?
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts
Download a free PDF copy of this book