id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
84c3db05f57f-8 | {
"helloWorld": "¡Hola Mundo!"
}
Now, run flutter gen-l10n so that codegen takes place. You should see generated files in
${FLUTTER_PROJECT}/.dart_tool/flutter_gen/gen_l10n.
Alternatively, you can also run flutter gen-l10n to generate the same
files without running the app.
Add the import statement on app_localizations.dart and AppLocalizations.delegate
in your call to the constructor for MaterialApp.
import 'package:flutter_gen/gen_l10n/app_localizations.dart'; | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-9 | return const MaterialApp(
title: 'Localizations Sample App',
localizationsDelegates: [
AppLocalizations.delegate, // Add this line
GlobalMaterialLocalizations.delegate,
GlobalWidgetsLocalizations.delegate,
GlobalCupertinoLocalizations.delegate,
],
supportedLocales: [
Locale('en'), // English
Locale('es'), // Spanish
],
home: MyHomePage(),
);
The AppLocalizations class also provides auto-generated
localizationsDelegates and supportedLocales lists.
You can use these instead of providing them manually.
const MaterialApp(
title: 'Localizations Sample App',
localizationsDelegates: AppLocalizations.localizationsDelegates,
supportedLocales: AppLocalizations.supportedLocales,
);
Now you can use AppLocalizations anywhere in your app: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-10 | Now you can use AppLocalizations anywhere in your app:
appBar: AppBar(
// The [AppBar] title text should update its message
// according to the system locale of the target platform.
// Switching between English and Spanish locales should
// cause this text to update.
title: Text(AppLocalizations.of(context)!.helloWorld),
),
This code generates a Text widget that displays “Hello World!”
if the target device’s locale is set to English, and “¡Hola Mundo!”
if the target device’s locale is set to Spanish. In the arb files,
the key of each entry is used as the method name of the getter,
while the value of that entry contains the localized message.
To see a sample Flutter app using this tool, please see
gen_l10n_example.
To localize your device app description, you can pass in the localized
string into MaterialApp.onGenerateTitle: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-11 | Placeholders, plurals, and selects
You can also include application values in a message with
special syntax that uses a placeholder to generate a method
instead of a getter.
A placeholder, which must be a valid Dart identifier name,
becomes a positional parameter in the generated method in the
AppLocalizations code. Define a placeholder name by wrapping
it in curly braces as follows:
"{placeholderName}"
Define each placeholder in the placeholders object in the app’s .arb file.
For example, to define a hello message with a userName parameter,
add the following to lib/l10n/app_en.arb:
Regenerate the AppLocalizations file. This adds a hello method call to
the AppLocalizations.of(context) object, and the method accepts
a parameter of type String; the hello method returns a string.
Implement this by replacing the code passed into Builder
with the following: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-12 | Implement this by replacing the code passed into Builder
with the following:
"{countPlaceholder, plural, =0{message0} =1{message1} =2{message2} few{messageFew} many{messageMany} other{messageOther}}"
The expression above will be replaced by the message variation
(message0, message1, …) corresponding to the value
of the countPlaceholder. Only the messageOther field is required.
The following example defines a message that pluralizes the word, “wombat”:
Using a plural method is easy enough, just pass it the item count parameter:
Similar to plurals, you can also choose a value based on a String placeholder.
This is most often used to support gendered languages. The syntax is:
"{selectPlaceholder, select, case{message} ... other{messageOther}}"
The following example defines a message that selects a pronoun based on gender: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-13 | The following example defines a message that selects a pronoun based on gender:
To use this feature, pass the gender string as a parameter:
Keep in mind that when using select statements, comparison between the
parameter and the actual value is case-sensitive. That is,
AppLocalizations.of(context)!.pronoun("Male") will default to the
“other” case, and return “they”.
Escaping syntax
Sometimes, you have to use tokens, such as { and }, as normal characters. To ignore
such tokens from being parsed, enable the use-escaping flag by adding the following to l10n.yaml.
use-escaping
true
The parser ignores any string of characters wrapped with a pair of single quotes.
To use a normal single quote character, use a pair of consecutive single quotes. For example:
"helloWorld"
"Hello! '{Isn''t}' this a wonderful day?" | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-14 | "Hello! '{Isn''t}' this a wonderful day?"
becomes the following Dart String:
"Hello! {Isn't} this a wonderful day?"
Messages with numbers and currencies
Numbers, including those that represent currency values,
are displayed very differently in different locales.
The localizations generation tool in flutter_localizations uses the
intl package’s NumberFormat class
to properly format numbers based on the locale and the
desired format.
The int, double, and number types can use any of the
following NumberFormat constructors:
compact
“1.2M”
compactCurrency*
“$1.2M”
compactSimpleCurrency*
“$1.2M”
compactLong
“1.2 million”
currency* | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-15 | “1.2 million”
currency*
“USD1,200,000.00”
decimalPattern
“1,200,000”
decimalPercentPattern*
“120,000,000%”
percentPattern
“120,000,000%”
scientificPattern
“1E6”
simpleCurrency*
“$1,200,000”
The starred NumberFormat constructors in the table offer optional, named parameters.
Those parameters can be specified as the value of the placeholder’s optionalParameters object.
For example, to specify the optional decimalDigits parameter for compactCurrency,
make the following changes to the lib/l10n/app_en.arg file:
Messages with dates | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-16 | Messages with dates
Dates strings are formatted in many different ways depending both the locale and the app’s needs.
intl’s DateFormat class.
There are 41 format variations, identified by the names of their
"helloWorldOn"
"Hello World on {date}"
"@helloWorldOn"
"description"
"A message with a date parameter"
"placeholders"
"date"
"type"
"DateTime"
"format"
"yMd"
In an app where the locale is US English, the following expression would produce “7/10/1996”. In a Russian locale, it would produce “10.07.1996”.
AppLocalizations
of
context
helloWorldOn
DateTime | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-17 | context
helloWorldOn
DateTime
utc
1996
10
))
Localizing for iOS: Updating the iOS app bundle
iOS applications define key application metadata,
including supported locales, in an Info.plist file
that is built into the application bundle.
To configure the locales supported by your app,
use the following instructions:
Open your project’s ios/Runner.xcworkspace Xcode file.
In the Project Navigator, open the Info.plist file
under the Runner project’s Runner folder.
Select the Information Property List item.
Then select Add Item from the Editor menu,
and select Localizations from the pop-up menu. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-18 | Select and expand the newly-created Localizations item.
For each locale your application supports,
add a new item and select the locale you wish to add
from the pop-up menu in the Value field.
This list should be consistent with the languages listed
in the supportedLocales parameter.
Once all supported locales have been added, save the file.
Advanced topics for further customization
This section covers additional ways to customize a
localized Flutter application.
Advanced locale definition
Some languages with multiple variants require more than just a
language code to properly differentiate.
For example, fully differentiating all variants of
Chinese requires specifying the language code, script code,
and country code. This is due to the existence
of simplified and traditional script, as well as regional
differences in the way characters are written within the same script type.
In order to fully express every variant of Chinese for the
country codes CN, TW, and HK, the list of supported
locales should include: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-19 | This explicit full definition ensures that your app can
distinguish between and provide the fully nuanced localized
content to all combinations of these country codes.
If a user’s preferred locale is not specified,
then the closest match is used instead,
which likely contains differences to what the user expects.
Flutter only resolves to locales defined in supportedLocales.
Flutter provides scriptCode-differentiated
localized content for commonly used languages.
See Localizations for information on how the supported
locales and the preferred locales are resolved.
Although Chinese is a primary example,
other languages like French (fr_FR, fr_CA)
should also be fully differentiated for more nuanced localization.
Tracking the locale: The Locale class and the Localizations widget | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-20 | Tracking the locale: The Locale class and the Localizations widget
The Locale class identifies the user’s language.
Mobile devices support setting the locale for all applications,
usually using a system settings menu.
Internationalized apps respond by displaying values that are
locale-specific. For example, if the user switches the device’s locale
from English to French, then a Text widget that originally
displayed “Hello World” would be rebuilt with “Bonjour le monde”.
The Localizations widget defines the locale
for its child and the localized resources that the child depends on.
The WidgetsApp widget creates a Localizations widget
and rebuilds it if the system’s locale changes.
You can always lookup an app’s current locale with
Localizations.localeOf():
Specifying the app’s supportedLocales parameter | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-21 | Specifying the app’s supportedLocales parameter
Although the flutter_localizations library currently supports 78
languages and language variants, only English language translations
are available by default. It’s up to the developer to decide exactly
which languages to support.
The MaterialApp supportedLocales
parameter limits locale changes. When the user changes the locale
setting on their device, the app’s Localizations widget only
follows suit if the new locale is a member of this list.
If an exact match for the device locale isn’t found,
then the first supported locale with a matching languageCode
is used. If that fails, then the first element of the
supportedLocales list is used.
An app that wants to use a different “locale resolution”
method can provide a localeResolutionCallback.
For example, to have your app unconditionally accept
whatever locale the user selects:
Configuring the l10n.yaml file | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-22 | Configuring the l10n.yaml file
The l10n.yaml file allows you to configure the gen-l10n tool
to specify:
where all the input files are located
where all the output files should be created
what Dart class name to give your localizations delegate
For a full list of options, either run flutter gen-l10n --help
at the command line or refer to the following table:
arb-dir
The directory where the template and translated arb files are located. The default is lib/l10n.
output-dir | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-23 | output-dir
The directory where the generated localization classes are written. This option is only relevant if you want to generate the localizations code somewhere else in the Flutter project. You also need to set the synthetic-package flag to false.The app must import the file specified in the output-localization-file option from this directory. If unspecified, this defaults to the same directory as the input directory specified in arb-dir.
template-arb-file
The template arb file that is used as the basis for generating the Dart localization and messages files. The default is app_en.arb.
output-localization-file
The filename for the output localization and localizations delegate classes. The default is app_localizations.dart.
untranslated-messages-file | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-24 | untranslated-messages-file
The location of a file that describes the localization messages haven’t been translated yet. Using this option creates a JSON file at the target location, in the following format: "locale": ["message_1", "message_2" ... "message_n"] If this option is not specified, a summary of the messages that haven’t been translated are printed on the command line.
output-class
The Dart class name to use for the output localization and localizations delegate classes. The default is AppLocalizations.
preferred-supported-locales
The list of preferred supported locales for the application. By default, the tool generates the supported locales list in alphabetical order. Use this flag to default to a different locale.For example, pass in [ en_US ] to default to American English if a device supports it.
header | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-25 | header
The header to prepend to the generated Dart localizations files. This option takes in a string.For example, pass in "/// All localized files." to prepend this string to the generated Dart file.Alternatively, see the header-file option to pass in a text file for longer headers.
header-file
The header to prepend to the generated Dart localizations files. The value of this option is the name of the file that contains the header text which will be inserted at the top of each generated Dart file. Alternatively, see the header option to pass in a string for a simpler header.This file should be placed in the directory specified in arb-dir.
[no-]use-deferred-loading | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-26 | [no-]use-deferred-loading
Specifies whether to generate the Dart localization file with locales imported as deferred, allowing for lazy loading of each locale in Flutter web.This can reduce a web app’s initial startup time by decreasing the size of the JavaScript bundle. When this flag is set to true, the messages for a particular locale are only downloaded and loaded by the Flutter app as they are needed. For projects with a lot of different locales and many localization strings, it can improve performance to defer loading. For projects with a small number of locales, the difference is negligible, and might slow down the start up compared to bundling the localizations with the rest of the application.Note that this flag doesn’t affect other platforms such as mobile or desktop.
gen-inputs-and-outputs-list | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-27 | gen-inputs-and-outputs-list
When specified, the tool generates a JSON file containing the tool’s inputs and outputs, named gen_l10n_inputs_ and_outputs.json.This can be useful for keeping track of which files of the Flutter project were used when generating the latest set of localizations. For example, the Flutter tool’s build system uses this file to keep track of when to call gen_l10n during hot reload.The value of this option is the directory where the JSON file is generated. When null, the JSON file won’t be generated.
synthetic-package
Determines whether the generated output files are generated as a synthetic package or at a specified directory in the Flutter project. This flag is true by default. When synthetic-package is set to false, it generates the localizations files in the directory specified by arb-dir by default. If output-dir is specified, files are generated there.
project-dir | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-28 | project-dir
When specified, the tool uses the path passed into this option as the directory of the root Flutter project.When null, the relative path to the present working directory is used.
[no-]required-resource-attributes
Requires all resource ids to contain a corresponding resource attribute.By default, simple messages won’t require metadata, but it’s highly recommended as this provides context for the meaning of a message to readers.Resource attributes are still required for plural messages.
[no-]nullable-getter
Specifies whether the localizations class getter is nullable.By default, this value is true so that Localizations.of(context) returns a nullable value for backwards compatibility. If this value is false, then a null check is performed on the returned value of Localizations.of(context), removing the need for null checking in user code.
[no-]format
When specified, the dart format command is run after generating the localization files.
use-escaping | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-29 | use-escaping
Specifies whether to enable the use of single quotes as escaping syntax.
[no-]suppress-warnings
When specified, all warnings are suppressed.
How internationalization in Flutter works
This section covers the technical details of how localizations work
in Flutter. If you’re planning on supporting your own set of localized
messages, the following content would be helpful. Otherwise, you can
skip this section.
Loading and retrieving localized values
Localizations.of(context,type).
If the device’s locale changes,
the
InheritedWidget.
When a build function refers to an inherited widget,
an implicit dependency on the inherited widget is created.
When an inherited widget changes
(when the | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-30 | Localized values are loaded by the Localizations widget’s
list of LocalizationsDelegates.
Each delegate must define an asynchronous load()
method that produces an object that encapsulates a
collection of localized values.
Typically these objects define one method per localized value.
In a large app, different modules or packages might be bundled with
their own localizations. That’s why the Localizations widget
manages a table of objects, one per LocalizationsDelegate.
To retrieve the object produced by one of the LocalizationsDelegate’s
load methods, you specify a BuildContext and the object’s type.
For example,
the localized strings for the Material Components widgets
are defined by the MaterialLocalizations class.
Instances of this class are created by a LocalizationDelegate
provided by the MaterialApp class.
They can be retrieved with Localizations.of():
Localizations
of
MaterialLocalizations
>(
context
MaterialLocalizations | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-31 | >(
context
MaterialLocalizations
);
This particular Localizations.of() expression is used frequently,
so the MaterialLocalizations class provides a convenient shorthand:
static
MaterialLocalizations
of
BuildContext
context
return
Localizations
of
MaterialLocalizations
>(
context
MaterialLocalizations
);
/// References to the localized values defined by MaterialLocalizations
/// are typically written like this:
tooltip:
MaterialLocalizations
of
context
backButtonTooltip
Defining a class for the app’s localized resources | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-32 | Defining a class for the app’s localized resources
Putting together an internationalized Flutter app usually
starts with the class that encapsulates the app’s localized values.
The example that follows is typical of such classes.
Complete source code for the intl_example for this app.
This example is based on the APIs and tools provided by the
intl package.
An alternative class for the app’s localized resources
describes an example that doesn’t depend on the intl package.
The DemoLocalizations class defined below
contains the app’s strings (just one for the example)
translated into the locales that the app supports.
It uses the initializeMessages() function
generated by Dart’s intl package,
Intl.message(), to look them up.
intl tool
that analyzes the source code for classes that contain
Adding support for a new language | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-33 | Adding support for a new language
An app that needs to support a language that’s not included in
GlobalMaterialLocalizations has to do some extra work:
it must provide about 70 translations (“localizations”)
for words or phrases and the date patterns and symbols for the
locale.
See the following for an example of how to add
support for the Norwegian Nynorsk language.
A new GlobalMaterialLocalizations subclass defines the
localizations that the Material library depends on.
A new LocalizationsDelegate subclass, which serves
as factory for the GlobalMaterialLocalizations subclass,
must also be defined.
Here’s the source code for the complete add_language example,
minus the actual Nynorsk translations. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-34 | The locale-specific GlobalMaterialLocalizations subclass
is called NnMaterialLocalizations,
and the LocalizationsDelegate subclass is
_NnMaterialLocalizationsDelegate.
The value of NnMaterialLocalizations.delegate
is an instance of the delegate, and is all
that’s needed by an app that uses these localizations.
The delegate class includes basic date and number format
localizations. All of the other localizations are defined by String
valued property getters in NnMaterialLocalizations, like this:
These are the English translations, of course.
To complete the job you need to change the return
value of each getter to an appropriate Nynorsk string.
The getters return “raw” Dart strings that have an r prefix,
like r'About $applicationName',
because sometimes the strings contain variables with a $ prefix.
The variables are expanded by parameterized localization methods:
The date patterns and symbols of the locale will also need to
be specified. In the source code, the date patterns and symbols
are defined like this: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-35 | These will need to be modified for the locale to use the correct
date formatting. Unfortunately, since the intl library does
not share the same flexibility for number formatting, the formatting
for an existing locale will have to be used as a substitute in
_NnMaterialLocalizationsDelegate:
For more information about localization strings, see the
flutter_localizations README.
Once you’ve implemented your language-specific subclasses of
GlobalMaterialLocalizations and LocalizationsDelegate,
you just need to add the language and a delegate instance to your app.
Here’s some code that sets the app’s language to Nynorsk and
adds the NnMaterialLocalizations delegate instance to the app’s
localizationsDelegates list:
Alternative internationalization workflows
This section describes different approaches to internationalize
your Flutter application.
An alternative class for the app’s localized resources | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-36 | An alternative class for the app’s localized resources
The previous example was defined in terms of the Dart intl
package. Developers can choose their own approach for managing
localized values for the sake of simplicity or perhaps to integrate
with a different i18n framework.
Complete source code for the minimal app.
In the below example, the DemoLocalizations class
includes all of its translations directly in per language Maps.
In the minimal app the DemoLocalizationsDelegate is slightly
different. Its load method returns a SynchronousFuture
because no asynchronous loading needs to take place.
Using the Dart intl tools
Before building an API using the Dart intl package
you’ll want to review the intl package’s documentation.
Here’s a summary of the process
for localizing an app that depends on the intl package. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-37 | The demo app depends on a generated source file called
l10n/messages_all.dart, which defines all of the
localizable strings used by the app.
Rebuilding l10n/messages_all.dart requires two steps.
With the app’s root directory as the current directory,
generate l10n/intl_messages.arb from lib/main.dart:
$ dart run intl_translation:extract_to_arb --output-dir=lib/l10n lib/main.dart
The intl_messages.arb file is a JSON format map with one entry for
each Intl.message() function defined in main.dart. This
file serves as a template for the English and Spanish translations,
intl_en.arb and intl_es.arb.
These translations are created by you, the developer. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-38 | With the app’s root directory as the current directory,
generate intl_messages_<locale>.dart for each
intl_<locale>.arb file and intl_messages_all.dart,
which imports all of the messages files:
$ dart run intl_translation:generate_from_arb \
--output-dir=lib/l10n --no-use-deferred-loading \
lib/main.dart lib/l10n/intl_*.arb
Windows does not support file name wildcarding.
Instead, list the .arb files that were generated by the
intl_translation:extract_to_arb command. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-39 | $ dart run intl_translation:generate_from_arb \
--output-dir=lib/l10n --no-use-deferred-loading \
lib/main.dart \
lib/l10n/intl_en.arb lib/l10n/intl_fr.arb lib/l10n/intl_messages.arb
The DemoLocalizations class uses the generated initializeMessages()
function (defined in intl_messages_all.dart)
to load the localized messages and Intl.message() to look them up. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
955904bd8783-0 | Adding a Flutter Fragment to an Android app
Add Flutter to existing app
Adding Flutter to Android
Add a Flutter Fragment
Add a FlutterFragment to an Activity with a new FlutterEngine
Using a pre-warmed FlutterEngine
Initial route with a cached engine
Display a splash screen
Run Flutter with a specified initial route
Run Flutter from a specified entrypoint
Control FlutterFragment’s render mode
Display a FlutterFragment with transparency
The relationship between FlutterFragment and its Activity
Fragment represents a modular
piece of a larger UI. A
FlutterFragment
so that developers can present a Flutter experience any place
that they can use a regular
If an Activity is equally applicable for your application needs,
consider using a FlutterActivity instead of a
FlutterFragment, which is quicker and easier to use. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-1 | FlutterFragment allows developers to control the following
details of the Flutter experience within the Fragment:
Initial Flutter route
Dart entrypoint to execute
Opaque vs translucent background
Whether FlutterFragment should control its surrounding Activity
Whether a new FlutterEngine or a cached FlutterEngine should be used
FlutterFragment also comes with a number of calls that
must be forwarded from its surrounding Activity.
These calls allow Flutter to react appropriately to OS events.
All varieties of FlutterFragment, and its requirements,
are described in this guide.
Add a FlutterFragment to an Activity with a new FlutterEngine
The first thing to do to use a FlutterFragment is to add it to a host
Activity.
To add a FlutterFragment to a host Activity, instantiate and
attach an instance of FlutterFragment in onCreate() within the
Activity, or at another time that works for your app:
Java | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-2 | Java
Kotlin
public
class
MyActivity
extends
FragmentActivity
// Define a tag String to represent the FlutterFragment within this
// Activity's FragmentManager. This value can be whatever you'd like.
private
static
final
String
TAG_FLUTTER_FRAGMENT
"flutter_fragment"
// Declare a local variable to reference the FlutterFragment so that you
// can forward calls to it later.
private
FlutterFragment
flutterFragment
@Override
protected
void
onCreate
Bundle
savedInstanceState
super
onCreate
savedInstanceState
); | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-3 | onCreate
savedInstanceState
);
// Inflate a layout that has a container for your FlutterFragment.
// For this example, assume that a FrameLayout exists with an ID of
// R.id.fragment_container.
setContentView
layout
my_activity_layout
);
// Get a reference to the Activity's FragmentManager to add a new
// FlutterFragment, or find an existing one.
FragmentManager
fragmentManager
getSupportFragmentManager
();
// Attempt to find an existing FlutterFragment,
// in case this is not the first time that onCreate() was run.
flutterFragment
FlutterFragment
fragmentManager
findFragmentByTag
TAG_FLUTTER_FRAGMENT | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-4 | TAG_FLUTTER_FRAGMENT
);
// Create and attach a FlutterFragment if one does not exist.
if
flutterFragment
==
null
flutterFragment
FlutterFragment
createDefault
();
fragmentManager
beginTransaction
()
add
id
fragment_container
flutterFragment
TAG_FLUTTER_FRAGMENT
commit
();
class
MyActivity
FragmentActivity
()
companion
object
// Define a tag String to represent the FlutterFragment within this
// Activity's FragmentManager. This value can be whatever you'd like.
private | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-5 | private
const
val
TAG_FLUTTER_FRAGMENT
"flutter_fragment"
// Declare a local variable to reference the FlutterFragment so that you
// can forward calls to it later.
private
var
flutterFragment
FlutterFragment
null
override
fun
onCreate
savedInstanceState
Bundle
?)
super
onCreate
savedInstanceState
// Inflate a layout that has a container for your FlutterFragment. For
// this example, assume that a FrameLayout exists with an ID of
// R.id.fragment_container.
setContentView
layout
my_activity_layout | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-6 | setContentView
layout
my_activity_layout
// Get a reference to the Activity's FragmentManager to add a new
// FlutterFragment, or find an existing one.
val
fragmentManager
FragmentManager
supportFragmentManager
// Attempt to find an existing FlutterFragment, in case this is not the
// first time that onCreate() was run.
flutterFragment
fragmentManager
findFragmentByTag
TAG_FLUTTER_FRAGMENT
as
FlutterFragment
// Create and attach a FlutterFragment if one does not exist.
if
flutterFragment
==
null
var
newFlutterFragment
FlutterFragment
createDefault | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-7 | newFlutterFragment
FlutterFragment
createDefault
()
flutterFragment
newFlutterFragment
fragmentManager
beginTransaction
()
add
id
fragment_container
newFlutterFragment
TAG_FLUTTER_FRAGMENT
commit
()
The previous code is sufficient to render a Flutter UI
that begins with a call to your main() Dart entrypoint,
an initial Flutter route of /, and a new FlutterEngine.
However, this code is not sufficient to achieve all expected
Flutter behavior. Flutter depends on various OS signals that
must be forwarded from your host Activity to FlutterFragment.
These calls are shown in the following example:
Java
Kotlin
public
class
MyActivity | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-8 | public
class
MyActivity
extends
FragmentActivity
@Override
public
void
onPostResume
()
super
onPostResume
();
flutterFragment
onPostResume
();
@Override
protected
void
onNewIntent
@NonNull
Intent
intent
flutterFragment
onNewIntent
intent
);
@Override
public
void
onBackPressed
()
flutterFragment
onBackPressed
();
@Override
public | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-9 | ();
@Override
public
void
onRequestPermissionsResult
int
requestCode
@NonNull
String
[]
permissions
@NonNull
int
[]
grantResults
flutterFragment
onRequestPermissionsResult
requestCode
permissions
grantResults
);
@Override
public
void
onUserLeaveHint
()
flutterFragment
onUserLeaveHint
();
@Override
public
void
onTrimMemory
int
level
super | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-10 | int
level
super
onTrimMemory
level
);
flutterFragment
onTrimMemory
level
);
class
MyActivity
FragmentActivity
()
override
fun
onPostResume
()
super
onPostResume
()
flutterFragment
!!
onPostResume
()
override
fun
onNewIntent
@NonNull
intent
Intent
flutterFragment
!!
onNewIntent
intent
override
fun | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-11 | intent
override
fun
onBackPressed
()
flutterFragment
!!
onBackPressed
()
override
fun
onRequestPermissionsResult
requestCode
Int
permissions
Array
String
?>,
grantResults
IntArray
flutterFragment
!!
onRequestPermissionsResult
requestCode
permissions
grantResults
override
fun
onUserLeaveHint
()
flutterFragment
!!
onUserLeaveHint
()
override
fun
onTrimMemory | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-12 | override
fun
onTrimMemory
level
Int
super
onTrimMemory
level
flutterFragment
!!
onTrimMemory
level
With the OS signals forwarded to Flutter,
your FlutterFragment works as expected.
You have now added a FlutterFragment to your existing Android app.
The simplest integration path uses a new FlutterEngine,
which comes with a non-trivial initialization time,
leading to a blank UI until Flutter is
initialized and rendered the first time.
Most of this time overhead can be avoided by using
a cached, pre-warmed FlutterEngine, which is discussed next.
Using a pre-warmed FlutterEngine | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-13 | Using a pre-warmed FlutterEngine
By default, a FlutterFragment creates its own instance
of a FlutterEngine, which requires non-trivial warm-up time.
This means your user sees a blank Fragment for a brief moment.
You can mitigate most of this warm-up time by
using an existing, pre-warmed instance of FlutterEngine.
To use a pre-warmed FlutterEngine in a FlutterFragment,
instantiate a FlutterFragment with the withCachedEngine()
factory method.
Java
Kotlin
// Somewhere in your app, before your FlutterFragment is needed,
// like in the Application class ...
// Instantiate a FlutterEngine.
FlutterEngine
flutterEngine
new
FlutterEngine
context
);
// Start executing Dart code in the FlutterEngine. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-14 | );
// Start executing Dart code in the FlutterEngine.
flutterEngine
getDartExecutor
().
executeDartEntrypoint
DartEntrypoint
createDefault
()
);
// Cache the pre-warmed FlutterEngine to be used later by FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
);
FlutterFragment
withCachedEngine
"my_engine_id"
).
build
();
// Somewhere in your app, before your FlutterFragment is needed,
// like in the Application class ...
// Instantiate a FlutterEngine. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-15 | // Instantiate a FlutterEngine.
val
flutterEngine
FlutterEngine
context
// Start executing Dart code in the FlutterEngine.
flutterEngine
getDartExecutor
().
executeDartEntrypoint
DartEntrypoint
createDefault
()
// Cache the pre-warmed FlutterEngine to be used later by FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
FlutterFragment
withCachedEngine
"my_engine_id"
).
build
() | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-16 | ).
build
()
FlutterFragment internally knows about FlutterEngineCache
and retrieves the pre-warmed FlutterEngine based on the ID
given to withCachedEngine().
By providing a pre-warmed FlutterEngine,
as previously shown, your app renders the
first Flutter frame as quickly as possible.
Initial route with a cached engine
The concept of an initial route is available when configuring a
FlutterActivity or a FlutterFragment with a new FlutterEngine.
However, FlutterActivity and FlutterFragment don’t offer the
concept of an initial route when using a cached engine.
This is because a cached engine is expected to already be
running Dart code, which means it’s too late to configure the
initial route. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-17 | Developers that would like their cached engine to begin
with a custom initial route can configure their cached
FlutterEngine to use a custom initial route just before
executing the Dart entrypoint. The following example
demonstrates the use of an initial route with a cached engine:
Java
Kotlin
public
class
MyApplication
extends
Application
@Override
public
void
onCreate
()
super
onCreate
();
// Instantiate a FlutterEngine.
flutterEngine
new
FlutterEngine
this
);
// Configure an initial route.
flutterEngine
getNavigationChannel
().
setInitialRoute | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-18 | getNavigationChannel
().
setInitialRoute
"your/route/here"
);
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
getDartExecutor
().
executeDartEntrypoint
DartEntrypoint
createDefault
()
);
// Cache the FlutterEngine to be used by FlutterActivity or FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
);
class
MyApplication
Application
()
lateinit
var
flutterEngine
FlutterEngine | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-19 | var
flutterEngine
FlutterEngine
override
fun
onCreate
()
super
onCreate
()
// Instantiate a FlutterEngine.
flutterEngine
FlutterEngine
this
// Configure an initial route.
flutterEngine
navigationChannel
setInitialRoute
"your/route/here"
);
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
dartExecutor
executeDartEntrypoint
DartExecutor
DartEntrypoint
createDefault
()
// Cache the FlutterEngine to be used by FlutterActivity or FlutterFragment. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-20 | // Cache the FlutterEngine to be used by FlutterActivity or FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
By setting the initial route of the navigation channel, the associated
FlutterEngine displays the desired route upon initial execution of the
runApp() Dart function.
Changing the initial route property of the navigation channel
after the initial execution of runApp() has no effect.
Developers who would like to use the same FlutterEngine
between different Activitys and Fragments and switch
the route between those displays need to setup a method channel and
explicitly instruct their Dart code to change Navigator routes.
Display a splash screen | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-21 | Display a splash screen
The initial display of Flutter content requires some wait time,
even if a pre-warmed FlutterEngine is used.
To help improve the user experience around
this brief waiting period, Flutter supports the
display of a splash screen (also known as “launch screen”) until Flutter
renders its first frame. For instructions about how to show a launch
screen, see the splash screen guide.
Run Flutter with a specified initial route
An Android app might contain many independent Flutter experiences,
running in different FlutterFragments, with different
FlutterEngines. In these scenarios,
it’s common for each Flutter experience to begin with different
initial routes (routes other than /).
To facilitate this, FlutterFragment’s Builder
allows you to specify a desired initial route, as shown:
Java
Kotlin
// With a new FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-22 | FlutterFragment
flutterFragment
FlutterFragment
withNewEngine
()
initialRoute
"myInitialRoute/"
build
();
// With a new FlutterEngine.
val
flutterFragment
FlutterFragment
withNewEngine
()
initialRoute
"myInitialRoute/"
build
()
Run Flutter from a specified entrypoint
Similar to varying initial routes, different
FlutterFragments may want to execute different
Dart entrypoints. In a typical Flutter app, there is only one
Dart entrypoint: main(), but you can define other entrypoints.
FlutterFragment supports specification of the desired
Dart entrypoint to execute for the given Flutter experience.
To specify an entrypoint, build FlutterFragment, as shown: | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-23 | Java
Kotlin
FlutterFragment
flutterFragment
FlutterFragment
withNewEngine
()
dartEntrypoint
"mySpecialEntrypoint"
build
();
val
flutterFragment
FlutterFragment
withNewEngine
()
dartEntrypoint
"mySpecialEntrypoint"
build
()
The FlutterFragment configuration results in the execution
of a Dart entrypoint called mySpecialEntrypoint().
Notice that the parentheses () are
not included in the dartEntrypoint String name.
Control FlutterFragment’s render mode
Java
Kotlin
// With a new FlutterEngine.
FlutterFragment
flutterFragment | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-24 | FlutterFragment
flutterFragment
FlutterFragment
withNewEngine
()
renderMode
FlutterView
RenderMode
texture
build
();
// With a cached FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
renderMode
FlutterView
RenderMode
texture
build
();
// With a new FlutterEngine.
val
flutterFragment
FlutterFragment
withNewEngine
()
renderMode
FlutterView
RenderMode
texture | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-25 | FlutterView
RenderMode
texture
build
()
// With a cached FlutterEngine.
val
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
renderMode
FlutterView
RenderMode
texture
build
()
Using the configuration shown, the resulting FlutterFragment
renders its UI to a TextureView.
Display a FlutterFragment with transparency | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-26 | Display a FlutterFragment with transparency
By default, FlutterFragment renders with an opaque background,
using a SurfaceView. (See “Control FlutterFragment’s render
mode.”) That background is black for any pixels that aren’t
painted by Flutter. Rendering with an opaque background is
the preferred rendering mode for performance reasons.
Flutter rendering with transparency on Android negatively
affects performance. However, there are many designs that
require transparent pixels in the Flutter experience that
show through to the underlying Android UI. For this reason,
Flutter supports translucency in a FlutterFragment.
To enable transparency for a FlutterFragment,
build it with the following configuration:
Java
Kotlin
// Using a new FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment
withNewEngine
()
transparencyMode
FlutterView | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-27 | ()
transparencyMode
FlutterView
TransparencyMode
transparent
build
();
// Using a cached FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
transparencyMode
FlutterView
TransparencyMode
transparent
build
();
// Using a new FlutterEngine.
val
flutterFragment
FlutterFragment
withNewEngine
()
transparencyMode
FlutterView
TransparencyMode
transparent
build
() | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-28 | transparent
build
()
// Using a cached FlutterEngine.
val
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
transparencyMode
FlutterView
TransparencyMode
transparent
build
()
The relationship between FlutterFragment and its Activity
Some apps choose to use Fragments as entire Android screens.
In these apps, it would be reasonable for a Fragment to
control system chrome like Android’s status bar,
navigation bar, and orientation. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-29 | In other apps, Fragments are used to represent only
a portion of a UI. A FlutterFragment might be used to
implement the inside of a drawer, a video player,
or a single card. In these situations, it would be
inappropriate for the FlutterFragment to affect
Android’s system chrome because there are other UI
pieces within the same Window.
Java
Kotlin
// Using a new FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment
withNewEngine
()
shouldAttachEngineToActivity
false
build
();
// Using a cached FlutterEngine.
FlutterFragment
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
shouldAttachEngineToActivity | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
955904bd8783-30 | "my_engine_id"
shouldAttachEngineToActivity
false
build
();
// Using a new FlutterEngine.
val
flutterFragment
FlutterFragment
withNewEngine
()
shouldAttachEngineToActivity
false
build
()
// Using a cached FlutterEngine.
val
flutterFragment
FlutterFragment
withCachedEngine
"my_engine_id"
shouldAttachEngineToActivity
false
build
()
Note:
Some plugins may expect or require an Activity reference.
Ensure that none of your plugins require an Activity
before you disable access. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-fragment/index.html |
d0bda568e27d-0 | Adding a Flutter screen to an Android app
Add Flutter to existing app
Adding Flutter to Android
Add a Flutter screen
Add a normal Flutter screen
Step 1: Add FlutterActivity to AndroidManifest.xml
Step 2: Launch FlutterActivity
Step 3: (Optional) Use a cached FlutterEngine
Initial route with a cached engine
Add a translucent Flutter screen
Step 1: Use a theme with translucency
Step 2: Start FlutterActivity with transparency
This guide describes how to add a single Flutter screen to an
existing Android app. A Flutter screen can be added as a normal,
opaque screen, or as a see-through, translucent screen.
Both options are described in this guide.
Add a normal Flutter screen
Step 1: Add FlutterActivity to AndroidManifest.xml | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-1 | Step 1: Add FlutterActivity to AndroidManifest.xml
FlutterActivity to display a Flutter
experience within an Android app. Like any other
Activity,
<activity
android:name=
"io.flutter.embedding.android.FlutterActivity"
android:theme=
"@style/LaunchTheme"
android:configChanges=
"orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
android:hardwareAccelerated=
"true"
android:windowSoftInputMode=
"adjustResize"
/> | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-2 | "adjustResize"
/>
The reference to @style/LaunchTheme can be replaced
by any Android theme that want to apply to your FlutterActivity.
The choice of theme dictates the colors applied to
Android’s system chrome, like Android’s navigation bar, and to
the background color of the FlutterActivity just before
the Flutter UI renders itself for the first time.
Step 2: Launch FlutterActivity
With FlutterActivity registered in your manifest file,
add code to launch FlutterActivity from whatever point
in your app that you’d like. The following example shows
FlutterActivity being launched from an OnClickListener.
Note:
Make sure to use the following import:
import
io.flutter.embedding.android.FlutterActivity
Java
Kotlin
myButton
setOnClickListener
new
OnClickListener
() | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-3 | new
OnClickListener
()
@Override
public
void
onClick
View
startActivity
FlutterActivity
createDefaultIntent
currentActivity
);
});
myButton
setOnClickListener
startActivity
FlutterActivity
createDefaultIntent
this
The previous example assumes that your Dart entrypoint
is called main(), and your initial Flutter route is ‘/’.
The Dart entrypoint can’t be changed using Intent,
but the initial route can be changed using Intent.
The following example demonstrates how to launch a
FlutterActivity that initially renders a custom
route in Flutter.
Java
Kotlin
myButton
addOnClickListener
new | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-4 | myButton
addOnClickListener
new
OnClickListener
()
@Override
public
void
onClick
View
startActivity
FlutterActivity
withNewEngine
()
initialRoute
"/my_route"
build
currentActivity
);
});
myButton
setOnClickListener
startActivity
FlutterActivity
withNewEngine
()
initialRoute
"/my_route"
build
this
Replace "/my_route" with your desired initial route. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-5 | this
Replace "/my_route" with your desired initial route.
The use of the withNewEngine() factory method
configures a FlutterActivity that internally create
its own FlutterEngine instance. This comes with a
non-trivial initialization time. The alternative approach
is to instruct FlutterActivity to use a pre-warmed,
cached FlutterEngine, which minimizes Flutter’s
initialization time. That approach is discussed next.
Step 3: (Optional) Use a cached FlutterEngine
To pre-warm a FlutterEngine, find a reasonable
location in your app to instantiate a FlutterEngine.
The following example arbitrarily pre-warms a
FlutterEngine in the Application class:
Java
Kotlin
public
class
MyApplication
extends
Application
public
FlutterEngine
flutterEngine
@Override | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-6 | FlutterEngine
flutterEngine
@Override
public
void
onCreate
()
super
onCreate
();
// Instantiate a FlutterEngine.
flutterEngine
new
FlutterEngine
this
);
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
getDartExecutor
().
executeDartEntrypoint
DartEntrypoint
createDefault
()
);
// Cache the FlutterEngine to be used by FlutterActivity.
FlutterEngineCache
getInstance
()
put
"my_engine_id" | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-7 | ()
put
"my_engine_id"
flutterEngine
);
class
MyApplication
Application
()
lateinit
var
flutterEngine
FlutterEngine
override
fun
onCreate
()
super
onCreate
()
// Instantiate a FlutterEngine.
flutterEngine
FlutterEngine
this
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
dartExecutor
executeDartEntrypoint
DartExecutor
DartEntrypoint
createDefault
() | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-8 | DartEntrypoint
createDefault
()
// Cache the FlutterEngine to be used by FlutterActivity.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
FlutterEngineCache can be whatever you want.
Make sure that you pass the same ID to any
FlutterFragment that should use the cached
With a pre-warmed, cached FlutterEngine, you now need
to instruct your FlutterActivity to use the cached
FlutterEngine instead of creating a new one.
To accomplish this, use FlutterActivity’s withCachedEngine()
builder:
Java
Kotlin
myButton
addOnClickListener
new
OnClickListener
()
@Override
public
void | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-9 | @Override
public
void
onClick
View
startActivity
FlutterActivity
withCachedEngine
"my_engine_id"
build
currentActivity
);
});
myButton
setOnClickListener
startActivity
FlutterActivity
withCachedEngine
"my_engine_id"
build
this
When using the withCachedEngine() factory method,
pass the same ID that you used when caching the desired
FlutterEngine.
Now, when you launch FlutterActivity,
there is significantly less delay in
the display of Flutter content. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-10 | Note:
Flutter’s debug/release builds have drastically different
performance characteristics. To evaluate the performance
of Flutter, use a release build.
Initial route with a cached engine
The concept of an initial route is available when configuring a
FlutterActivity or a FlutterFragment with a new FlutterEngine.
However, FlutterActivity and FlutterFragment don’t offer the
concept of an initial route when using a cached engine.
This is because a cached engine is expected to already be
running Dart code, which means it’s too late to configure the
initial route.
Developers that would like their cached engine to begin
with a custom initial route can configure their cached
FlutterEngine to use a custom initial route just before
executing the Dart entrypoint. The following example
demonstrates the use of an initial route with a cached engine:
Java
Kotlin
public
class
MyApplication
extends | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-11 | class
MyApplication
extends
Application
@Override
public
void
onCreate
()
super
onCreate
();
// Instantiate a FlutterEngine.
flutterEngine
new
FlutterEngine
this
);
// Configure an initial route.
flutterEngine
getNavigationChannel
().
setInitialRoute
"your/route/here"
);
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
getDartExecutor
().
executeDartEntrypoint
DartEntrypoint
createDefault | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-12 | DartEntrypoint
createDefault
()
);
// Cache the FlutterEngine to be used by FlutterActivity or FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
);
class
MyApplication
Application
()
lateinit
var
flutterEngine
FlutterEngine
override
fun
onCreate
()
super
onCreate
()
// Instantiate a FlutterEngine.
flutterEngine
FlutterEngine
this
// Configure an initial route.
flutterEngine | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-13 | // Configure an initial route.
flutterEngine
navigationChannel
setInitialRoute
"your/route/here"
);
// Start executing Dart code to pre-warm the FlutterEngine.
flutterEngine
dartExecutor
executeDartEntrypoint
DartExecutor
DartEntrypoint
createDefault
()
// Cache the FlutterEngine to be used by FlutterActivity or FlutterFragment.
FlutterEngineCache
getInstance
()
put
"my_engine_id"
flutterEngine
By setting the initial route of the navigation channel, the associated
FlutterEngine displays the desired route upon initial execution of the
runApp() Dart function. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-14 | Changing the initial route property of the navigation channel
after the initial execution of runApp() has no effect.
Developers who would like to use the same FlutterEngine
between different Activitys and Fragments and switch
the route between those displays need to setup a method channel and
explicitly instruct their Dart code to change Navigator routes.
Add a translucent Flutter screen
Most full-screen Flutter experiences are opaque.
However, some apps would like to deploy a Flutter
screen that looks like a modal, for example,
a dialog or bottom sheet. Flutter supports translucent
FlutterActivitys out of the box.
To make your FlutterActivity translucent,
make the following changes to the regular process of
creating and launching a FlutterActivity.
Step 1: Use a theme with translucency
Android requires a special theme property for Activitys that render
with a translucent background. Create or update an Android theme with the
following property:
<style | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-15 | <style
name=
"MyTheme"
parent=
"@style/MyParentTheme"
<item
name=
"android:windowIsTranslucent"
>true
</item>
</style>
Then, apply the translucent theme to your FlutterActivity.
<activity
android:name=
"io.flutter.embedding.android.FlutterActivity"
android:theme=
"@style/MyTheme"
android:configChanges=
"orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
android:hardwareAccelerated=
"true"
android:windowSoftInputMode= | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-16 | "true"
android:windowSoftInputMode=
"adjustResize"
/>
Your FlutterActivity now supports translucency.
Next, you need to launch your FlutterActivity
with explicit transparency support.
Step 2: Start FlutterActivity with transparency
To launch your FlutterActivity with a transparent background,
pass the appropriate BackgroundMode to the IntentBuilder:
Java
Kotlin
// Using a new FlutterEngine.
startActivity
FlutterActivity
withNewEngine
()
backgroundMode
FlutterActivityLaunchConfigs
BackgroundMode
transparent
build
context
);
// Using a cached FlutterEngine.
startActivity
FlutterActivity | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-17 | startActivity
FlutterActivity
withCachedEngine
"my_engine_id"
backgroundMode
FlutterActivityLaunchConfigs
BackgroundMode
transparent
build
context
);
// Using a new FlutterEngine.
startActivity
FlutterActivity
withNewEngine
()
backgroundMode
FlutterActivityLaunchConfigs
BackgroundMode
transparent
build
this
);
// Using a cached FlutterEngine.
startActivity
FlutterActivity
withCachedEngine
"my_engine_id"
backgroundMode
FlutterActivityLaunchConfigs
BackgroundMode | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
d0bda568e27d-18 | FlutterActivityLaunchConfigs
BackgroundMode
transparent
build
this
);
You now have a FlutterActivity with a transparent background.
Note:
Make sure that your Flutter content also includes a
translucent background. If your Flutter UI paints a
solid background color, then it still appears as
though your FlutterActivity has an opaque background. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-screen/index.html |
aa30da320b2d-0 | Adding a Flutter View to an Android app
Add Flutter to existing app
Adding Flutter to Android
Integrate via FlutterView
A sample
General approach
APIs to implement
Warning:
Integrating via a FlutterView
is advanced usage and requires manually creating custom, application specific
bindings.
Integrating via a FlutterView
requires a bit more work than via FlutterActivity and FlutterFragment previously
described.
Fundamentally, the Flutter framework on the Dart side requires access to various
activity-level events and lifecycles to function. Since the FlutterView (which
is an android.view.View)
can be added to any activity which is owned by the developer’s application
and since the FlutterView doesn’t have access to activity level events, the
developer must bridge those connections manually to the FlutterEngine. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-view/index.html |
aa30da320b2d-1 | How you choose to feed your application’s activities’ events to the FlutterView
will be specific to your application.
A sample
Unlike the guides for FlutterActivity and FlutterFragment, the FlutterView
integration could be better demonstrated with a sample project.
A sample project is at https://github.com/flutter/samples/tree/main/add_to_app/android_view
to document a simple FlutterView integration where FlutterViews are used
for some of the cells in a RecycleView list of cards as seen in the gif above.
General approach
FlutterView
and the
FlutterEngine
present in the
FlutterActivityAndFragmentDelegate
in your own application’s code. The connections made in the
FlutterActivityAndFragmentDelegate
are done automatically when using a
FlutterActivity
or a
FlutterFragment,
but since the | https://docs.flutter.dev/development/add-to-app/android/add-flutter-view/index.html |
aa30da320b2d-2 | FlutterActivity
or a
FlutterFragment,
but since the
FlutterView
in this case is being added to an Activity or Fragment in your application,
you must recreate the connections manually. Otherwise, the
FlutterView
will not render anything or have other missing functionalities.
A sample FlutterViewEngine
class shows one such possible implementation of an application-specific
connection between an Activity, a FlutterView
and a FlutterEngine.
APIs to implement
The absolute minimum implementation needed for Flutter to draw anything at all
is to:
Call attachToFlutterEngine when the
FlutterView
is added to a resumed Activity’s view hierarchy and is visible; and
Call appIsResumed on the FlutterEngine’s
lifecycleChannel field when the Activity hosting the FlutterView
is visible. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-view/index.html |
aa30da320b2d-3 | The reverse detachFromFlutterEngine and other lifecycle methods on the LifecycleChannel
class must also be called to not leak resources when the FlutterView or Activity
is no longer visible.
In addition, see the remaining implementation in the FlutterViewEngine
demo class or in the FlutterActivityAndFragmentDelegate
to ensure a correct functioning of other features such as clipboards, system
UI overlay, plugins etc. | https://docs.flutter.dev/development/add-to-app/android/add-flutter-view/index.html |
24832475af81-0 | Adding Flutter to Android
Add Flutter to existing app
Adding Flutter to Android
Topics:
Project setup
Add a single Flutter screen
Add a Flutter Fragment
Add a Flutter View
Plugin setup | https://docs.flutter.dev/development/add-to-app/android/index.html |
8861fdd3679e-0 | Managing plugins and dependencies in add-to-app
Add Flutter to existing app
Adding Flutter to Android
Plugin setup
A. Simple scenario
B. Plugins needing project edits
C. Merging libraries
This guide describes how to set up your project to consume
plugins and how to manage your Gradle library dependencies
between your existing Android app and your Flutter module’s plugins.
A. Simple scenario
In the simple cases:
Your Flutter module uses a plugin that has no additional
Android Gradle dependency because it only uses Android OS
APIs, such as the camera plugin.
Your Flutter module uses a plugin that has an Android
Gradle dependency, such as
ExoPlayer from the video_player plugin,
but your existing Android app didn’t depend on ExoPlayer. | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
8861fdd3679e-1 | There are no additional steps needed. Your add-to-app
module will work the same way as a full-Flutter app.
Whether you integrate using Android Studio,
Gradle subproject or AARs,
transitive Android Gradle libraries are automatically
bundled as needed into your outer existing app.
B. Plugins needing project edits
Some plugins require you to make some edits to the
Android side of your project.
For example, the integration instructions for the
firebase_crashlytics plugin require manual
edits to your Android wrapper project’s build.gradle file.
For full-Flutter apps, these edits are done in your
Flutter project’s /android/ directory.
In the case of a Flutter module, there are only Dart
files in your module project. Perform those Android
Gradle file edits on your outer, existing Android
app rather than in your Flutter module. | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
8861fdd3679e-2 | Note:
Astute readers might notice that the Flutter module
directory also contains an .android and an
.ios directory. Those directories are Flutter-tool-generated
and are only meant to bootstrap Flutter into generic
Android or iOS libraries. They should not be edited or checked-in.
This allows Flutter to improve the integration point should
there be bugs or updates needed with new versions of Gradle,
Android, Android Gradle Plugin, etc.
For advanced users, if more modularity is needed and you must
not leak knowledge of your Flutter module’s dependencies into
your outer host app, you can rewrap and repackage your Flutter
module’s Gradle library inside another native Android Gradle
library that depends on the Flutter module’s Gradle library.
You can make your Android specific changes such as editing the
AndroidManifest.xml, Gradle files or adding more Java files
in that wrapper library.
C. Merging libraries | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
8861fdd3679e-3 | C. Merging libraries
The scenario that requires slightly more attention is if
your existing Android application already depends on the
same Android library that your Flutter module
does (transitively via a plugin).
For instance, your existing app’s Gradle may already have:
dependencies
implementation
'com.crashlytics.sdk.android:crashlytics:2.10.1'
And your Flutter module also depends on
firebase_crashlytics via pubspec.yaml:
dependencies
firebase_crashlytics
^0.1.3
This plugin usage transitively adds a Gradle dependency again via
firebase_crashlytics v0.1.3’s own Gradle file:
dependencies
implementation
'com.crashlytics.sdk.android:crashlytics:2.9.9' | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
8861fdd3679e-4 | The two com.crashlytics.sdk.android:crashlytics dependencies
might not be the same version. In this example,
the host app requested v2.10.1 and the Flutter
module plugin requested v2.9.9.
By default, Gradle v5
resolves dependency version conflicts
by using the newest version of the library.
This is generally ok as long as there are no API
or implementation breaking changes between the versions.
For example, you might use the new Crashlytics library
in your existing app as follows:
dependencies
implementation
com
google
firebase
firebase
crashlytics:
17.0
beta03 | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
8861fdd3679e-5 | 17.0
beta03
This approach won’t work since there are major API differences
between the Crashlytics’ Gradle library version
v17.0.0-beta03 and v2.9.9.
For Gradle libraries that follow semantic versioning,
you can generally avoid compilation and runtime errors
by using the same major semantic version in your
existing app and Flutter module plugin. | https://docs.flutter.dev/development/add-to-app/android/plugin-setup/index.html |
27bdf6947950-0 | Integrate a Flutter module into your Android project
Add Flutter to existing app
Adding Flutter to Android
Integrate Flutter
Using Android Studio
Manual integration
Create a Flutter module
Java 11 requirement
Add the Flutter module as a dependency
Option A - Depend on the Android Archive (AAR)
Option B - Depend on the module’s source code
Flutter can be embedded into your existing Android
application piecemeal, as a source code Gradle
subproject or as AARs.
The integration flow can be done using the Android Studio
IDE with the Flutter plugin or manually.
only supports
building ahead-of-time (AOT) compiled libraries
for
Consider using the abiFilters Android Gradle
Plugin API to limit the supported architectures in your APK.
Doing this avoids a missing libflutter.so runtime crash,
for example: | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-1 | android
//...
defaultConfig
ndk
// Filter for architectures supported by Flutter.
abiFilters
'armeabi-v7a'
'arm64-v8a'
'x86_64'
The Flutter engine has an x86 and x86_64 version.
When using an emulator in debug Just-In-Time (JIT) mode,
the Flutter module still runs correctly.
Using Android Studio
The Android Studio IDE is a convenient way of integrating
your Flutter module automatically. With Android Studio,
you can co-edit both your Android code and your Flutter code
in the same project. You can also continue to use your normal
IntelliJ Flutter plugin functionalities such as Dart code
completion, hot reload, and widget inspector. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-2 | Add-to-app flows with Android Studio are only supported on
Android Studio 3.6 with version 42+ of the Flutter plugin
for IntelliJ. The Android Studio integration also only
supports integrating using a source code Gradle subproject,
rather than using AARs. See below for more details on
the distinction.
Using the File > New > New Module… menu in
Android Studio in your existing Android project,
you can either create a new Flutter module to integrate,
or select an existing Flutter module that was created previously.
If you create a new module, you can use a wizard to
select the module name, location, and so on.
The Android Studio plugin automatically configures your
Android project to add your Flutter module as a dependency,
and your app is ready to build.
Note:
To see the changes that were automatically made to your
Android project by the IDE plugin, consider using
source control for your Android project before performing
any steps. A local diff shows the changes. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-3 | Tip:
By default, your project’s Project pane is probably
showing the ‘Android’ view. If you can’t see your new
Flutter files in the Project pane, ensure that
your Project pane is set to display ‘Project Files’,
which shows all files without filtering.
Your app now includes the Flutter module as a dependency.
You can jump to the Adding a Flutter screen to an Android app
to follow the next steps.
Manual integration
To integrate a Flutter module with an existing Android app
manually, without using Flutter’s Android Studio plugin,
follow these steps:
Create a Flutter module
Let’s assume that you have an existing Android app at
some/path/MyApp, and that you want your Flutter
project as a sibling:
cd some/path/
flutter create
t module
-org com.example my_flutter | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-4 | t module
-org com.example my_flutter
This creates a some/path/my_flutter/ Flutter module project
with some Dart code to get you started and an .android/
hidden subfolder. The .android folder contains an
Android project that can both help you run a barebones
standalone version of your Flutter module via flutter run
and it’s also a wrapper that helps bootstrap the Flutter
module an embeddable Android library.
Note:
Add custom Android code to your own existing
application’s project or a plugin,
not to the module in .android/.
Changes made in your module’s .android/
directory won’t appear in your existing Android
project using the module. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-5 | Do not source control the .android/ directory
since it’s autogenerated. Before building the
module on a new machine, run flutter pub get
in the my_flutter directory first to regenerate
the .android/ directory before building the
Android project using the Flutter module.
Note:
To avoid Dex merging issues, flutter.androidPackage should not be identical to your host app’s package name
Java 11 requirement
The Flutter Android engine uses Java 11 features.
Before attempting to connect your Flutter module project
to your host Android app, ensure that your host Android
app declares the following source compatibility within your
app’s build.gradle file, under the android { }
block, such as:
android
//...
compileOptions
sourceCompatibility
11
targetCompatibility
11
Add the Flutter module as a dependency | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
27bdf6947950-6 | 11
Add the Flutter module as a dependency
Next, add the Flutter module as a dependency of your
existing app in Gradle. There are two ways to achieve this.
The AAR mechanism creates generic Android AARs as
intermediaries that packages your Flutter module.
This is good when your downstream app builders don’t
want to have the Flutter SDK installed. But,
it adds one more build step if you build frequently.
The source code subproject mechanism is a convenient
one-click build process, but requires the Flutter SDK.
This is the mechanism used by the Android Studio IDE plugin.
Option A - Depend on the Android Archive (AAR)
This option packages your Flutter library as a generic local
Maven repository composed of AARs and POMs artifacts.
This option allows your team to build the host app without
installing the Flutter SDK. You can then distribute the
artifacts from a local or remote repository. | https://docs.flutter.dev/development/add-to-app/android/project-setup/index.html |
Subsets and Splits