fluttery_framework 4.4.0

Provides all the functions and features needed for a typical production app.

Fluttery Framework

A Framework for Flutter's Framework

Allows for faster and easier development with better maintainability. It looks like Flutter and works like Flutter. There's no 're-inventing of the wheel' or an extra learning curve. If you know Flutter, you'll know Fluttery Framework.

It supplies the adaptive functions and features expected of a production-ready app:

• Flutter's own intuitive State Management
• An extended version of Flutter's State class
• A State Object Controller for this new State class
• Additional error handling capabilities
• Easy implementation of both the Material & Cupertino interface
• App-wide accessibility to system preferences
• Built-in app notifications
• A better menu bar
• Event handling for the device the app runs on
• A date picker
• A color theme picker
• An array of dialog windows
• A customizable bottom bar
• A loading screen option

Installing

Instead of using version number suggested in the 'Installing' page, always go up to the 'minor' semantic version number when installing this library package. This means always having a trailing zero, '.0'. This allows you to take in any 'patch' versions that involves bugfixes. For example, when installing version 7.9.2, use 7.9.0. That means, the bug fix, 7.9.3, will be installed the next time you 'upgrade' your dependencies.

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:

Fluttery Framework

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 or Cupertino) 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 fully implemented.

When I first started working with Flutter, I began keeping modular bits of code from past projects that generally accelerated the development process. I’d use those 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 is the result of this practice. The Fluttery Framework uses packages, functions, and features, 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 few years.

For example, if you know GetX and its many extensions, you’ll know Fluttery’s extensions as well. Jonny Borges, the author of GetX, did a great job providing these extensions! They’ve proven to be indispensable when writing a production-ready app. As for GetX itself, it never became my chosen approach, but I did like his extensions, and so I took them to be used in the Fluttery Framework…accompanied by Jonny’s MIT license of course.

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 Fluttery Framework:

• connectivity_plus
• device_info_plus
• flutter_localizations
• flutter_material_color_picker
• go_router (but not before discovering how to fix it)
• http
• l10n_translator
• package_info_plus
• path_provider
• prefs
• sizer
• state_extended
• 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. This is a framework after all. It’s 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. The purpose of all this is so you supply that specific code while the Fluttery Framework supplies the rest.

Again, as a framework, it also offers a structured approach to making a production-worthy app. It offers a way of doing things. For we Flutter developers, a ready means to access a State object’s setState() function is of particular interest. With that, Fluttery Framework's 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.

However, 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 five years of working with Flutter. It looks like Flutter and works like Flutter because it works with Flutter as well as sound Dart and Flutter packages from the Flutter community.