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