id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
de6d0c61b45b-2 | Manual serialization
Automated serialization using code generation
Different projects come with different complexities and use cases.
For smaller proof-of-concept projects or quick prototypes,
using code generators might be overkill.
For apps with several JSON models with more complexity,
encoding by hand can quickly become tedious, repetitive,
and lend itself to many small errors.
Use manual serialization for smaller projects
Manual JSON decoding refers to using the built-in JSON decoder in
dart:convert. It involves passing the raw JSON string to the jsonDecode()
function, and then looking up the values you need in the resulting
Map<String, dynamic>.
It has no external dependencies or particular setup process,
and it’s good for a quick proof of concept. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-3 | Manual decoding does not perform well when your project becomes bigger.
Writing decoding logic by hand can become hard to manage and error-prone.
If you have a typo when accessing a nonexistent JSON
field, your code throws an error during runtime.
If you do not have many JSON models in your project and are
looking to test a concept quickly,
manual serialization might be the way you want to start.
For an example of manual encoding, see
Serializing JSON manually using dart:convert.
Use code generation for medium to large projects
JSON serialization with code generation means having an external library
generate the encoding boilerplate for you. After some initial setup,
you run a file watcher that generates the code from your model classes.
For example, json_serializable and built_value are these
kinds of libraries. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-4 | This approach scales well for a larger project. No hand-written
boilerplate is needed, and typos when accessing JSON fields are caught at
compile-time. The downside with code generation is that it requires some
initial setup. Also, the generated source files might produce visual clutter
in your project navigator.
You might want to use generated code for JSON serialization when you have a
medium or a larger project. To see an example of code generation based JSON
encoding, see Serializing JSON using code generation libraries.
Is there a GSON/Jackson/Moshi equivalent in Flutter?
The simple answer is no.
Such a library would require using runtime reflection, which is disabled in
Flutter. Runtime reflection interferes with tree shaking, which Dart has
supported for quite a long time. With tree shaking, you can “shake off” unused
code from your release builds. This optimizes the app’s size significantly. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-5 | Since reflection makes all code implicitly used by default, it makes tree
shaking difficult. The tools cannot know what parts are unused at runtime, so
the redundant code is hard to strip away. App sizes cannot be easily optimized
when using reflection.
Although you cannot use runtime reflection with Flutter,
some libraries give you similarly easy-to-use APIs but are
based on code generation instead. This
approach is covered in more detail in the
code generation libraries section.
Serializing JSON manually using dart:convert
Basic JSON serialization in Flutter is very simple. Flutter has a built-in
dart:convert library that includes a straightforward JSON encoder and
decoder.
The following sample JSON implements a simple user model.
With dart:convert,
you can serialize this JSON model in two ways.
Serializing JSON inline | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-6 | Serializing JSON inline
By looking at the dart:convert documentation,
you’ll see that you can decode the JSON by calling the
jsonDecode() function, with the JSON string as the method argument.
Unfortunately, jsonDecode() returns a Map<String, dynamic>, meaning
that you do not know the types of the values until runtime. With this approach,
you lose most of the statically typed language features: type safety,
autocompletion and most importantly, compile-time exceptions. Your code will
become instantly more error-prone.
For example, whenever you access the name or email fields, you could quickly
introduce a typo. A typo that the compiler doesn’t know about since the
JSON lives in a map structure.
Serializing JSON inside model classes
Combat the previously mentioned problems by introducing a plain model
class, called User in this example. Inside the User class, you’ll find:
A User.fromJson() constructor, for constructing a new User instance from a
map structure. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-7 | A toJson() method, which converts a User instance into a map.
With this approach, the calling code can have type safety,
autocompletion for the name and email fields, and compile-time exceptions.
If you make typos or treat the fields as ints instead of Strings,
the app won’t compile, instead of crashing at runtime.
user.dart
The responsibility of the decoding logic is now moved inside the model
itself. With this new approach, you can decode a user easily.
To encode a user, pass the User object to the jsonEncode() function.
You don’t need to call the toJson() method, since jsonEncode()
already does it for you. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-8 | With this approach, the calling code doesn’t have to worry about JSON
serialization at all. However, the model class still definitely has to.
In a production app, you would want to ensure that the serialization
works properly. In practice, the User.fromJson() and User.toJson()
methods both need to have unit tests in place to verify correct behavior.
The cookbook contains a more comprehensive worked example of using
JSON model classes, using an isolate to parse
the JSON file on a background thread. This approach is ideal if you
need your app to remain responsive while the JSON file is being
decoded.
However, real-world scenarios are not always that simple.
Sometimes JSON API responses are more complex, for example since they
contain nested JSON objects that must be parsed through their own model
class.
It would be nice if there were something that handled the JSON encoding
and decoding for you. Luckily, there is!
Serializing JSON using code generation libraries | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-9 | Serializing JSON using code generation libraries
Although there are other libraries available, this guide uses
json_serializable, an automated source code generator that
generates the JSON serialization boilerplate for you.
Flutter Favorite packages
on pub.dev that generate JSON serialization code,
json_serializable and
built_value.
How do you choose between these packages?
The
Since the serialization code is not handwritten or maintained manually
anymore, you minimize the risk of having JSON serialization exceptions at
runtime.
Setting up json_serializable in a project
To include json_serializable in your project, you need one regular
dependency, and two dev dependencies. In short, dev dependencies
are dependencies that are not included in our app source code—they
are only used in the development environment.
The latest versions of these required dependencies can be seen by
following the pubspec file in the JSON serializable example.
pubspec.yaml | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-10 | pubspec.yaml
dependencies
# Your other regular dependencies here
json_annotation
<latest_version>
dev_dependencies
# Your other dev_dependencies here
build_runner
<latest_version>
json_serializable
<latest_version>
Run flutter pub get inside your project root folder
(or click Packages get in your editor)
to make these new dependencies available in your project.
Creating model classes the json_serializable way
The following shows how to convert the User class to a
json_serializable class. For the sake of simplicity,
this code uses the simplified JSON model
from the previous samples.
user.dart
With this setup, the source code generator generates code for encoding
and decoding the name and email fields from JSON. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-11 | If needed, it is also easy to customize the naming strategy.
For example, if the API returns objects with snake_case,
and you want to use lowerCamelCase in your models,
you can use the @JsonKey annotation with a name parameter:
/// Tell json_serializable that "registration_date_millis" should be
/// mapped to this property.
@JsonKey
name:
'registration_date_millis'
final
int
registrationDateMillis
It’s best if both server and client follow the same naming strategy.
@JsonSerializable() provides fieldRename enum for totally converting dart
fields into JSON keys.
Modifying @JsonSerializable(fieldRename: FieldRename.snake) is equivalent to
adding @JsonKey(name: '<snake_case>') to each field. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-12 | Sometimes server data is uncertain, so it is necessary to verify and protect data
on client.
Other commonly used @JsonKey annotations include:
/// Tell json_serializable to use "defaultValue" if the JSON doesn't
/// contain this key or if the value is `null`.
@JsonKey
defaultValue:
false
final
bool
isAdult
/// When `true` tell json_serializable that JSON must contain the key,
/// If the key doesn't exist, an exception is thrown.
@JsonKey
required
true
final
String
id
/// When `true` tell json_serializable that generated code should
/// ignore this field completely.
@JsonKey
ignore:
true
final | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-13 | ignore:
true
final
String
verificationCode
Running the code generation utility
When creating json_serializable classes the first time,
you’ll get errors similar to what is shown in the image below.
These errors are entirely normal and are simply because the generated code for
the model class does not exist yet. To resolve this, run the code
generator that generates the serialization boilerplate.
There are two ways of running the code generator.
One-time code generation
By running flutter pub run build_runner build --delete-conflicting-outputs in the project root,
you generate JSON serialization code for your models whenever they are needed.
This triggers a one-time build that goes through the source files, picks the
relevant ones, and generates the necessary serialization code for them. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-14 | While this is convenient, it would be nice if you did not have to run the
build manually every time you make changes in your model classes.
Generating code continuously
A watcher makes our source code generation process more convenient. It
watches changes in our project files and automatically builds the necessary
files when needed. Start the watcher by running
flutter pub run build_runner watch --delete-conflicting-outputs in the project root.
It is safe to start the watcher once and leave it running in the background.
Consuming json_serializable models
To decode a JSON string the json_serializable way,
you do not have actually to make any changes to our previous code.
The same goes for encoding. The calling API is the same as before. | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-15 | The same goes for encoding. The calling API is the same as before.
With json_serializable,
you can forget any manual JSON serialization in the User class.
The source code generator creates a file called user.g.dart,
that has all the necessary serialization logic.
You no longer have to write automated tests to ensure
that the serialization works—it’s now
the library’s responsibility to make sure the serialization works
appropriately.
Generating code for nested classes
You might have code that has nested classes within a class.
If that is the case, and you have tried to pass the class in JSON format
as an argument to a service (such as Firebase, for example),
you might have experienced an Invalid argument error.
Consider the following Address class:
The Address class is nested inside the User class: | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-16 | The Address class is nested inside the User class:
Running
flutter pub run build_runner build --delete-conflicting-outputs
in the terminal creates
the *.g.dart file, but the private _$UserToJson() function
looks something like the following:
Map
String
dynamic
_$UserToJson
User
instance
String
dynamic
>{
'name'
instance
name
'address'
instance
address
};
All looks fine now, but if you do a print() on the user object:
The result is:
name:
John
address:
Instance
of
'address' | https://docs.flutter.dev/development/data-and-backend/json/index.html |
de6d0c61b45b-17 | Instance
of
'address'
When what you probably want is output like the following:
name:
John
address:
street:
My
st.
city:
New
York
}}
To make this work, pass explicitToJson: true in the @JsonSerializable()
annotation over the class declaration. The User class now looks as follows:
For more information, see explicitToJson in the
JsonSerializable class for the json_annotation package.
Further references
For more information, see the following resources:
The dart:convert and JsonCodec documentation
The json_serializable package on pub.dev
The json_serializable examples on GitHub | https://docs.flutter.dev/development/data-and-backend/json/index.html |
4f3f0c961955-0 | Networking
Data & backend
Networking
Cross-platform http networking
Platform notes
Android
macOS
Samples
Cross-platform http networking
The http package provides the simplest way to issue http requests. This
package is supported on Android, iOS, macOS, Windows, Linux and the web.
Platform notes
Some platforms require additional steps, as detailed below.
Android
Android apps must declare their use of the internet in the Android
manifest (AndroidManifest.xml ):
macOS
macOS apps must allow network access in the relevant .entitlements files.
Learn more about setting up entitlements.
Samples
For a practical sample of various networking tasks (incl. fetching data,
WebSockets, and parsing data in the background) see the
networking cookbook. | https://docs.flutter.dev/development/data-and-backend/networking/index.html |
6d4998fdd451-0 | Intro
Ephemeral versus app state
Start thinking declaratively
Data & backend
State management
Start thinking declaratively
If you’re coming to Flutter from an imperative framework
(such as Android SDK or iOS UIKit), you need to start
thinking about app development from a new perspective.
Many assumptions that you might have don’t apply to Flutter. For example, in
Flutter it’s okay to rebuild parts of your UI from scratch instead of modifying
it. Flutter is fast enough to do that, even on every frame if needed.
Flutter is declarative. This means that Flutter builds its user interface to
reflect the current state of your app: | https://docs.flutter.dev/development/data-and-backend/state-mgmt/declarative/index.html |
6d4998fdd451-1 | When the state of your app changes
(for example, the user flips a switch in the settings screen),
you change the state, and that triggers a redraw of the user interface.
There is no imperative changing of the UI itself
(like widget.setText)—you change the state,
and the UI rebuilds from scratch.
Read more about the declarative approach to UI programming
in the get started guide.
The declarative style of UI programming has many benefits.
Remarkably, there is only one code path for any state of the UI.
You describe what the UI should look
like for any given state, once—and that is it.
At first,
this style of programming might not seem as intuitive as the
imperative style. This is why this section is here. Read on.
Intro
Ephemeral versus app state | https://docs.flutter.dev/development/data-and-backend/state-mgmt/declarative/index.html |
4a586bd4a152-0 | Start thinking declaratively
Simple app state management
Differentiate between ephemeral state and app state
Data & backend
State management
Differentiate between ephemeral state and app state
Ephemeral state
App state
There is no clear-cut rule
This doc introduces app state, ephemeral state,
and how you might manage each in a Flutter app.
In the broadest possible sense, the state of an app is everything that
exists in memory when the app is running. This includes the app’s assets,
all the variables that the Flutter framework keeps about the UI,
animation state, textures, fonts, and so on. While this broadest
possible definition of state is valid, it’s not very useful for
architecting an app. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
4a586bd4a152-1 | First, you don’t even manage some state (like textures).
The framework handles those for you. So a more useful definition of
state is “whatever data you need in order to rebuild your UI at any
moment in time”. Second, the state that you do manage yourself can
be separated into two conceptual types: ephemeral state and app state.
Ephemeral state
Ephemeral state (sometimes called UI state or local state)
is the state you can neatly contain in a single widget.
This is, intentionally, a vague definition, so here are a few examples.
current page in a PageView
current progress of a complex animation
current selected tab in a BottomNavigationBar
Other parts of the widget tree seldom need to access this kind of state.
There is no need to serialize it, and it doesn’t change in complex ways. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
4a586bd4a152-2 | In other words, there is no need to use state management techniques
(ScopedModel, Redux, etc.) on this kind of state.
All you need is a StatefulWidget.
Below, you see how the currently selected item in a bottom navigation bar is
held in the _index field of the _MyHomepageState class.
In this example, _index is ephemeral state.
Here, using setState() and a field inside the StatefulWidget’s State
class is completely natural. No other part of your app needs to access
_index. The variable only changes inside the MyHomepage widget.
And, if the user closes and restarts the app,
you don’t mind that _index resets to zero.
App state
State that is not ephemeral,
that you want to share across many parts of your app,
and that you want to keep between user sessions,
is what we call application state
(sometimes also called shared state).
Examples of application state: | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
4a586bd4a152-3 | Examples of application state:
User preferences
Login info
Notifications in a social networking app
The shopping cart in an e-commerce app
Read/unread state of articles in a news app
For managing app state, you’ll want to research your options.
Your choice depends on the complexity and nature of your app,
your team’s previous experience, and many other aspects. Read on.
There is no clear-cut rule
To be clear, you can use State and setState() to manage all of
the state in your app. In fact, the Flutter team does this in many
simple app samples (including the starter app that you get with every
flutter create). | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
4a586bd4a152-4 | It goes the other way, too. For example, you might decide that—in
the context of your particular app—the selected tab in a bottom
navigation bar is not ephemeral state. You might need to change it
from outside the class, keep it between sessions, and so on.
In that case, the _index variable is app state.
There is no clear-cut, universal rule to distinguish
whether a particular variable is ephemeral or app state.
Sometimes, you’ll have to refactor one into another.
For example, you’ll start with some clearly ephemeral state,
but as your application grows in features,
it might need to be moved to app state.
For that reason, take the following diagram with a large grain of salt:
When asked about React’s setState versus Redux’s store, the author of Redux,
Dan Abramov, replied:
“The rule of thumb is: Do whatever is less awkward.” | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
4a586bd4a152-5 | “The rule of thumb is: Do whatever is less awkward.”
In summary, there are two conceptual types of state in any Flutter app.
Ephemeral state can be implemented using State and setState(),
and is often local to a single widget. The rest is your app state.
Both types have their place in any Flutter app, and the split between
the two depends on your own preference and the complexity of the app.
Start thinking declaratively
Simple app state management | https://docs.flutter.dev/development/data-and-backend/state-mgmt/ephemeral-vs-app/index.html |
da9325f90071-0 | State management
Data & backend
State management
Topics:
Introduction
Think declaratively
Ephemeral vs app state
Simple app state management
Options | https://docs.flutter.dev/development/data-and-backend/state-mgmt/index.html |
fb8405030d4b-0 | Start thinking declaratively
State management
Data & backend
State management
State management
If you are already familiar with state management in reactive apps,
you can skip this section, though you might want to review the
list of different approaches.
As you explore Flutter,
there comes a time when you need to share application
state between screens, across your app.
There are many approaches you can take,
and many questions to think about.
In the following pages,
you will learn the basics of dealing with state in Flutter apps.
Start thinking declaratively | https://docs.flutter.dev/development/data-and-backend/state-mgmt/intro/index.html |
96fe42bb37dc-0 | Simple app state management
List of state management approaches
Data & backend
State management
List of state management approaches
General overview
Provider
Riverpod
setState
InheritedWidget & InheritedModel
Redux
Fish-Redux
BLoC / Rx
GetIt
MobX
Flutter Commands
Binder
GetX
states_rebuilder
Triple Pattern (Segmented State Pattern)
solidart
flutter_reactive_widget
State management is a complex topic.
If you feel that some of your questions haven’t been answered,
or that the approach described on these pages
is not viable for your use cases, you are probably right. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-1 | Learn more at the following links,
many of which have been contributed by the Flutter community:
General overview
Things to review before selecting an approach.
Introduction to state management,
which is the beginning of this very section
(for those of you who arrived directly to this Options page
and missed the previous pages)
Pragmatic State Management in Flutter,
a video from Google I/O 2019
Flutter Architecture Samples, by Brian Egan
Provider
Simple app state management, the previous page in this section
Provider package
Riverpod
Riverpod, another good choice, is
similar to Provider and is compile-safe and testable.
Riverpod doesn’t have a dependency on the Flutter SDK.
Riverpod homepage
Getting started with Riverpod
setState | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-2 | Getting started with Riverpod
setState
The low-level approach to use for widget-specific, ephemeral state.
Adding interactivity to your Flutter app, a Flutter tutorial
Basic state management in Google Flutter, by Agung Surya
InheritedWidget & InheritedModel
The low-level approach used to communicate between ancestors and children
in the widget tree. This is what provider and many other approaches
use under the hood.
The following instructor-led video workshop covers how to
use InheritedWidget:
Other useful docs include:
InheritedWidget docs
Managing Flutter Application State With InheritedWidgets,
by Hans Muller
Inheriting Widgets, by Mehmet Fidanboylu
Using Flutter Inherited Widgets Effectively, by Eric Windmill | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-3 | Using Flutter Inherited Widgets Effectively, by Eric Windmill
Widget - State - Context - InheritedWidget, by Didier Bolelens
Redux
A state container approach familiar to many web developers.
Animation Management with Redux and Flutter,
a video from DartConf 2018 Accompanying article on Medium
Flutter Redux package
Redux Saga Middleware Dart and Flutter, by Bilal Uslu
Introduction to Redux in Flutter, by Xavi Rigau
Flutter + Redux—How to make a shopping list app,
by Paulina Szklarska on Hackernoon
Building a TODO application (CRUD) in Flutter with Redux—Part 1,
a video by Tensor Programming
Flutter Redux Thunk, an example, by Jack Wong | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-4 | Flutter Redux Thunk, an example, by Jack Wong
Building a (large) Flutter app with Redux, by Hillel Coren
Fish-Redux–An assembled flutter application framework based on Redux,
by Alibaba
Async Redux–Redux without boilerplate. Allows for both sync and async reducers,
by Marcelo Glasberg
Flutter meets Redux: The Redux way of managing Flutter applications state,
by Amir Ghezelbash
Redux and epics for better-organized code in Flutter apps, by Nihad Delic
Flutter_Redux_Gen - VS Code Plugin to generate boiler plate code, by Balamurugan Muthusamy (BalaDhruv)
Fish-Redux
Fish Redux is an assembled flutter application framework
based on Redux state management.
It is suitable for building medium and large applications. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-5 | Fish-Redux-Library package, by Alibaba
Fish-Redux-Source, project code
Flutter-Movie, A non-trivial example demonstrating how
to use Fish Redux, with more than 30 screens, graphql,
payment api, and media player.
BLoC / Rx
A family of stream/observable based patterns.
Architect your Flutter project using BLoC pattern,
by Sagar Suri
BloC Library, by Felix Angelov
Reactive Programming - Streams - BLoC - Practical Use Cases,
by Didier Boelens
GetIt
A service locator based state management approach that
doesn’t need a BuildContext.
GetIt package, the service locator.
It can also be used together with BloCs.
GetIt Mixin package, a mixin that completes
GetIt to a full state management solution. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-6 | GetIt Hooks package, same as the mixin in
case you already use flutter_hooks.
Flutter state management for minimalists, by Suragch
Note:
To learn more, watch this short Package of the Week video on the GetIt package:
MobX
A popular library based on observables and reactions.
MobX.dart, Hassle free state-management for your Dart and Flutter apps
Getting started with MobX.dart
Flutter: State Management with Mobx, a video by Paul Halliday
Flutter Commands
Reactive state management that uses the Command Pattern
and is based on ValueNotifiers. Best in combination with
GetIt, but can be used with Provider or other
locators too.
Flutter Command package
RxCommand package, Stream based implementation.
Binder | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-7 | RxCommand package, Stream based implementation.
Binder
A state management package that uses InheritedWidget
at its core. Inspired in part by recoil.
This package promotes the separation of concerns.
Binder package
Binder examples
Binder snippets, vscode snippets to be even more
productive with Binder
GetX
A simplified reactive state management solution.
GetX package
Complete GetX State Management, a video by Tadas Petra
GetX Flutter Firebase Auth Example, by Jeff McMorris
states_rebuilder
An approach that combines state management with a
dependency injection solution and an integrated router.
For more information, see the following info:
States Rebuilder project code
States Rebuilder documentation
Triple Pattern (Segmented State Pattern)
Segmented State pattern. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
96fe42bb37dc-8 | Segmented State pattern.
For more information, refer to the following resources:
Triple documentation
Flutter Triple package
Triple Pattern: A new pattern for state management in Flutter
(blog post written in Portuguese but can be auto-translated)
VIDEO: Flutter Triple Pattern by Kevlin Ossada (recorded in English)
solidart
A simple but powerful state management solution inspired by SolidJS.
Official Documentation
solidart package
flutter_solidart package
flutter_reactive_widget
Also includes a definition for PersistentReactiveValue, a subclass
of ReactiveValue whose latest value persists, surviving app
restarts.
flutter_reactive_widget source and documentation
Simple app state management | https://docs.flutter.dev/development/data-and-backend/state-mgmt/options/index.html |
6232898c8832-0 | Ephemeral versus app state
List of approaches
Simple app state management
Data & backend
State management
Simple app state management
Our example
Lifting state up
Accessing the state
ChangeNotifier
ChangeNotifierProvider
Consumer
Provider.of
Putting it all together
Now that you know about declarative UI programming
and the difference between ephemeral and app state,
you are ready to learn about simple app state management.
On this page, we are going to be using the provider package.
If you are new to Flutter and you don’t have a strong reason to choose
another approach (Redux, Rx, hooks, etc.), this is probably the approach
you should start with. The provider package is easy to understand
and it doesn’t use much code.
It also uses concepts that are applicable in every other approach. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-1 | That said, if you have a strong background in
state management from other reactive frameworks,
you can find packages and tutorials listed on the options page.
Our example
For illustration, consider the following simple app.
The app has two separate screens: a catalog,
and a cart (represented by the MyCatalog,
and MyCart widgets, respectively). It could be a shopping app,
but you can imagine the same structure in a simple social networking
app (replace catalog for “wall” and cart for “favorites”).
The catalog screen includes a custom app bar (MyAppBar)
and a scrolling view of many list items (MyListItems).
Here’s the app visualized as a widget tree.
So we have at least 5 subclasses of Widget. Many of them need
access to state that “belongs” elsewhere. For example, each
MyListItem needs to be able to add itself to the cart.
It might also want to see whether the currently displayed item
is already in the cart. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-2 | This takes us to our first question: where should we put the current
state of the cart?
Lifting state up
In Flutter,
it makes sense to keep the state above the widgets that use it.
Why? In declarative frameworks like Flutter, if you want to change the UI,
you have to rebuild it. There is no easy way to have
MyCart.updateWith(somethingNew). In other words, it’s hard to
imperatively change a widget from outside, by calling a method on it.
And even if you could make this work, you would be fighting the
framework instead of letting it help you.
// BAD: DO NOT DO THIS
void
myTapHandler
()
var
cartWidget
somehowGetMyCartWidget
();
cartWidget
updateWith
item
); | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-3 | updateWith
item
);
Even if you get the above code to work,
you would then have to deal
with the following in the MyCart widget:
// BAD: DO NOT DO THIS
Widget
build
BuildContext
context
return
SomeWidget
// The initial state of the cart.
);
void
updateWith
Item
item
// Somehow you need to change the UI from here.
You would need to take into consideration the current state of the UI
and apply the new data to it. It’s hard to avoid bugs this way. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-4 | In Flutter, you construct a new widget every time its contents change.
Instead of MyCart.updateWith(somethingNew) (a method call)
you use MyCart(contents) (a constructor). Because you can only
construct new widgets in the build methods of their parents,
if you want to change contents, it needs to live in MyCart’s
parent or above.
Now MyCart has only one code path for building any version of the UI.
This is what we mean when we say that widgets are immutable.
They don’t change—they get replaced.
Now that we know where to put the state of the cart, let’s see how
to access it.
Accessing the state
When a user clicks on one of the items in the catalog,
it’s added to the cart. But since the cart lives above MyListItem,
how do we do that? | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-5 | A simple option is to provide a callback that MyListItem can call
when it is clicked. Dart’s functions are first class objects,
so you can pass them around any way you want. So, inside
MyCatalog you can define the following:
This works okay, but for an app state that you need to modify from
many different places, you’d have to pass around a lot of
callbacks—which gets old pretty quickly.
Fortunately, Flutter has mechanisms for widgets to provide data and
services to their descendants (in other words, not just their children,
but any widgets below them). As you would expect from Flutter,
where Everything is a Widget™, these mechanisms are just special
kinds of widgets—InheritedWidget, InheritedNotifier,
InheritedModel, and more. We won’t be covering those here,
because they are a bit low-level for what we’re trying to do. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-6 | Instead, we are going to use a package that works with the low-level
widgets but is simple to use. It’s called provider.
Before working with provider,
don’t forget to add the dependency on it to your pubspec.yaml.
name
my_name
description
Blah blah blah.
# ...
dependencies
flutter
sdk
flutter
provider
^6.0.0
dev_dependencies
# ...
Now you can import 'package:provider/provider.dart';
and start building.
With provider, you don’t need to worry about callbacks or
InheritedWidgets. But you do need to understand 3 concepts:
ChangeNotifier
ChangeNotifierProvider
Consumer
ChangeNotifier | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-7 | ChangeNotifierProvider
Consumer
ChangeNotifier
ChangeNotifier is a simple class included in the Flutter SDK which provides
change notification to its listeners. In other words, if something is
a ChangeNotifier, you can subscribe to its changes. (It is a form of
Observable, for those familiar with the term.)
In our shopping app example, we want to manage the state of the cart in a
ChangeNotifier. We create a new class that extends it, like so:
ChangeNotifier {
/// Internal, private state of the cart.
final List<Item> _items = [];
/// An unmodifiable view of the items in the cart.
UnmodifiableListView<Item> get items => UnmodifiableListView(_items);
/// The current total price of all items (assuming all items cost $42).
int get totalPrice => _items.length * 42; | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-8 | /// Adds [item] to cart. This and [removeAll] are the only ways to modify the
/// cart from the outside.
void add(Item item) {
_items.add(item);
// This call tells the widgets that are listening to this model to rebuild.
notifyListeners();
}
/// Removes all items from the cart.
void removeAll() {
_items.clear();
// This call tells the widgets that are listening to this model to rebuild.
notifyListeners();
}
}
The only code that is specific to ChangeNotifier is the call
to notifyListeners(). Call this method any time the model changes in a way
that might change your app’s UI. Everything else in CartModel is the
model itself and its business logic. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-9 | ChangeNotifier is part of flutter:foundation and doesn’t depend on
any higher-level classes in Flutter. It’s easily testable (you don’t even need
to use widget testing for it). For example,
here’s a simple unit test of CartModel:
ChangeNotifierProvider
ChangeNotifierProvider is the widget that provides an instance of
a ChangeNotifier to its descendants. It comes from the provider package.
We already know where to put ChangeNotifierProvider: above the widgets that
need to access it. In the case of CartModel, that means somewhere
above both MyCart and MyCatalog.
You don’t want to place ChangeNotifierProvider higher than necessary
(because you don’t want to pollute the scope). But in our case,
the only widget that is on top of both MyCart and MyCatalog is MyApp.
ChangeNotifierProvider(
create: (context) => CartModel(),
child: const MyApp(),
),
);
} | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-10 | If you want to provide more than one class, you can use MultiProvider:
MultiProvider(
providers: [
ChangeNotifierProvider(create: (context) => CartModel()),
Provider(create: (context) => SomeOtherClass()),
],
child: const MyApp(),
),
);
}
Consumer
Now that CartModel is provided to widgets in our app through the
ChangeNotifierProvider declaration at the top, we can start using it.
This is done through the Consumer widget.
Consumer<CartModel>(
builder: (context, cart, child) {
return Text('Total price: ${cart.totalPrice}');
},
); | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-11 | We must specify the type of the model that we want to access.
In this case, we want CartModel, so we write
Consumer<CartModel>. If you don’t specify the generic (<CartModel>),
the provider package won’t be able to help you. provider is based on types,
and without the type, it doesn’t know what you want.
The only required argument of the Consumer widget
is the builder. Builder is a function that is called whenever the
ChangeNotifier changes. (In other words, when you call notifyListeners()
in your model, all the builder methods of all the corresponding
Consumer widgets are called.)
The builder is called with three arguments. The first one is context,
which you also get in every build method.
The second argument of the builder function is the instance of
the ChangeNotifier. It’s what we were asking for in the first place.
You can use the data in the model to define what the UI should look like
at any given point. | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-12 | The third argument is child, which is there for optimization.
If you have a large widget subtree under your Consumer
that doesn’t change when the model changes, you can construct it
once and get it through the builder.
child) => Stack(
children: [
// Use SomeExpensiveWidget here, without rebuilding every time.
if (
child != null)
child,
Text('Total price: ${cart.totalPrice}'),
],
),
// Build the expensive widget here.
child: const SomeExpensiveWidget(),
);
It is best practice to put your Consumer widgets as deep in the tree
as possible. You don’t want to rebuild large portions of the UI
just because some detail somewhere changed.
Instead:
Provider.of | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-13 | Instead:
Provider.of
Sometimes, you don’t really need the data in the model to change the
UI but you still need to access it. For example, a ClearCart
button wants to allow the user to remove everything from the cart.
It doesn’t need to display the contents of the cart,
it just needs to call the clear() method.
We could use Consumer<CartModel> for this,
but that would be wasteful. We’d be asking the framework to
rebuild a widget that doesn’t need to be rebuilt.
For this use case, we can use Provider.of,
with the listen parameter set to false.
listen: false).removeAll();
Using the above line in a build method won’t cause this widget to
rebuild when notifyListeners is called.
Putting it all together | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
6232898c8832-14 | Putting it all together
You can check out the example covered in this article.
If you want something simpler,
see what the simple Counter app looks like when
built with provider.
By following along with these articles, you’ve greatly
improved your ability to create state-based applications.
Try building an application with provider yourself to
master these skills.
Ephemeral versus app state
List of approaches | https://docs.flutter.dev/development/data-and-backend/state-mgmt/simple/index.html |
42c74e18858f-0 | Background processes
Packages & plugins
Background processes
Have you ever wanted to execute Dart code in the
background—even if your app wasn’t the currently active app?
Perhaps you wanted to implement a process that watches the time,
or that catches camera movement.
In Flutter, you can execute Dart code in the background.
The mechanism for this feature involves setting up an isolate.
Isolates are Dart’s model for multithreading,
though an isolate differs from a conventional thread
in that it doesn’t share memory with the main program.
You’ll set up your isolate for background execution using
callbacks and a callback dispatcher.
Additionally, the WorkManager plugin enables persistent background processing
that keeps tasks scheduled through app restarts and system reboots. | https://docs.flutter.dev/development/packages-and-plugins/background-processes/index.html |
42c74e18858f-1 | For more information and a geofencing example that uses background
execution of Dart code, see the Medium article by Ben Konyi,
Executing Dart in the Background with Flutter Plugins and
Geofencing. At the end of this article,
you’ll find links to example code, and relevant documentation for Dart,
iOS, and Android.
See the Happy paths recommendations for more information
on background processing. | https://docs.flutter.dev/development/packages-and-plugins/background-processes/index.html |
9cbca39b081a-0 | Developing packages & plugins
Packages & plugins
Developing
Package introduction
Package types
Developing Dart packages
Step 1: Create the package
Step 2: Implement the package
Developing plugin packages
Federated plugins
Endorsed federated plugin
Non-endorsed federated plugin
Specifying a plugin’s supported platforms
Federated platform packages
Endorsed implementations
Step 1: Create the package
Step 2: Implement the package | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-1 | Step 1: Create the package
Step 2: Implement the package
Step 2a: Define the package API (.dart)
Step 2b: Add Android platform code (.kt/.java)
Step 2c: Add iOS platform code (.swift/.h+.m)
Step 2d: Add Linux platform code (.h+.cc)
Step 2e: Add macOS platform code (.swift)
Step 2f: Add Windows platform code (.h+.cpp)
Step 2g: Connect the API and the platform code
Add support for platforms in an existing plugin project
Dart platform implementations
Dart-only platform implementations
Hybrid platform implementations
Testing your plugin
Developing FFI plugin packages
Step 1: Create the package
Step 2: Building and bundling native code
Step 3: Binding to native code
Step 4: Invoking native code
Adding documentation | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-2 | Adding documentation
API documentation
Adding licenses to the LICENSE file
Publishing your package
Handling package interdependencies
Android
iOS
Web
Package introduction
Packages enable the creation of modular code that can be shared easily.
A minimal package consists of the following:
A metadata file that declares the package name,
version, author, and so on.
The lib directory contains the public code in
the package, minimally a single <package-name>.dart file.
Note:
For a list of dos and don’ts when writing an effective plugin,
see the Medium article by Mehmet Fidanboylu,
Writing a good plugin.
Package types
Packages can contain more than one kind of content: | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-3 | Package types
Packages can contain more than one kind of content:
General packages written in Dart,
for example the path package.
Some of these might contain Flutter specific
functionality and thus have a dependency on the
Flutter framework, restricting their use to Flutter only,
for example the fluro package.
A specialized Dart package that contains an API written in
Dart code combined with one or more platform-specific
implementations.
Plugin packages can be written for Android
(using Kotlin or Java), iOS (using Swift or Objective-C),
web, macOS, Windows, or Linux, or any combination
thereof.
A concrete example is the url_launcher plugin package.
To see how to use the url_launcher package, and how it
was extended to implement support for web,
see the Medium article by Harry Terkelsen,
How to Write a Flutter Web Plugin, Part 1. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-4 | A specialized Dart package that contains an API written in
Dart code combined with one or more platform-specific
implementations that use Dart FFI(Android, iOS, macOS).
Developing Dart packages
The following instructions explain how to write a Flutter
package.
Step 1: Create the package
To create a starter Flutter package,
use the --template=package flag with flutter create:
flutter create
-template
=package hello
This creates a package project in the hello
folder with the following content:
A (mostly) empty license text file.
The unit tests for the package.
A configuration file used by the IntelliJ IDEs.
A hidden file that tells Git which files or
folders to ignore in a project.
A hidden file used by IDEs to track the properties
of the Flutter project. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-5 | A hidden file used by IDEs to track the properties
of the Flutter project.
A yaml file containing metadata that specifies
the package’s dependencies. Used by the pub tool.
A starter markdown file that briefly describes
the package’s purpose.
A starter app containing Dart code for the package.
A hidden folder containing configuration files
for the IntelliJ IDEs.
A (mostly) empty markdown file for tracking
version changes to the package.
Step 2: Implement the package
For pure Dart packages, simply add the functionality
inside the main lib/<package name>.dart file,
or in several files in the lib directory.
To test the package, add unit tests
in a test directory.
For additional details on how to organize the
package contents,
see the Dart library package documentation.
Developing plugin packages | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-6 | Developing plugin packages
If you want to develop a package that calls into
platform-specific APIs,
you need to develop a plugin package.
The API is connected to the platform-specific
implementation(s) using a platform channel.
Federated plugins
Federated plugins are a way of splitting support for
different platforms into separate packages.
So, a federated plugin can use one package for iOS,
another for Android, another for web,
and yet another for a car (as an example of an IoT device).
Among other benefits, this approach allows a domain expert
to extend an existing plugin to work for the platform they know best.
A federated plugin requires the following packages:
The package that plugin users depend on to use the plugin.
This package specifies the API used by the Flutter app. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-7 | One or more packages that contain the platform-specific
implementation code. The app-facing package calls into
these packages—they aren’t included into an app,
unless they contain platform-specific functionality
accessible to the end user.
The package that glues the app-facing packing
to the platform package(s). This package declares an
interface that any platform package must implement to
support the app-facing package. Having a single package
that defines this interface ensures that all platform
packages implement the same functionality in a uniform way.
Endorsed federated plugin
Ideally, when adding a platform implementation to
a federated plugin, you will coordinate with the package
author to include your implementation.
In this way, the original author endorses your
implementation. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-8 | For example, say you write a foobar_windows
implementation for the (imaginary) foobar plugin.
In an endorsed plugin, the original foobar author
adds your Windows implementation as a dependency
in the pubspec for the app-facing package.
Then, when a developer includes the foobar plugin
in their Flutter app, the Windows implementation,
as well as the other endorsed implementations,
are automatically available to the app.
Non-endorsed federated plugin
If you can’t, for whatever reason, get your implementation
added by the original plugin author, then your plugin
is not endorsed. A developer can still use your
implementation, but must manually add the plugin
to the app’s pubspec file. So, the developer
must include both the foobar dependency and
the foobar_windows dependency in order to achieve
full functionality. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-9 | For more information on federated plugins,
why they are useful, and how they are
implemented, see the Medium article by Harry Terkelsen,
How To Write a Flutter Web Plugin, Part 2.
Specifying a plugin’s supported platforms
Plugins can specify the platforms they support by
adding keys to the platforms map in the
pubspec.yaml file. For example,
the following pubspec file shows the
flutter: map for the hello plugin,
which supports only iOS and Android:
flutter
plugin
platforms
android
package
com.example.hello
pluginClass
HelloPlugin
ios
pluginClass
HelloPlugin
environment
sdk
>=2.1.0
<3.0.0" | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-10 | >=2.1.0
<3.0.0"
# Flutter versions prior to 1.12 did not support the
# flutter.plugin.platforms map.
flutter
>=1.12.0"
When adding plugin implementations for more platforms,
the platforms map should be updated accordingly.
For example, here’s the map in the pubspec file
for the hello plugin,
when updated to add support for macOS and web:
flutter
plugin
platforms
android
package
com.example.hello
pluginClass
HelloPlugin
ios
pluginClass
HelloPlugin
macos
pluginClass
HelloPlugin
web
pluginClass
HelloPlugin
fileName | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-11 | pluginClass
HelloPlugin
fileName
hello_web.dart
environment
sdk
>=2.1.0
<3.0.0"
# Flutter versions prior to 1.12 did not support the
# flutter.plugin.platforms map.
flutter
>=1.12.0"
Federated platform packages
A platform package uses the same format,
but includes an implements entry indicating
which app-facing package it implements. For example,
a hello_windows plugin containing the Windows
implementation for hello
would have the following flutter: map:
flutter
plugin
implements
hello
platforms
windows
pluginClass
HelloPlugin
Endorsed implementations | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-12 | pluginClass
HelloPlugin
Endorsed implementations
An app facing package can endorse a platform package by adding a
dependency on it, and including it as a default_package in the
platforms: map. If the hello plugin above endorsed hello_windows,
it would look as follows:
flutter
plugin
platforms
android
package
com.example.hello
pluginClass
HelloPlugin
ios
pluginClass
HelloPlugin
windows
default_package
hello_windows
dependencies
hello_windows
^1.0.0
Note that as shown here, an app-facing package can have
some platforms implemented within the package,
and others in endorsed federated implementations.
Step 1: Create the package | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-13 | Step 1: Create the package
To create a plugin package, use the --template=plugin
flag with flutter create.
Use the --org option to specify your organization,
using reverse domain name notation. This value is used
in various package and bundle identifiers in the
generated plugin code.
Use the -a option to specify the language for android
or the -i option to specify the language for ios.
Please choose one of the following:
flutter create
-org com.example
-template
=plugin
-platforms
=android,ios,linux,macos,windows
a kotlin hello
flutter create
-org com.example
-template
=plugin
-platforms
=android,ios,linux,macos,windows
a java hello
flutter create | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-14 | a java hello
flutter create
-org com.example
-template
=plugin
-platforms
=android,ios,linux,macos,windows
i objc hello
flutter create
-org com.example
-template
=plugin
-platforms
=android,ios,linux,macos,windows
i swift hello
This creates a plugin project in the hello folder
with the following specialized content:
The Dart API for the plugin.
The Android platform-specific implementation of the plugin API
in Kotlin.
The iOS-platform specific implementation of the plugin API
in Objective-C.
A Flutter app that depends on the plugin,
and illustrates how to use it. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-15 | A Flutter app that depends on the plugin,
and illustrates how to use it.
By default, the plugin project uses Swift for iOS code and
Kotlin for Android code. If you prefer Objective-C or Java,
you can specify the iOS language using -i and the
Android language using -a. For example:
flutter create
-template
=plugin
-platforms
=android,ios
i objc hello
flutter create
-template
=plugin
-platforms
=android,ios
a java hello
Step 2: Implement the package
As a plugin package contains code for several platforms
written in several programming languages,
some specific steps are needed to ensure a smooth experience.
Step 2a: Define the package API (.dart) | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-16 | Step 2a: Define the package API (.dart)
The API of the plugin package is defined in Dart code.
Open the main hello/ folder in your favorite Flutter editor.
Locate the file lib/hello.dart.
Step 2b: Add Android platform code (.kt/.java)
We recommend you edit the Android code using Android Studio.
Then use the following steps:
Launch Android Studio.
Select Open an existing Android Studio Project
in the Welcome to Android Studio dialog,
or select File > Open from the menu,
and select the hello/example/android/build.gradle file.
In the Gradle Sync dialog, select OK.
In the Android Gradle Plugin Update dialog,
select Don’t remind me again for this project.
The Android platform code of your plugin is located in
hello/java/com.example.hello/HelloPlugin. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-17 | You can run the example app from Android Studio by
pressing the run (▶) button.
Step 2c: Add iOS platform code (.swift/.h+.m)
We recommend you edit the iOS code using Xcode.
Before editing the iOS platform code in Xcode,
first make sure that the code has been built at least once
(in other words, run the example app from your IDE/editor,
or in a terminal execute
cd hello/example; flutter build ios --no-codesign).
Then use the following steps:
Launch Xcode.
Select File > Open, and select the
hello/example/ios/Runner.xcworkspace file.
The iOS platform code for your plugin is located in
Pods/Development Pods/hello/../../example/ios/.symlinks/plugins/hello/ios/Classes
in the Project Navigator.
You can run the example app by pressing the run (▶) button. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-18 | You can run the example app by pressing the run (▶) button.
Step 2d: Add Linux platform code (.h+.cc)
We recommend you edit the Linux code using an IDE with
C++ integration. The instructions below are for
Visual Studio Code with the “C/C++” and “CMake” extensions
installed, but can be adjusted for other IDEs.
Before editing the Linux platform code in an IDE,
first make sure that the code has been built at least once
(in other words, run the example app from your Flutter
IDE/editor, or in a terminal execute
cd hello/example; flutter build linux).
Then use the following steps:
Launch Visual Studio Code.
Open the hello/example/linux/ directory.
Choose Yes in the prompt asking:
Would you like to configure project "linux"?.
This will allow C++ autocomplete to work. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-19 | The Linux platform code for your plugin is located in
flutter/ephemeral/.plugin_symlinks/hello/linux/.
You can run the example app using flutter run.
Note: Creating a runnable Flutter application
on Linux requires steps that are part of the flutter
tool, so even if your editor provides CMake
integration building and running that way won’t
work correctly.
Step 2e: Add macOS platform code (.swift)
We recommend you edit the macOS code using Xcode.
Before editing the macOS platform code in Xcode,
first make sure that the code has been built at least once
(in other words, run the example app from your IDE/editor,
or in a terminal execute
cd hello/example; flutter build macos).
Then use the following steps:
Launch Xcode.
Select File > Open, and select the
hello/example/macos/Runner.xcworkspace file. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-20 | The macOS platform code for your plugin is located in
Pods/Development Pods/hello/../../example/macos/Flutter/ephemeral/.symlinks/plugins/hello/macos/Classes
in the Project Navigator.
You can run the example app by pressing the run (▶) button.
Step 2f: Add Windows platform code (.h+.cpp)
We recommend you edit the Windows code using Visual Studio.
Before editing the Windows platform code in Visual Studio,
first make sure that the code has been built at least once
(in other words, run the example app from your IDE/editor,
or in a terminal execute
cd hello/example; flutter build windows).
Then use the following steps:
Launch Visual Studio.
Select Open a project or solution, and select the
hello/example/build/windows/hello_example.sln file. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-21 | The Windows platform code for your plugin is located in
hello_plugin/Source Files and hello_plugin/Header Files in
the Solution Explorer.
You can run the example app by right-clicking hello_example in
the Solution Explorer and selecting Set as Startup Project,
then pressing the run (▶) button. Important: After
making changes to plugin code, you must select
Build > Build Solution before running again, otherwise
an outdated copy of the built plugin will be run instead
of the latest version containing your changes.
Step 2g: Connect the API and the platform code
Finally, you need to connect the API written in Dart code with
the platform-specific implementations.
This is done using a platform channel,
or through the interfaces defined in a platform
interface package.
Add support for platforms in an existing plugin project
To add support for specific platforms to an
existing plugin project, run flutter create with
the --template=plugin flag again in the project directory.
For example, to add web support in an existing plugin, run: | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-22 | flutter create
-template
=plugin
-platforms
=web
If this command displays a message about updating the
pubspec.yaml file, follow the provided instructions.
Dart platform implementations
In many cases, non-web platform implementations only use the
platform-specific implementation language, as shown above. However,
platform implementations can also use platform-specific Dart as well.
Note:
The examples below only apply to non-web platforms. Web
plugin implementations are always written in Dart, and use
pluginClass and fileName for their Dart implementations
as shown above.
Dart-only platform implementations | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-23 | Dart-only platform implementations
In some cases, some platforms can be
implemented entirely in Dart (for example, using FFI).
For a Dart-only platform implementation on a platform other than web,
replace the pluginClass in pubspec.yaml with a dartPluginClass.
Here is the hello_windows example above modified for a
Dart-only implementation:
flutter
plugin
implements
hello
platforms
windows
dartPluginClass
HelloPluginWindows
In this version you would have no C++ Windows code, and would instead
subclass the hello plugin’s Dart platform interface class with a
HelloPluginWindows class that includes a static
registerWith() method. This method is called during startup,
and can be used to register the Dart implementation:
class
HelloPluginWindows
extends
HelloPluginPlatform | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-24 | HelloPluginWindows
extends
HelloPluginPlatform
/// Registers this class as the default instance of [HelloPluginPlatform].
static
void
registerWith
()
HelloPluginPlatform
instance
HelloPluginWindows
();
Hybrid platform implementations
Platform implementations can also use both Dart and a platform-specific
language. For example, a plugin could use a different platform channel
for each platform so that the channels can be customized per platform.
A hybrid implementation uses both of the registration systems
described above. Here is the hello_windows example above modified for a
hybrid implementation:
flutter
plugin
implements
hello
platforms
windows
dartPluginClass
HelloPluginWindows
pluginClass
HelloPlugin | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-25 | HelloPluginWindows
pluginClass
HelloPlugin
The Dart HelloPluginWindows class would use the registerWith()
shown above for Dart-only implementations, while the C++ HelloPlugin
class would be the same as in a C++-only implementation.
Testing your plugin
We encourage you test your plugin with automated tests
to ensure that functionality doesn’t regress
as you make changes to your code.
To learn more about testing your plugins,
check out Testing plugins.
If you are writing tests for your Flutter app
and plugins are causing crashes,
check out Flutter in plugin tests.
Developing FFI plugin packages
If you want to develop a package that calls into native APIs using
Dart’s FFI, you need to develop an FFI plugin package. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-26 | Both FFI plugin packages and (non-FFI) plugin packages support
bundling native code, but FFI plugin packages do not support
method channels and do include method channel registration code.
If you want to implement a plugin that uses both method channels
and FFI, use a (non-FFI) plugin. You can chose per platform to
use an FFI or (non-FFI) plugin.
FFI plugin packages were introduced in Flutter 3.0, if you’re
targeting older Flutter versions, you can use a (non-FFI) plugin.
Step 1: Create the package
To create a starter FFI plugin package,
use the --template=plugin_ffi flag with flutter create:
flutter create
-template
=plugin_ffi hello
This creates an FFI plugin project in the hello
folder with the following specialized content: | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-27 | This creates an FFI plugin project in the hello
folder with the following specialized content:
lib: The Dart code that defines the API of the plugin,
and which calls into the native code using dart:ffi.
src: The native source code, and a CmakeFile.txt
file for building that source code into a dynamic library.
platform folders (android, ios, windows, etc.): The
build files for building and bundling the native code
library with the platform application.
Step 2: Building and bundling native code
The pubspec.yaml specifies FFI plugins as follows:
plugin
platforms
some_platform
ffiPlugin
true
This configuration invokes the native build
for the various target platforms and bundles
the binaries in Flutter applications using these FFI plugins. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-28 | This can be combined with dartPluginClass,
such as when FFI is used for the
implementation of one platform in a federated plugin:
plugin
implements
some_other_plugin
platforms
some_platform
dartPluginClass
SomeClass
ffiPlugin
true
A plugin can have both FFI and method channels:
plugin
platforms
some_platform
pluginClass
SomeName
ffiPlugin
true
The native build systems that are invoked by FFI
(and method channels) plugins are:
For Android: Gradle, which invokes the Android NDK for native builds.
See the documentation in android/build.gradle. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-29 | For iOS and macOS: Xcode, via CocoaPods.
See the documentation in ios/hello.podspec.
See the documentation in macos/hello.podspec.
For Linux and Windows: CMake.
See the documentation in linux/CMakeLists.txt.
See the documentation in windows/CMakeLists.txt.
Step 3: Binding to native code
To use the native code, bindings in Dart are needed.
To avoid writing these by hand, they are generated from the header file
(src/hello.h) by package:ffigen.
Regenerate the bindings by running the following:
flutter pub run ffigen
-config ffigen.yaml
Step 4: Invoking native code
Very short-running native functions can be directly
invoked from any isolate.
For an example, see sum in lib/hello.dart. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-30 | Longer-running functions should be invoked on a
helper isolate to avoid dropping frames in
Flutter applications.
For an example, see sumAsync in lib/hello.dart.
Adding documentation
It is recommended practice to add the following documentation
to all packages:
A README.md file that introduces the package
A CHANGELOG.md file that documents changes in each version
A LICENSE file containing the terms under which the package
is licensed
API documentation for all public APIs (see below for details)
API documentation
When you publish a package,
API documentation is automatically generated and
published to pub.dev/documentation.
For example, see the docs for device_info.
If you wish to generate API documentation locally on
your development machine, use the following commands:
Change directory to the location of your package:
cd ~/dev/mypackage | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-31 | cd ~/dev/mypackage
Tell the documentation tool where the
Flutter SDK is located (change the following commands to reflect
where you placed it):
export FLUTTER_ROOT=~/dev/flutter # on macOS or Linux
set FLUTTER_ROOT=~/dev/flutter # on Windows
Run the dartdoc tool
(included as part of the Flutter SDK), as follows:
$FLUTTER_ROOT/bin/cache/dart-sdk/bin/dartdoc # on macOS or Linux
%FLUTTER_ROOT%\bin\cache\dart-sdk\bin\dartdoc # on Windows
For tips on how to write API documentation, see
Effective Dart Documentation.
Adding licenses to the LICENSE file | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-32 | Adding licenses to the LICENSE file
Individual licenses inside each LICENSE file
should be separated by 80 hyphens
on their own on a line.
If a LICENSE file contains more than one
component license, then each component
license must start with the names of the
packages to which the component license applies,
with each package name on its own line,
and the list of package names separated from
the actual license text by a blank line.
(The packages need not match the names of
the pub package. For example, a package might itself contain
code from multiple third-party sources,
and might need to include a license for each one.)
The following example shows a well-organized license file:
Here is another example of a well-organized license file:
Here is an example of a poorly-organized license file:
Another example of a poorly-organized license file:
Publishing your package | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-33 | Publishing your package
Tip:
Have you noticed that some of the packages and plugins
on pub.dev are designated as Flutter Favorites?
These are the packages published by verified developers
and are identified as the packages and plugins you
should first consider using when writing your app.
To learn more,
see the Flutter Favorites program.
Once you have implemented a package, you can publish it on
pub.dev, so that other developers can easily use it.
Prior to publishing, make sure to review the pubspec.yaml,
README.md, and CHANGELOG.md files to make sure their
content is complete and correct. Also, to improve the
quality and usability of your package (and to make it
more likely to achieve the status of a Flutter Favorite),
consider including the following items:
Diverse code usage examples
Screenshots, animated gifs, or videos
A link to the corresponding code repository | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-34 | A link to the corresponding code repository
Next, run the publish command in dry-run mode
to see if everything passes analysis:
flutter pub publish
-dry-run
The next step is publishing to pub.dev,
but be sure that you are ready because
publishing is forever:
flutter pub publish
For more details on publishing, see the
publishing docs on dart.dev.
Handling package interdependencies
If you are developing a package hello that depends on
the Dart API exposed by another package, you need to add
that package to the dependencies section of your
pubspec.yaml file. The code below makes the Dart API
of the url_launcher plugin available to hello:
dependencies
url_launcher
^5.0.0 | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-35 | url_launcher
^5.0.0
You can now import 'package:url_launcher/url_launcher.dart'
and launch(someUrl) in the Dart code of hello.
This is no different from how you include packages in
Flutter apps or any other Dart project.
But if hello happens to be a plugin package
whose platform-specific code needs access
to the platform-specific APIs exposed by url_launcher,
you also need to add suitable dependency declarations
to your platform-specific build files, as shown below.
Android
The following example sets a dependency for
url_launcher in hello/android/build.gradle:
android
// lines skipped
dependencies
compileOnly
rootProject
findProject
":url_launcher" | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-36 | findProject
":url_launcher"
You can now import io.flutter.plugins.urllauncher.UrlLauncherPlugin
and access the UrlLauncherPlugin
class in the source code at hello/android/src.
For more information on build.gradle files, see the
Gradle Documentation on build scripts.
iOS
The following example sets a dependency for
url_launcher in hello/ios/hello.podspec:
Pod
::
Spec
new
do
# lines skipped
dependency
'url_launcher'
You can now #import "UrlLauncherPlugin.h" and
access the UrlLauncherPlugin class in the source code
at hello/ios/Classes.
For additional details on .podspec files, see the
CocoaPods Documentation on them.
Web | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
9cbca39b081a-37 | Web
All web dependencies are handled by the pubspec.yaml
file like any other Dart package. | https://docs.flutter.dev/development/packages-and-plugins/developing-packages/index.html |
483e6748ad0b-0 | Flutter Favorite program
Packages & plugins
Flutter Favorite program
Metrics
Flutter Ecosystem Committee
Flutter Favorite usage guidelines
What’s next
Flutter Favorites
Note:
Due to limited staffing resources,
we are pausing the
Flutter Favorites and Happy Path programs.
We will update (and possibly combine)
these programs as soon as possible.
The aim of the Flutter Favorite program is to identify
packages and plugins that you should first consider when
building your app.
This is not a guarantee of quality or suitability to your
particular situation—you should always perform your
own evaluation of packages and plugins for your project.
You can see the complete list of
Flutter Favorite packages on pub.dev. | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-1 | You can see the complete list of
Flutter Favorite packages on pub.dev.
Note:
Looking to add more functionality to your app?
The Happy paths project guides you with
opinionated recommendations for
plugins and packages that can take your app
to the next level.
Metrics
Flutter Favorite packages have passed high quality standards
using the following metrics:
Overall package score
Permissive license,
including (but not limited to)
Apache, Artistic, BSD, CC BY, MIT, MS-PL and W3C
GitHub version tag matches the current version from
pub.dev, so you can see exactly what source is in the package
Feature completeness—and not marked as incomplete
(for example, with labels like “beta” or “under construction”)
Verified publisher
General usability when it comes to the overview,
docs, sample/example code, and API quality | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-2 | Good runtime behavior in terms of CPU and memory usage
High quality dependencies
Flutter Ecosystem Committee
The Flutter Ecosystem Committee is comprised of Flutter
team members and Flutter community members spread
across its ecosystem.
One of their jobs is to decide when a package
has met the quality bar to become a Flutter Favorite.
The current committee members
(ordered alphabetically by last name)
are as follows:
Pooja Bhaumik
Hillel Coren
Simon Lightfoot
Lara Martín
John Ryan
Diego Velasquez
Kyle Wang
If you’d like to nominate a package or plugin as a
potential future Flutter Favorite, or would like
to bring any other issues to the attention of the committee,
send the committee an email.
Flutter Favorite usage guidelines | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-3 | Flutter Favorite usage guidelines
Flutter Favorite packages are labeled as such on pub.dev
by the Flutter team.
If you own a package that has been designated as a Flutter Favorite,
you must adhere to the following guidelines:
Flutter Favorite package authors may place the Flutter Favorite
logo in the package’s GitHub README, on the package’s
pub.dev Overview tab,
and on social media as related to posts about that package.
We encourage you to use the #FlutterFavorite
hashtag in social media.
When using the Flutter Favorite logo,
the author must link to (this) Flutter Favorite landing page,
to provide context for the designation. | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-4 | If a Flutter Favorite package loses its Flutter Favorite status,
the author will be notified,
at which point the author must immediately remove all uses
of “Flutter Favorite” and the Flutter Favorite logo from
the affected package.
Don’t alter, distort,
or modify the Flutter Favorite logo in any way,
including displaying the logo with color variations
or unapproved visual elements.
Don’t display the Flutter Favorite logo in a manner that
is misleading, unfair, defamatory, infringing, libelous,
disparaging, obscene, or otherwise objectionable to Google.
What’s next | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-5 | What’s next
You should expect the list of Flutter Favorite packages
to grow and change as the ecosystem continues to thrive.
The committee will continue working with package authors
to increase quality, as well as consider other areas of the
ecosystem that could benefit from the Flutter Favorite program,
such as tools, consulting firms, and prolific Flutter contributors.
As the Flutter ecosystem grows,
we’ll be looking at expanding the set of metrics,
which might include the following:
Use of the new pubspec.yaml format that clearly
indicates which platforms are supported.
Support for the latest stable version of Flutter.
Support for AndroidX.
Support for multiple platforms, such as web, macOS,
Windows, Linux, etc.
Integration as well as unit test coverage.
Flutter Favorites | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
483e6748ad0b-6 | Integration as well as unit test coverage.
Flutter Favorites
You can see the complete list of
Flutter Favorite packages on pub.dev. | https://docs.flutter.dev/development/packages-and-plugins/favorites/index.html |
c59ce75ad41c-0 | Happy paths project
Packages & plugins
Happy paths project
Note:
Due to limited staffing resources,
we are pausing the
Flutter Favorites and Happy Path programs.
We will update (and possibly combine)
these programs as soon as possible.
Once you’ve learned Flutter basics and are ready to move on
to developing more advanced apps, how do you make that leap?
The pub.dev website lists thousands of packages and plugins
for Dart and Flutter.
So how do you choose?
Perhaps you suffer from analysis paralysis. | https://docs.flutter.dev/development/packages-and-plugins/happy-paths/index.html |
c59ce75ad41c-1 | Perhaps you suffer from analysis paralysis.
The Happy paths project is here to help.
We’ve created Happy paths recommendations to help
you make informed decisions on how to add various
types of functionality to your app.
There are many packages that can help you achieve your goals,
but we wanted to provide some guidance for newer Flutter
developers as you ramp up to building larger and more complex apps.
Keep in mind that these are not the only paths that you can choose,
but are solutions that we can recommend.
In future, we plan to add more happy path recommendations
for different areas of functionality. If there’s a specific
happy path recommendation that you would like to see,
file an issue to let us know.
Ads
Monetize your mobile app with in-app ads.
Background processing
Enable headless execution of Dart code.
Geolocation
Determine a user's location for enhanced app functionality. | https://docs.flutter.dev/development/packages-and-plugins/happy-paths/index.html |
Subsets and Splits