Flutter Design Patterns and Best Practices Build Scalable, Maintainable, and Production-Ready Apps Using Effective Architectural Principles
Elevate your mobile app development skills using reusable software development methodologies and code design principles, leveraging proven strategies from industry experts who have fostered thriving developer communities Key Features Cover code structure, app architecture, testing, performance optim...
| Otros Autores: | , , |
|---|---|
| Formato: | Libro electrónico |
| Idioma: | Inglés |
| Publicado: |
Birmingham, England :
Packt Publishing
[2024]
|
| Edición: | First edition |
| Materias: | |
| Ver en Biblioteca Universitat Ramon Llull: | https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009853383706719 |
Tabla de Contenidos:
- 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.
