Fluttery Framework
A Framework for Flutter's Framework
Allows for faster and easier development with better maintainability. It looks like Flutter because it works like Flutter.
There's no 're-inventing of the wheel' here.
If you know Flutter, you'll know how to use this.
It supplies the adaptive functions and features expected of a production-ready app:
- An extended version of the State class offering a built-in FutureBuilder or InheritedWidget.
- A State Object Controller class for its version of the State class
- Built-in responsive interface capability utilizing the package, Sizer
- Essential error handling capabilities
- Easy implementation of both the Material & Cupertino interface for one app That means one app but with both an Android and iOS interface.
- App-wide accessibility to system preferences
- A better menu bar
- 27 device event-handlers
- A loading screen option
- An array of dialog windows
- A customizable bottom bar
Fluttery Framework Documentation
- Get started
- StateX class
- State Object Controller
- AppState class
- App's Preferences
- App object
- Error handling
- Testing
- Extensions
- Device Information
Free overview article on medium.com:
As great as Flutter is, you will not create a ‘production-worthy’ app using Flutter right out of the box. When building a Flutter app, it’s expected to be one codebase that runs on an Android phone, an iOS phone, on Windows, on Linux, and or on the Web---and to do so seamlessly. It is to display the appropriate design interface (Material, Cupertino, etc.) depending on the platform it’s running on, it is to have a responsive interface that displays its information correctly no matter the screen size of the device or platform, and it is to fail gracefully if and when it encounters an error. Flutter right out of the box does not have these capabilities. Until now.
When I first started working with Flutter, I began keeping modular bits of code from past projects that generally accelerated the development process. I would use these again and again in future apps---building up a toolkit as we developers often do. Libraries of tried and tested bits of software that I can later put together to reliably supply a particular function or feature. Over time, I turned to the Flutter community for such libraries, and again, if I didn’t find one I liked, I wrote my own:
The Fluttery Framework uses packages you will likely need in your own apps. It's a collection of software that's proven to be effective solutions to those capabilities required time and time again by a typical real-world app. It’s an amalgamation of what's great about Flutter and what the Flutter community has contributed over the last years. For example, GetX never became a chosen approach for me, but I did like Jonny Borges' many extensions, and so I took them to be used in the Fluttery package--with Jonny’s MIT license of course. They’ve proven to be indispensable when writing a production-ready app.
The extensions alone are reason enough to use this package frankly:
- extensions_view.dart
- context_extensions.dart
- double_extensions.dart
- duration_extensions.dart
- dynamic_extensions.dart
- gorouter_extension.dart
- num_extensions.dart
- string_extensions.dart
- widget_extensions.dart
As the years went by, I found packages that made my life easier and so they too were incorporated into the Fluttery Framework:
- connectivity_plus
- device_info_plus
- flutter_localizations
- flutter_material_color_picker
- go_router (but not before discovering how to fix it)
- http
- package_info_plus
- path_provider
- sizer
- timezone
- universal_io
- universal_platform
- url_launcher
- url_strategy
- uuid
- intl
I was careful to choose only packages that fulfill the general requirements of a typical app. I didn’t choose those too specific and only suitable for a particular problem domain. After all, this is to serve as a ‘general framework’ for all my apps no matter how diverse each is. Of course, for your specific app with its specific needs, you then will add additional packages or write your own. You supply the specific code; the Fluttery Framework supplies the rest.
Such a framework is to offer a structured approach to making a production-worthy app. For we Flutter developers in particular, a ready means to access a State object’s setState() function is of interest. With that, Fluttery own unique contribution to this package is the concept of a ‘State Object Controller.’ The use of controllers are nothing new to Flutter. It uses controllers in a number of its widgets. I realized that having a controller object working with a State object would only enhance the development process. It would encourage a separation of an app’s interface from its event handling and business rules promoting a clean architecture.
The Fluttery Framework is a culmination of sound Dart and Flutter packages from the Flutter community. Unlike other options out there, it works with Flutter; not on top of it as a separate approach.
Libraries
- controller/app
- controller/device_info
- controller/error_handler
- controller/handle_error
- controller/platforms/run_app
- controller/platforms/run_webapp
- model/assets
- model/files
- model/hash
- model/installfile
- view/app
- view/app/app_appstate
- view/app_state
- view/app_statefulwidget
- view/run_app
- view/utils/app_settings
- view/utils/gorouter_extension
- view/utils/radiobutton_widget