id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
d85fbf6a73f2-0 | Creating flavors for Flutter
What are flavors
Environment set up
Creating flavors in iOS
Using flavors in iOS
Plugin configurations
Using flavors in Android
Setting up launch configurations
Launching your app flavors
More information
Packages
What are flavors
Have you ever wondered how to set up different environments in your Flutter app?
Flavors (known as build configurations in iOS), allow you (the developer) to
create separate environments for your app using the same code base.
For example, you might have one flavor for your full-fledged production app,
another as a limited “free” app, another for testing experimental features, and so on. | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-1 | Say you want to make both free and paid versions of your Flutter app.
You can use flavors to set up both app versions
without writing two separate apps.
For example, the free version of the app has basic functionality and ads.
In contrast, the paid version has basic app functionality, extra features,
different styles for paid users, and no ads.
You also might use flavors for feature development.
If you’ve built a new feature and want to try it out,
you could set up a flavor to test it out.
Your production code remains unaffected
until you’re ready to deploy your new feature.
Flavors let you define compile-time configurations
and set parameters that are read at runtime to customize
your app’s behavior.
This document guides you through setting up Flutter flavors for iOS and Android.
Environment set up
Prerequisites:
Xcode installed
An existing Flutter project | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-2 | Xcode installed
An existing Flutter project
To set up flavors in iOS, you’ll define build configurations in Xcode.
Creating flavors in iOS
Open your project in Xcode.
Select Runner > New Scheme from the menu to add a new Scheme.
A scheme describes how Xcode runs different actions.
For the purposes of this guide, the example flavor and scheme are
named free.
The build configurations in the free scheme
have the -free suffix.
Duplicate the build configurations to differentiate between the
default configurations that are already available and the new configurations
for the free scheme.
Under the Info tab at the end of the
Configurations dropdown list, click the plus button and duplicate
each configuration name (Debug, Release, and Profile).
Duplicate the existing configurations, once for each environment. | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-3 | Note:
Your configurations should be based on your Debug.xconfig or Release.xcconfig
file, not the Pods-Runner.xcconfigs. You can check this by expanding the configuration names.
To match the free flavor, add -free
at the end of each new configuration name.
Change the free scheme to match the build configurations already created.
In the Runner project, click Manage Schemes… and a pop up window opens.
Double click the free scheme. In the next step
(as shown in the screenshot), you’ll modify each scheme
to match its free build configuration:
Using flavors in iOS
Now that you’ve set up your free flavor,
you can, for example, add different product bundle identifiers per flavor.
A bundle identifier uniquely identifies your application.
In this example, we set the Debug-free value to equal
com.flavor-test.free. | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-4 | Change the app bundle identifier to differentiate between schemes.
In Product Bundle Identifier, append .free to each -free scheme value.
In the Build Settings, set the Product Name value to match each flavor.
For example, add Debug Free.
Add the display name to Info.plist. Update the Bundle Display Name
value to $(PRODUCT_NAME).
Now you have set up your flavor by making a free scheme
in Xcode and setting the build configurations for that scheme.
For more information, skip to the Launching your app flavors
section at the end of this document.
Plugin configurations
If your app uses a Flutter plugin, you need to update the ios/Podfile.
In ios/Podfile change the default for Debug, Profile, and Release
to match the Xcode build configurations for the free scheme.
project
'Runner'
'Debug-free'
=> | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-5 | 'Runner'
'Debug-free'
=>
:debug
'Profile-free'
=>
:release
'Release-free'
=>
:release
Using flavors in Android
Setting up flavors in Android can be done in your project’s
build.gradle file.
Inside your Flutter project,
navigate to android/app/build.gradle.
Create a flavorDimension to group your added product flavors.
Gradle doesn’t combine product flavors that share the same dimension.
Add a productFlavors object with the desired flavors along
with values for dimension, resValue,
and applicationId or applicationIdSuffix. | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-6 | The name of the application for each build is located in resValue.
If you specify a applicationIdSuffix instead of a applicationId,
it is appended to the “base” application id.
flavorDimensions
"default"
productFlavors
free
dimension
"default"
resValue
"string"
"app_name"
"free flavor example"
applicationIdSuffix
".free"
Setting up launch configurations
Next, add a launch.json file; this allows you to run the command
flutter run --flavor [environment name].
In VSCode, set up the launch configurations as follows:
In the root directory of your project, add a folder called .vscode.
Inside the .vscode folder, create a file named launch.json. | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-7 | Inside the .vscode folder, create a file named launch.json.
In the launch.json file, add a configuration object for each flavor.
Each configuration has a name, request, type, program,
and args key.
"version"
"0.2.0"
"configurations"
"name"
"free"
"request"
"launch"
"type"
"dart"
"program"
"lib/main_development.dart"
"args"
"--flavor"
"free"
"--target"
"lib/main_free.dart"
],
"compounds"
[] | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-8 | ],
"compounds"
[]
You can now run the terminal command
flutter run --flavor free or you can set up a run
configuration in your IDE.
Launching your app flavors
Once the flavors are set up, modify the Dart code in
lib / main.dart to consume the flavors.
Test the setup using flutter run --flavor free
at the command line, or in your IDE.
For examples of build flavors for iOS (Xcode) and Android,
check out the integration test samples in the Flutter repo.
More information
For more information on creating and using flavors, check out
the following resources:
Build flavors in Flutter (Android and iOS) with different Firebase projects per flavor Flutter Ready to Go
Flavoring Flutter Applications (Android & iOS) | https://docs.flutter.dev/deployment/flavors/index.html |
d85fbf6a73f2-9 | Flavoring Flutter Applications (Android & iOS)
Flutter Flavors Setup with multiple Firebase Environments using FlutterFire and Very Good CLI
Packages
For packages that support creating flavors, check out the following:
flutter_flavor
flutter_flavorizr | https://docs.flutter.dev/deployment/flavors/index.html |
6cc3b85e5d7a-0 | Build and release an iOS app
Preliminaries
Register your app on App Store Connect
Register a Bundle ID
Create an application record on App Store Connect
Review Xcode project settings
Updating the app’s deployment version
Add an app icon
Add a launch image
Create a build archive and upload to App Store Connect
Update the app’s build and version numbers
Create an app bundle
Upload the app bundle to App Store Connect
Create a build archive with Codemagic CLI tools
Release your app on TestFlight
Release your app to the App Store
Troubleshooting
This guide provides a step-by-step walkthrough of releasing a
Flutter app to the App Store and TestFlight.
Preliminaries
Xcode is required to build and release your app. You
must use a device running macOS to follow this guide. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-1 | Before beginning the process of releasing your app,
ensure that it meets
Apple’s App Review Guidelines.
In order to publish your app to the App Store,
you must first enroll in the
Apple Developer Program.
You can read more about the various
membership options in Apple’s
Choosing a Membership guide.
Register your app on App Store Connect
Manage your app’s life cycle on
App Store Connect (formerly iTunes Connect).
You define your app name and description, add screenshots,
set pricing, and manage releases to the App Store and TestFlight.
Registering your app involves two steps: registering a unique
Bundle ID, and creating an application record on App Store Connect.
For a detailed overview of App Store Connect, see the
App Store Connect guide.
Register a Bundle ID | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-2 | Register a Bundle ID
Every iOS application is associated with a Bundle ID,
a unique identifier registered with Apple.
To register a Bundle ID for your app, follow these steps:
Open the App IDs page of your developer account.
Click + to create a new Bundle ID.
Enter an app name, select Explicit App ID, and enter an ID.
Select the services your app uses, then click Continue.
On the next page, confirm the details and click Register
to register your Bundle ID.
Create an application record on App Store Connect
Register your app on App Store Connect:
Open App Store Connect in your browser.
On the App Store Connect landing page, click My Apps.
Click + in the top-left corner of the My Apps page,
then select New App. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-3 | Fill in your app details in the form that appears.
In the Platforms section, ensure that iOS is checked.
Since Flutter does not currently support tvOS,
leave that checkbox unchecked. Click Create.
Navigate to the application details for your app and select
App Information from the sidebar.
In the General Information section, select the Bundle ID
you registered in the preceding step.
For a detailed overview, see
Add an app to your account.
Review Xcode project settings
This step covers reviewing the most important settings
in the Xcode workspace.
For detailed procedures and descriptions, see
Prepare for app distribution.
Navigate to your target’s settings in Xcode:
Open the default Xcode workspace in your project by running
open ios/Runner.xcworkspace in a terminal window from your
Flutter project directory.
To view your app’s settings, select the Runner target in the
Xcode navigator. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-4 | Verify the most important settings.
In the Identity section of the General tab:
The display name of your app.
The App ID you registered on App Store Connect.
In the Signing & Capabilities tab:
Whether Xcode should automatically manage app signing
and provisioning. This is set true by default, which should
be sufficient for most apps. For more complex scenarios,
see the Code Signing Guide.
Select the team associated with your registered Apple Developer
account. If required, select Add Account…,
then update this setting.
In the Deployment section of the Build Settings tab:
The minimum iOS version that your app supports.
Flutter supports iOS 11 and later. If your app or plugins
include Objective-C or Swift code that makes use of APIs newer
than iOS 11, update this setting to the highest required version.
The General tab of your project settings should resemble
the following: | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-5 | The General tab of your project settings should resemble
the following:
For a detailed overview of app signing, see
Create, export, and delete signing certificates.
Updating the app’s deployment version
If you changed Deployment Target in your Xcode project,
open ios/Flutter/AppframeworkInfo.plist in your Flutter app
and update the MinimumOSVersion value to match.
Add an app icon
When a new Flutter app is created, a placeholder icon set is created.
This step covers replacing these placeholder icons with your
app’s icons:
Review the iOS App Icon guidelines.
In the Xcode project navigator, select Assets.xcassets in the
Runner folder. Update the placeholder icons with your own app icons.
Verify the icon has been replaced by running your app using
flutter run.
Add a launch image
Similar to the app icon, you may also want to replace the placeholder launch image: | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-6 | Similar to the app icon, you may also want to replace the placeholder launch image:
In the Xcode project navigator, select Assets.xcassets in the
Runner folder. Update the placeholder launch image with your own launch image.
Verify the new launch image by hot restarting your app. (Don’t use hot reload.)
Create a build archive and upload to App Store Connect
During development, you’ve been building, debugging, and testing
with debug builds. When you’re ready to ship your app to users
on the App Store or TestFlight, you need to prepare a release build.
Update the app’s build and version numbers
The default version number of the app is 1.0.0.
To update it, navigate to the pubspec.yaml file
and update the following line:
version
1.0.0+1 | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-7 | version
1.0.0+1
The version number is three numbers separated by dots,
such as 1.0.0 in the example above, followed by an optional
build number such as 1 in the example above, separated by a +.
Both the version and the build number can be overridden in
flutter build ipa by specifying --build-name and --build-number,
respectively.
In iOS, build-name uses CFBundleShortVersionString
while build-number uses CFBundleVersion.
Read more about iOS versioning at Core Foundation Keys
on the Apple Developer’s site.
You may also override the pubspec.yaml build name and number in Xcode:
Open Runner.xcworkspace in your app’s ios folder.
Select Runner in the Xcode project navigator, then select the
Runner target in the settings view sidebar.
In the Identity section, update the Version to the user-facing
version number you wish to publish. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-8 | In the Identity section, update the Build identifier to a unique
build number used to track this build on App Store Connect.
Each upload requires a unique build number.
Create an app bundle
Run flutter build ipa to produce an Xcode build archive (.xcarchive file)
in your project’s build/ios/archive/ directory and an App Store app
bundle (.ipa file) in build/ios/ipa.
Consider adding the --obfuscate and --split-debug-info flags to
obfuscate your Dart code to make it more difficult
to reverse engineer.
If you are not distributing to the App Store, you can optionally
choose a different export method by
adding the option --export-method ad-hoc,
--export-method development or --export-method enterprise. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-9 | Note:
On versions of Flutter where flutter build ipa --export-method is unavailable,
open build/ios/archive/MyApp.xcarchive and follow the instructions below
to validate and distribute the app from Xcode.
Upload the app bundle to App Store Connect
Once the app bundle is created, upload it to
App Store Connect by either:
Install and open the Apple Transport macOS app.
Drag and drop the build/ios/ipa/*.ipa app bundle into the app.
Or upload the app bundle from the command line by running:
xcrun altool --upload-app --type ios -f build/ios/ipa/*.ipa --apiKey your_api_key --apiIssuer your_issuer_id
Run man altool for details about how to authenticate with the App Store Connect API key.
Or open build/ios/archive/MyApp.xcarchive in Xcode. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-10 | Or open build/ios/archive/MyApp.xcarchive in Xcode.
Click the Validate App button. If any issues are reported,
address them and produce another build. You can reuse the same
build ID until you upload an archive.
After the archive has been successfully validated, click
Distribute App.
Note:
When you export your app at the end of Distribute App,
Xcode will create a directory containing
an IPA of your app and an ExportOptions.plist file.
You can create new IPAs with the same options without launching
Xcode by running
flutter build ipa --export-options-plist=path/to/ExportOptions.plist.
See xcodebuild -h for details about the keys in this property list. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-11 | You can follow the status of your build in the
Activities tab of your app’s details page on
App Store Connect.
You should receive an email within 30 minutes notifying you that
your build has been validated and is available to release to testers
on TestFlight. At this point you can choose whether to release
on TestFlight, or go ahead and release your app to the App Store.
For more details, see
Upload an app to App Store Connect.
Create a build archive with Codemagic CLI tools
This step covers creating a build archive and uploading
your build to App Store Connect using Flutter build commands
and Codemagic CLI Tools executed in a terminal
in the Flutter project directory. This allows you to create a build archive
with full control of distribution certificates in a temporary keychain
isolated from your login keychain.
Install the Codemagic CLI tools:
pip3 install codemagic-cli-tools | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-12 | You’ll need to generate an App Store Connect API Key
with App Manager access to automate operations with App Store Connect. To make
subsequent commands more concise, set the following environment variables from
the new key: issuer id, key id, and API key file.
export APP_STORE_CONNECT_ISSUER_ID=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
export APP_STORE_CONNECT_KEY_IDENTIFIER=ABC1234567
export APP_STORE_CONNECT_PRIVATE_KEY=`cat /path/to/api/key/AuthKey_XXXYYYZZZ.p8`
You need to export or create an iOS Distribution certificate to code sign and package a build archive.
If you have existing certificates, you can export the
private keys by executing the following command for each certificate: | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-13 | openssl pkcs12 -in <certificate_name>.p12 -nodes -nocerts | openssl rsa -out cert_key
Or you can create a new private key by executing the following command:
ssh-keygen -t rsa -b 2048 -m PEM -f cert_key -q -N ""
Later, you can have CLI tools automatically create a new iOS Distribution from the private key.
Set up a new temporary keychain to be used for code signing:
keychain initialize
Restore Login Keychain!
After running keychain initialize you must run the following:
keychain use-login
This sets your login keychain as the default to avoid potential
authentication issues with apps on your machine.
Fetch the code signing files from App Store Connect: | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-14 | Fetch the code signing files from App Store Connect:
app-store-connect fetch-signing-files $(xcode-project detect-bundle-id) \
--platform IOS \
--type IOS_APP_STORE \
--certificate-key=@file:/path/to/cert_key \
--create
Where cert_key is either your exported iOS Distribution certificate private key
or a new private key which automatically generates a new certificate. The certificate
will be created from the private key if it doesn’t exist in App Store Connect.
Now add the fetched certificates to your keychain:
keychain add-certificates
Update the Xcode project settings to use fetched code signing profiles:
xcode-project use-profiles
Install Flutter dependencies:
flutter packages pub get
Install CocoaPods dependencies: | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-15 | flutter packages pub get
Install CocoaPods dependencies:
find . -name "Podfile" -execdir pod install \;
Build the Flutter the iOS project:
flutter build ipa --release \
--export-options-plist=$HOME/export_options.plist
Note that export_options.plist is the output of the xcode-project use-profiles command.
Publish the app to App Store Connect:
app-store-connect publish \
--path $(find $(pwd) -name "*.ipa")
As mentioned earlier, don’t forget to set your login keychain
as the default to avoid authentication issues
with apps on your machine:
keychain use-login | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-16 | keychain use-login
You should receive an email within 30 minutes notifying you that
your build has been validated and is available to release to testers
on TestFlight. At this point you can choose whether to release
on TestFlight, or go ahead and release your app to the App Store.
Release your app on TestFlight
TestFlight allows developers to push their apps
to internal and external testers. This optional step
covers releasing your build on TestFlight.
Navigate to the TestFlight tab of your app’s application
details page on App Store Connect.
Select Internal Testing in the sidebar.
Select the build to publish to testers, then click Save.
Add the email addresses of any internal testers.
You can add additional internal users in the Users and Roles
page of App Store Connect,
available from the dropdown menu at the top of the page. | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-17 | For more details, see Distribute an app using TestFlight.
Release your app to the App Store
When you’re ready to release your app to the world,
follow these steps to submit your app for review and
release to the App Store:
Select Pricing and Availability from the sidebar of your app’s
application details page on
App Store Connect and complete the
required information.
Select the status from the sidebar. If this is the first
release of this app, its status is
1.0 Prepare for Submission. Complete all required fields.
Click Submit for Review.
Apple notifies you when their app review process is complete.
Your app is released according to the instructions you
specified in the Version Release section.
For more details, see
Distribute an app through the App Store.
Troubleshooting | https://docs.flutter.dev/deployment/ios/index.html |
6cc3b85e5d7a-18 | Troubleshooting
The Distribute your app guide provides a
detailed overview of the process of releasing an app to the App Store. | https://docs.flutter.dev/deployment/ios/index.html |
65d1e8064a65-0 | Build and release a Linux app to the Snap Store
Prerequisites
Set up the build environment
Install snapcraft
Install Multipass
Install LXD
Overview of snapcraft
Flutter snapcraft.yaml example
Metadata
Grade, confinement, and base
Apps
Parts
Desktop file and icon
Flutter super-cool-app.desktop example
Build the snap
Publish
Snap Store channels
Snap Store automatic review
Additional resources
During a typical development cycle,
you test an app using flutter run at the command line,
or by using the Run and Debug
options in your IDE. By default,
Flutter builds a debug version of your app.
When you’re ready to prepare a release version of your app,
for example to publish to the Snap Store,
this page can help. | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-1 | Prerequisites
To build and publish to the Snap Store, you need the
following components:
Ubuntu OS, 18.04 LTS (or higher)
Snapcraft command line tool
Multipass virtualization manager or
LXD container manager
Set up the build environment
Use the following instructions to set up your build environment.
Install snapcraft
At the command line, run the following:
sudo snap
install snapcraft
-classic
Install Multipass
Also at the command line, run the following:
sudo snap
install multipass
-classic | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-2 | sudo snap
install multipass
-classic
To work correctly, Multipass requires access to the CPU
virtualization extensions. If the extensions are not
available for your CPU architecture, not enabled in BIOS,
or not accessible (for instance if you are running a
virtual machine without nested virtualization),
you won’t be able to use Multipass.
If you see the following error, you should use LXD:
launch failed: CPU does not support KVM extensions
Install LXD
To install LXD, use the following command:
sudo snap
install lxd
LXD can be used as an alternative backend during the
snap build process. Once installed, LXD needs to be
configured for use. The default answers are suitable
for most use cases.
sudo lxd init | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-3 | Would you like to use LXD clustering? (yes/no) [default=no]:
Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]:
Name of the storage backend to use (btrfs, dir, lvm, zfs, ceph) [default=zfs]:
Create a new ZFS pool? (yes/no) [default=yes]:
Would you like to use an existing empty disk or partition? (yes/no) [default=no]:
Size in GB of the new loop device (1GB minimum) [default=5GB]:
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]:
What should the new bridge be called? [default=lxdbr0]: | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-4 | What should the new bridge be called? [default=lxdbr0]:
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]:
Would you like LXD to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes]
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]: | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-5 | On the first run, LXD may not be able to connect to its socket:
An error occurred when trying to communicate with the 'LXD'
provider: cannot connect to the LXD socket
('/var/snap/lxd/common/lxd/unix.socket').
This means you need to add your user name to the LXD
(lxd) group, so log out of your session and then log back in:
sudo usermod
a
G lxd <your username>
Overview of snapcraft
The snapcraft tool builds snaps based on the instructions
listed in a snapcraft.yaml file.
To get a basic understanding of snapcraft and its
core concepts, take a look at the Snap documentation
and the Introduction to snapcraft.
Additional links and information are listed at the
bottom of this page.
Flutter snapcraft.yaml example | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-6 | Flutter snapcraft.yaml example
Place the YAML file in your Flutter
project under <project root>/snap/snapcraft.yaml.
(And remember that YAML files are sensitive to white space!)
For example:
name
super-cool-app
version
0.1.0
summary
Super Cool App
description
Super Cool App that does everything!
confinement
strict
base
core18
grade
stable
slots
dbus-super-cool-app
# adjust accordingly to your app name
interface
dbus
bus
session
name
org.bar.super_cool_app | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-7 | name
org.bar.super_cool_app
# adjust accordingly to your app name and
apps
super-cool-app
command
super_cool_app
extensions
flutter-master
# Where "master" defines which Flutter channel to use for the build
plugs
network
slots
dbus-super-cool-app
parts
super-cool-app
source
plugin
flutter
flutter-target
lib/main.dart
# The main entry-point file of the application
The following sections explain the various pieces of the YAML file.
Metadata | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-8 | Metadata
This section of the snapcraft.yaml file defines and
describes the application. The snap version is
derived (adopted) from the build section.
name
super-cool-app
version
0.1.0
summary
Super Cool App
description
Super Cool App that does everything!
Grade, confinement, and base
This section defines how the snap is built.
confinement
strict
base
core18
grade
stable
Specifies the quality of the snap; this is relevant for
the publication step later. | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-9 | Specifies the quality of the snap; this is relevant for
the publication step later.
Specifies what level of system resource access the snap
will have once installed on the end-user system.
Strict confinement limits the application access to
specific resources (defined by plugs in the app section).
Snaps are designed to be self-contained applications,
and therefore, they require their own private core root
filesystem known as base. The base keyword specifies
the version used to provide the minimal set of common libraries,
and mounted as the root filesystem for the application at runtime.
Apps
This section defines the application(s) that exist inside the snap.
There can be one or more applications per snap. This example
has a single application—super_cool_app.
apps
super-cool-app
command
super_cool_app
extensions
flutter-master | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-10 | extensions
flutter-master
Points to the binary, relative to the snap’s root,
and runs when the snap is invoked.
A list of one or more extensions. Snapcraft extensions
are reusable components that can expose sets of libraries
and tools to a snap at build and runtime,
without the developer needing to have specific knowledge
of included frameworks. The flutter-master extension exposes
the GTK 3 libraries to the Flutter snap. This ensures a
smaller footprint and better integration with the system.
The flutter-master extension sets your flutter channel
to master. If you would like to build your app with the dev
channel simply use the flutter-dev extension.
A list of one or more plugs for system interfaces.
These are required to provide necessary functionality
when snaps are strictly confined. This Flutter snap needs
access to the network. | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-11 | The DBus interface provides a way for snaps to
communicate over DBus. The snap providing the DBus
service declares a slot with the well-known DBus name
and which bus it uses. Snaps wanting to communicate
with the providing snap’s service declare a plug for
the providing snap. Note that a snap declaration is
needed for your snap to be delivered via the snap store
and claim this well-known DBus name (simply upload the
snap to the store and request a manual review and
a reviewer will take a look). | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-12 | When a providing snap is installed, snapd will
generate security policy that will allow it to
listen on the well-known DBus name on the specified
bus. If the system bus is specified, snapd will also
generate DBus bus policy that allows ‘root’ to own
the name and any user to communicate with the
service. Non-snap processes are allowed to
communicate with the providing snap following
traditional permissions checks. Other (consuming)
snaps may only communicate with the providing
snap by connecting the snaps’ interface.
Parts
This section defines the sources required to
assemble the snap.
Parts can be downloaded and built automatically using plugins.
Similar to extensions, snapcraft can use various plugins
(like Python, C, Java, Ruby, etc) to assist in the
building process. Snapcraft also has some special plugins.
Performs no action and the actual build process is
handled using a manual override. | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-13 | Performs no action and the actual build process is
handled using a manual override.
Provides the necessary Flutter SDK tools so you can
use it without having to manually download and set up
the build tools.
parts
super-cool-app
source
plugin
flutter
flutter-target
lib/main.dart
# The main entry-point file of the application
Desktop file and icon
Desktop entry files are used to add an application
to the desktop menu. These files specify the name and
icon of your application, the categories it belongs to,
related search keywords and more. These files have the
extension .desktop and follow the XDG Desktop Entry
Specification version 1.1.
Flutter super-cool-app.desktop example | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-14 | Flutter super-cool-app.desktop example
Place the .desktop file in your Flutter project
under <project root>/snap/gui/super-cool-app.desktop.
Notice: icon and .desktop file name must be the
same as your app name in yaml file!
For example:
Place your icon with .png extension in your Flutter
project under <project root>/snap/gui/super-cool-app.png.
Build the snap
Once the snapcraft.yaml file is complete,
run snapcraft as follows from the root directory
of the project.
To use the Multipass VM backend:
snapcraft
To use the LXD container backend:
snapcraft
-use-lxd
Publish | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-15 | snapcraft
-use-lxd
Publish
Once the snap is built, you’ll have a <name>.snap file
in your root project directory. You can now publish the snap.
The process consists of the following:
Create a developer account at snapcraft.io, if you
haven’t already done so.
Register the app’s name. Registration can be done
either using the Snap Store Web UI portal, or from the
command line, as follows:
$ snapcraft login
$ snapcraft register
Release the app. After reading the next section
to learn about selecting a Snap Store channel,
push the snap to the store:
$ snapcraft upload --release=<channel> <file>.snap
Snap Store channels
The Snap Store uses channels to differentiate among
different versions of snaps. | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-16 | The Snap Store uses channels to differentiate among
different versions of snaps.
The snapcraft upload command uploads the snap file to
the store. However, before you run this command,
you need to learn about the different release channels.
Each channel consists of three components:
All snaps must have a default track called latest.
This is the implied track unless specified otherwise.
Defines the readiness of the application.
The risk levels used in the snap store are:
stable, candidate, beta, and edge.
Allows creation of short-lived snap
sequences to test bug-fixes.
Snap Store automatic review
The Snap Store runs several automated checks against
your snap. There may also be a manual review,
depending on how the snap was built, and if there are
any specific security concerns. If the checks pass
without errors, the snap becomes available in the store.
Additional resources | https://docs.flutter.dev/deployment/linux/index.html |
65d1e8064a65-17 | Additional resources
You can learn more from the following links on the
snapcraft.io site:
Channels
Environment variables
Interface management
Parts environment variables
Releasing to the Snap Store
Snapcraft extensions
Supported plugins | https://docs.flutter.dev/deployment/linux/index.html |
181122a23360-0 | Build and release a macOS app
Preliminaries
Register your app on App Store Connect
Register a Bundle ID
Create an application record on App Store Connect
Review Xcode project settings
Configuring the app’s name, bundle identifier and copyright
Updating the app’s version number
Add an app icon
Create a build archive with Xcode
Create a build archive with Codemagic CLI tools
Distribute to registered devices
Release your app to the App Store
Troubleshooting
This guide provides a step-by-step walkthrough of releasing a
Flutter app to the App Store.
Preliminaries
Before beginning the process of releasing your app,
ensure that it meets
Apple’s App Review Guidelines. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-1 | In order to publish your app to the App Store,
you must first enroll in the
Apple Developer Program.
You can read more about the various
membership options in Apple’s
Choosing a Membership guide.
Register your app on App Store Connect
Manage your app’s life cycle on
App Store Connect (formerly iTunes Connect).
You define your app name and description, add screenshots,
set pricing, and manage releases to the App Store and TestFlight.
Registering your app involves two steps: registering a unique
Bundle ID, and creating an application record on App Store Connect.
For a detailed overview of App Store Connect, see the
App Store Connect guide.
Register a Bundle ID
Every macOS application is associated with a Bundle ID,
a unique identifier registered with Apple.
To register a Bundle ID for your app, follow these steps:
Open the App IDs page of your developer account. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-2 | Open the App IDs page of your developer account.
Click + to create a new Bundle ID.
Enter an app name, select Explicit App ID, and enter an ID.
Select the services your app uses, then click Continue.
On the next page, confirm the details and click Register
to register your Bundle ID.
Create an application record on App Store Connect
Register your app on App Store Connect:
Open App Store Connect in your browser.
On the App Store Connect landing page, click My Apps.
Click + in the top-left corner of the My Apps page,
then select New App.
Fill in your app details in the form that appears.
In the Platforms section, ensure that macOS is checked.
Since Flutter does not currently support tvOS,
leave that checkbox unchecked. Click Create.
Navigate to the application details for your app and select
App Information from the sidebar. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-3 | In the General Information section, select the Bundle ID
you registered in the preceding step.
For a detailed overview,
see Add an app to your account.
Review Xcode project settings
This step covers reviewing the most important settings
in the Xcode workspace.
For detailed procedures and descriptions, see
Prepare for app distribution.
Navigate to your target’s settings in Xcode:
In Xcode, open Runner.xcworkspace in your app’s macos folder.
To view your app’s settings, select the Runner project in the Xcode
project navigator. Then, in the main view sidebar, select the Runner
target.
Select the General tab.
Verify the most important settings.
In the Identity section:
The app category under which your app will be listed on the Mac App Store. This cannot be none.
The App ID you registered on App Store Connect. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-4 | The App ID you registered on App Store Connect.
In the Deployment info section:
The minimum macOS version that your app supports. Flutter supports macOS 10.11 and later.
In the Signing & Capabilities section:
Whether Xcode should automatically manage app signing
and provisioning. This is set true by default, which should
be sufficient for most apps. For more complex scenarios,
see the Code Signing Guide.
Select the team associated with your registered Apple Developer
account. If required, select Add Account…,
then update this setting.
The General tab of your project settings should resemble
the following:
For a detailed overview of app signing, see
Create, export, and delete signing certificates.
Configuring the app’s name, bundle identifier and copyright | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-5 | Configuring the app’s name, bundle identifier and copyright
The configuration for the product identifiers are centralized
in macos/Runner/Configs/AppInfo.xcconfig. For the app’s name,
set PRODUCT_NAME, for the copyright set PRODUCT_COPYRIGHT,
and finally set PRODUCT_BUNDLE_IDENTIFIER for the app’s
bundle identifier.
Updating the app’s version number
The default version number of the app is 1.0.0.
To update it, navigate to the pubspec.yaml file
and update the following line:
version: 1.0.0+1
The version number is three numbers separated by dots,
such as 1.0.0 in the example above, followed by an optional
build number such as 1 in the example above, separated by a +. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-6 | Both the version and the build number may be overridden in Flutter’s
build by specifying --build-name and --build-number,
respectively.
In macOS, build-name uses CFBundleShortVersionString
while build-number uses CFBundleVersion.
Read more about iOS versioning at Core Foundation Keys
on the Apple Developer’s site.
Add an app icon
When a new Flutter app is created, a placeholder icon set is created.
This step covers replacing these placeholder icons with your
app’s icons:
Review the macOS App Icon guidelines.
In the Xcode project navigator, select Assets.xcassets in the
Runner folder. Update the placeholder icons with your own app icons.
Verify the icon has been replaced by running your app using
flutter run -d macos.
Create a build archive with Xcode
This step covers creating a build archive and uploading
your build to App Store Connect using Xcode. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-7 | During development, you’ve been building, debugging, and testing
with debug builds. When you’re ready to ship your app to users
on the App Store or TestFlight, you need to prepare a release build.
At this point, you might consider obfuscating your Dart code
to make it more difficult to reverse engineer. Obfuscating
your code involves adding a couple flags to your build command.
In Xcode, configure the app version and build:
Open Runner.xcworkspace in your app’s macos folder. To do this from
the command line, run the following command from the base directory of your
application project.
open macos/Runner.xcworkspace
Select Runner in the Xcode project navigator, then select the
Runner target in the settings view sidebar.
In the Identity section, update the Version to the user-facing
version number you wish to publish. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-8 | In the Identity section, update the Build identifier to a unique
build number used to track this build on App Store Connect.
Each upload requires a unique build number.
Finally, create a build archive and upload it to App Store Connect:
Create a release Archive of your application. From the base directory of
your application project, run the following.
flutter build macos
Open Xcode and select Product > Archive to open the archive created
in the previous step.
Click the Validate App button. If any issues are reported,
address them and produce another build. You can reuse the same
build ID until you upload an archive.
After the archive has been successfully validated, click
Distribute App. You can follow the status of your build in the
Activities tab of your app’s details page on
App Store Connect. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-9 | You should receive an email within 30 minutes notifying you that
your build has been validated and is available to release to testers
on TestFlight. At this point you can choose whether to release
on TestFlight, or go ahead and release your app to the App Store.
For more details, see
Upload an app to App Store Connect.
Create a build archive with Codemagic CLI tools
This step covers creating a build archive and uploading
your build to App Store Connect using Flutter build commands
and Codemagic CLI Tools executed in a terminal
in the Flutter project directory.
Install the Codemagic CLI tools:
pip3 install codemagic-cli-tools
You’ll need to generate an App Store Connect API Key
with App Manager access to automate operations with App Store Connect. To make
subsequent commands more concise, set the following environment variables from
the new key: issuer id, key id, and API key file. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-10 | export APP_STORE_CONNECT_ISSUER_ID=aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
export APP_STORE_CONNECT_KEY_IDENTIFIER=ABC1234567
export APP_STORE_CONNECT_PRIVATE_KEY=`cat /path/to/api/key/AuthKey_XXXYYYZZZ.p8`
You need to export or create a Mac App Distribution and a Mac Installer
Distribution certificate to perform code signing and package a build archive.
If you have existing certificates, you can export the
private keys by executing the following command for each certificate:
openssl pkcs12 -in <certificate_name>.p12 -nodes -nocerts | openssl rsa -out cert_key
Or you can create a new private key by executing the following command: | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-11 | Or you can create a new private key by executing the following command:
ssh-keygen -t rsa -b 2048 -m PEM -f cert_key -q -N ""
Later, you can have CLI tools automatically create a new Mac App Distribution and
Mac Installer Distribution certificate. You can use the same private key for
each new certificate.
Fetch the code signing files from App Store Connect:
app-store-connect fetch-signing-files YOUR.APP.BUNDLE_ID \
--platform MAC_OS \
--type MAC_APP_STORE \
--certificate-key=@file:/path/to/cert_key \
--create
Where cert_key is either your exported Mac App Distribution certificate private key
or a new private key which automatically generates a new certificate.
If you do not have a Mac Installer Distribution certificate,
you can create a new certificate by executing the following: | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-12 | app-store-connect create-certificate \
--type MAC_INSTALLER_DISTRIBUTION \
--certificate-key=@file:/path/to/cert_key \
--save
Use cert_key of the private key you created earlier.
Fetch the Mac Installer Distribution certificates:
app-store-connect list-certificates \
--type MAC_INSTALLER_DISTRIBUTION \
--certificate-key=@file:/path/to/cert_key \
--save
Set up a new temporary keychain to be used for code signing:
keychain initialize
Restore Login Keychain!
After running keychain initialize you must run the following:
keychain use-login
This sets your login keychain as the default to avoid potential
authentication issues with apps on your machine. | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-13 | Now add the fetched certificates to your keychain:
keychain add-certificates
Update the Xcode project settings to use fetched code signing profiles:
xcode-project use-profiles
Install Flutter dependencies:
flutter packages pub get
Install CocoaPods dependencies:
find . -name "Podfile" -execdir pod install \;
Build the Flutter macOS project:
flutter build macos --release
Package the app:
APP_NAME=$(find $(pwd) -name "*.app")
PACKAGE_NAME=$(basename "$APP_NAME" .app).pkg
xcrun productbuild --component "$APP_NAME" /Applications/ unsigned.pkg | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-14 | INSTALLER_CERT_NAME=$(keychain list-certificates \
| jq '[.[]
| select(.common_name
| contains("Mac Developer Installer"))
| .common_name][0]' \
| xargs)
xcrun productsign --sign "$INSTALLER_CERT_NAME" unsigned.pkg "$PACKAGE_NAME"
rm -f unsigned.pkg
Publish the packaged app to App Store Connect:
app-store-connect publish \
--path "$PACKAGE_NAME"
As mentioned earlier, don’t forget to set your login keychain
as the default to avoid authentication issues
with apps on your machine:
keychain use-login
Distribute to registered devices
TestFlight is not available for distributing macOS apps
to internal and external testers. See distribution guide
to prepare an archive for distribution to designated Mac computers.
Release your app to the App Store | https://docs.flutter.dev/deployment/macos/index.html |
181122a23360-15 | Release your app to the App Store
When you’re ready to release your app to the world,
follow these steps to submit your app for review and
release to the App Store:
Select Pricing and Availability from the sidebar of your app’s
application details page on
App Store Connect and complete the
required information.
Select the status from the sidebar. If this is the first
release of this app, its status is
1.0 Prepare for Submission. Complete all required fields.
Click Submit for Review.
Apple notifies you when their app review process is complete.
Your app is released according to the instructions you
specified in the Version Release section.
For more details, see
Distribute an app through the App Store.
Troubleshooting
The Distribute your app guide provides a
detailed overview of the process of releasing an app to the App Store. | https://docs.flutter.dev/deployment/macos/index.html |
2efd75044b3c-0 | Obfuscating Dart code
What is code obfuscation?
Limitations
Supported targets
Obfuscating your app
Reading an obfuscated stack trace
Caveat
What is code obfuscation?
Code obfuscation is the process of modifying an
app’s binary to make it harder for humans to understand.
Obfuscation hides function and class names in your
compiled Dart code, replacing each symbol with
another symbol, making it difficult for an attacker
to reverse engineer your proprietary app.
Flutter’s code obfuscation works
only on a release build.
Limitations
Note that obfuscating your code does not
encrypt resources nor does it protect against
reverse engineering.
It only renames symbols with more obscure names.
It is a poor security practice to
store secrets in an app. | https://docs.flutter.dev/deployment/obfuscate/index.html |
2efd75044b3c-1 | It is a poor security practice to
store secrets in an app.
Supported targets
The following build targets
support the obfuscation process
described on this page:
aar
apk
appbundle
ios
ios-framework
ipa
linux
macos
macos-framework
windows
Web apps don’t support obfuscation.
A web app can be minified, which provides a similar result.
When you build a release version of a Flutter web app,
the web compiler minifies the app. To learn more,
see Build and release a web app.
Obfuscating your app | https://docs.flutter.dev/deployment/obfuscate/index.html |
2efd75044b3c-2 | Obfuscating your app
To obfuscate your app, use the flutter build command
in release mode
with the --obfuscate and --split-debug-info options.
The --split-debug-info option specifies the directory
where Flutter outputs debug files.
In the case of obfuscation, it outputs a symbol map.
For example:
flutter build apk
-obfuscate
-split-debug-info
=/<project-name>/<directory>
Once you’ve obfuscated your binary, save
the symbols file. You need this if you later
want to de-obfuscate a stack trace.
Tip:
The --split-debug-info option can also be used without --obfuscate
to extract Dart program symbols, reducing code size.
To learn more about app size, see Measuring your app’s size. | https://docs.flutter.dev/deployment/obfuscate/index.html |
2efd75044b3c-3 | For detailed information on these flags, run
the help command for your specific target, for example:
flutter build apk
h
If these flags are not listed in the output,
run flutter --version to check your version of Flutter.
Reading an obfuscated stack trace
To debug a stack trace created by an obfuscated app,
use the following steps to make it human readable:
Find the matching symbols file.
For example, a crash from an Android arm64
device would need app.android-arm64.symbols.
Provide both the stack trace (stored in a file)
and the symbols file to the flutter symbolize command.
For example:
$ flutter symbolize -i <stack trace file> -d out/android/app.android-arm64.symbols
For more information on the symbolize command,
run flutter symbolize -h.
Caveat | https://docs.flutter.dev/deployment/obfuscate/index.html |
2efd75044b3c-4 | Caveat
Be aware of the following when coding an app that will
eventually be an obfuscated binary.
Code that relies on matching specific class, function,
or library names will fail.
For example, the following call to expect() won’t
work in an obfuscated binary: | https://docs.flutter.dev/deployment/obfuscate/index.html |
2e40c2e48061-0 | Build and release a web app
Handling images on the web
Choosing a web renderer
Minification
Building the app for release
Embedding a Flutter app into an HTML page
Deploying to the web
PWA Support
During a typical development cycle,
you test an app using flutter run -d chrome
(for example) at the command line.
This builds a debug version of your app.
This page helps you prepare a release version
of your app and covers the following topics:
Handling images on the web
Choosing a web renderer
Minification
Building the app for release
Deploying to the web
Handling images on the web | https://docs.flutter.dev/deployment/web/index.html |
2e40c2e48061-1 | Deploying to the web
Handling images on the web
The web supports the standard Image widget to display images.
However, because web browsers are built to run untrusted code safely,
there are certain limitations in what you can do with images compared
to mobile and desktop platforms.
For more information, see Displaying images on the web.
Choosing a web renderer
By default, the flutter build and flutter run commands
use the auto choice for the web renderer. This means that
your app runs with the HTML renderer on mobile browsers and
CanvasKit on desktop browsers. This is our recommended combination
to optimize for the characteristics of each platform.
For more information, see Web renderers.
Minification
Minification is handled for you when you
create a release build.
A debug build of a web app is not minified and
tree shaking has not been performed.
A profile build is not minified and tree shaking
has been performed. | https://docs.flutter.dev/deployment/web/index.html |
2e40c2e48061-2 | A profile build is not minified and tree shaking
has been performed.
A release build is both minified and tree shaking
has been performed.
Building the app for release
Build the app for deployment using the
flutter build web command.
You can also choose which renderer to use
by using the --web-renderer option (See Web renderers).
This generates the app, including the assets,
and places the files into the /build/web
directory of the project.
The release build of a simple app has the
following structure:
Note:
The canvaskit directory and its contents are only present when the
CanvasKit renderer is selected—not when the HTML renderer is selected. | https://docs.flutter.dev/deployment/web/index.html |
2e40c2e48061-3 | Launch a web server (for example,
python -m http.server 8000,
or by using the dhttpd package),
and open the /build/web directory. Navigate to
localhost:8000 in your browser
(given the python SimpleHTTPServer example)
to view the release version of your app.
Embedding a Flutter app into an HTML page
You can embed a Flutter web app,
as you would embed other content,
in an iframe tag of an HTML file.
In the following example, replace “URL”
with the location of your HTML page:
<iframe
src=
"URL"
></iframe>
Deploying to the web
When you are ready to deploy your app,
upload the release bundle
to Firebase, the cloud, or a similar service.
Here are a few possibilities, but there are
many others:
Firebase Hosting
GitHub Pages | https://docs.flutter.dev/deployment/web/index.html |
2e40c2e48061-4 | Firebase Hosting
GitHub Pages
Google Cloud Hosting
PWA Support
As of release 1.20, the Flutter template for web apps includes support
for the core features needed for an installable, offline-capable PWA app.
Flutter-based PWAs can be installed in the same way as any other web-based
PWA; the settings signaling that your Flutter app is a PWA are provided by
manifest.json, which is produced by flutter create in the web directory.
PWA support remains a work in progress,
so please give us feedback if you see something that doesn’t look right. | https://docs.flutter.dev/deployment/web/index.html |
b437bd2478c5-0 | Build and release a Windows desktop app
Preliminaries
Set up your application in the Partner Center
Packaging and deployment
Manual packaging and deployment for the Microsoft Store
Continuous deployment
Codemagic CI/CD
Updating the app’s version number
Add app icons
Validating the application package
One convenient approach to distributing Windows apps
is the Microsoft Store.
This guide provides a step-by-step walkthrough
of packaging and deploying a Flutter app in this way.
Note:
You are not required to publish Windows apps through the
Microsoft Store, particularly if you prefer more control
over the distribution experience or don’t want to deal
with the certification process. The Microsoft documentation
includes more information about traditional installation
approaches, including Windows Installer.
Preliminaries | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-1 | Preliminaries
Before beginning the process of releasing
a Flutter Windows desktop app to the Microsoft Store,
first confirm that it satisfies Microsoft Store Policies.
Also, you must join the
Microsoft Partner Network to be able to submit apps.
Set up your application in the Partner Center
Manage an application’s life cycle in the
Microsoft Partner Center.
First, reserve the application name and
ensure that the required rights to the name exist.
Once the name is reserved, the application
will be provisioned for services (such as
push notifications), and you can start adding add-ons.
Options such as pricing, availability,
age ratings, and category have to be
configured together with the first submission
and are automatically retained
for the subsequent submissions.
Packaging and deployment
Manual packaging and deployment for the Microsoft Store
Check out MSIX packaging
to learn about packaging
Flutter Windows desktop applications. | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-2 | Note that each product has a unique identity,
which the Store assigns.
If the package is being built manually,
you have to include its identity details
manually during the packaging.
The essential information can be retrieved
from the Partner Center using the following instructions:
In the Partner Center, navigate to the application.
Select Product management.
Retrieve the package identity name, publisher,
and publisher display name by clicking Product identity.
After manually packaging the application,
manually submit it to the
Microsoft Partner Center.
You can do this by creating a new submission,
navigating to Packages,
and uploading the created application package.
Continuous deployment
In addition to manually creating and deploying the package,
you can automate the build, package, versioning,
and deployment process using CI/CD tooling after having submitted
the application to the Microsoft Store for the first time.
Codemagic CI/CD | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-3 | Codemagic CI/CD
Codemagic CI/CD uses the
msix pub package to package
Flutter Windows desktop applications.
For Flutter applications, use either the
Codemagic Workflow Editor
or codemagic.yaml
to package the application and deploy it
to the Microsoft Partner Center.
Additional options (such as the list of
capabilites and language resources
contained in the package)
can be configured using this package.
For publishing, Codemagic uses the
Partner Center submission API;
so, Codemagic requires
associating the Azure Active Directory
and Partner Center accounts.
Updating the app’s version number
For apps published to the Microsoft Store,
the version number must be set during the
packaging process.
The default version number of the app is 1.0.0.0. | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-4 | The default version number of the app is 1.0.0.0.
Note:
Microsoft Store apps are not allowed to have a
Version with a revision number other than zero.
Therefore, the last number of the version must
remain zero for all releases.
Ensure that you follow Microsoft’s
versioning guidelines.
For apps not published to the Microsoft Store, you
can set the app’s executable’s file and product versions.
The executable’s default file version is 1.0.0.1,
and its default product version is 1.0.0+1. To update these,
navigate to the pubspec.yaml file and update the
following line:
version
1.0.0+1
The build name is three numbers separated by dots,
followed by an optional build number that is separated
by a +. In the example above, the build name is 1.0.0
and the build number is 1. | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-5 | The build name becomes the first three numbers of the
file and product versions, while the build number becomes
the fourth number of the file and product versions.
Both the build name and number can be overridden in
flutter build windows by specifying --build-name and
--build-number, respectively.
Note:
Flutter projects created before Flutter 3.3
need to be updated to set the executable’s version
information. For more information,
refer to the version migration guide.
Add app icons
To update the icon of a Flutter Windows
desktop application before packaging use the
following instructions:
In the Flutter project, navigate to
windows\runner\resources.
Replace the app_icon.ico with the desired icon.
If the name of the icon is other than app_icon.ico,
proceed to change the IDI_APP_ICON value in the
windows\runner\Runner.rc file to point to the new path. | https://docs.flutter.dev/deployment/windows/index.html |
b437bd2478c5-6 | When packaging with the msix pub package,
the logo path can also be configured inside the pubspec.yaml file.
To update the application image in the Store listing,
navigate to the Store listing step of the submission
and select Store logos.
From there, you can upload the logo with
the size of 300 x 300 pixels.
All uploaded images are retained for subsequent submissions.
Validating the application package
Before publication to the Microsoft Store,
first validate the application package locally.
Windows App Certification Kit
is a tool included in the
Windows Software Development Kit (SDK).
To validate the application:
Launch Windows App Cert Kit.
Select the Flutter Windows desktop package
(.msix, .msixbundle etc).
Choose a destination for the test report.
The report might contain important warnings and information,
even if the certification passes. | https://docs.flutter.dev/deployment/windows/index.html |
eeb0280474c9-0 | Accessibility
a11y & i18n
Accessibility
Inspecting accessibility support
Large fonts
Example
Screen readers
Sufficient contrast
Building with accessibility in mind
Testing accessibility on mobile
Testing accessibility on web
Accessibility release checklist
More information
Ensuring apps are accessible to a broad range of users is an essential
part of building a high-quality app. Applications that are poorly
designed create barriers to people of all ages. The UN Convention on
the Rights of Persons with Disabilities states the moral and legal
imperative to ensure universal access to information systems; countries
around the world enforce accessibility as a requirement; and companies
recognize the business advantages of maximizing access to their services. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-1 | We strongly encourage you to include an accessibility checklist
as a key criteria before shipping your app. Flutter is committed to
supporting developers in making their apps more accessible, and includes
first-class framework support for accessibility in addition to that
provided by the underlying operating system, including:
Large fonts
Render text widgets with user-specified font sizes
Screen readers
Communicate spoken feedback about UI contents
Sufficient contrast
Render widgets with colors that have sufficient contrast
Details of these features are discussed below.
Inspecting accessibility support
In addition to testing for these specific topics,
we recommend using automated accessibility scanners:
For Android:
Install the Accessibility Scanner for Android
Enable the Accessibility Scanner from
Android Settings > Accessibility >
Accessibility Scanner > On
Navigate to the Accessibility Scanner ‘checkbox’
icon button to initiate a scan | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-2 | For iOS:
Open the iOS folder of your Flutter app in Xcode
Select a Simulator as the target, and click Run button
In Xcode, select
Xcode > Open Developer Tools > Accessibility Inspector
In the Accessibility Inspector,
select Inspection > Enable Point to Inspect,
and then select the various user interface elements in running
Flutter app to inspect their accessibility attributes
In the Accessibility Inspector,
select Audit in the toolbar, and then
select Run Audit to get a report of potential issues
For web:
Open Chrome DevTools (or similar tools in other browsers)
Inspect the HTML tree containing the ARIA attributes generated by Flutter.
In Chrome, the “Elements” tab has a “Accessibility” sub-tab
that can be used to inspect the data exported to semantics tree
Large fonts | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-3 | Large fonts
Both Android and iOS contain system settings to configure the desired font
sizes used by apps. Flutter text widgets respect this OS setting when
determining font sizes.
Font sizes are calculated automatically by Flutter based on the OS setting.
However, as a developer you should make sure your layout has enough room to
render all its contents when the font sizes are increased.
For example, you can test all parts of your app on a small-screen
device configured to use the largest font setting.
Example
The following two screenshots show the standard Flutter app
template rendered with the default iOS font setting,
and with the largest font setting selected in iOS accessibility settings.
Screen readers
For mobile, screen readers (TalkBack, VoiceOver) enable visually
impaired users to get spoken feedback about the contents of the screen
and interact with the UI via gestures on mobile and keyboard shortcuts on desktop.
Turn on VoiceOver or TalkBack on your mobile device and navigate around your app. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-4 | To turn on the screen reader on your device, complete the following steps:
TalkBack on Android
VoiceOver on iPhone
Browsers
Desktop
On your device, open Settings.
Select Accessibility and then TalkBack.
Turn ‘Use TalkBack’ on or off.
Select Ok.
To learn how to find and customize Android’s accessibility features, view this video.
On your device, open Settings > Accessibility > VoiceOver
Turn the VoiceOver setting on or off
To learn how to find and customize iOS accessibility features, view this video.
For web, the following screen readers are currently supported:
Mobile Browsers:
iOS - VoiceOver
Android - TalkBack
Desktop Browsers:
MacOS - VoiceOver | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-5 | Desktop Browsers:
MacOS - VoiceOver
Windows - JAWs & NVDA
Screen Readers users on web will need to toggle
“Enable accessibility” button to build the semantics tree.
Users can skip this step if you programmatically auto-enable
accessibility for your app using this API:
RendererBinding.instance.setSemanticsEnabled(true)
Windows comes with a screen reader called Narrator
but some developers recommend using the more popular
NVDA screen reader. Learn about using NVDA to test
Windows apps here.
On a Mac, you can use the desktop version of VoiceOver,
which is included in macOS.
On Linux, a popular screen reader is called Orca.
It comes pre-installed with some distributions
and is available on package repositories such as apt.
Learn about using Orca
here. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-6 | Check out this video demo to see
Victor Tsaran, who leads the Accessibility program for Material Design,
using VoiceOver with the Flutter Gallery web app.
Flutter’s standard widgets generate an accessibility tree automatically.
However, if your app needs something different, it can be customized
using the Semantics widget.
Sufficient contrast
Sufficient color contrast makes text and images easier to read.
Along with benefitting users with various visual impairments,
sufficient color contrast helps all users when viewing an interface
on devices in extreme lighting conditions,
such as when exposed to direct sunlight or on a display with low
brightness.
The W3C recommends:
At least 4.5:1 for small text (below 18 point regular or 14 point bold)
At least 3.0:1 for large text (18 point and above regular or 14 point and
above bold)
Building with accessibility in mind | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-7 | Building with accessibility in mind
Ensuring your app can be used by everyone means building accessibility
into it from the start. For some apps, that’s easier said than done.
In the video below, two of our engineers take a mobile app from a dire
accessibility state to one that takes advantage of Flutter’s built-in
widgets to offer a dramatically more accessible experience.
Testing accessibility on mobile
Test your app using Flutter’s
Accessibility Guideline API.
This API checks if your app’s UI meets Flutter’s accessibility recommendations.
These cover recommendations for text contrast, target size, and target labels.
The following example shows how to use the Guideline API on Name Generator.
You created this app as part of the
Write your first Flutter app codelab.
Each button on the app’s main screen serves as a tappable target
with text represented in 18 point. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-8 | You can add Guideline API tests
in test/widget_test.dart of your app directory, or as a separate test
file (such as test/a11y_test.dart in the case of the Name Generator).
Testing accessibility on web
You can debug accessibility by visualizing the semantic nodes created for your web app
using the following command line flag in profile and release modes:
flutter run
d chrome
-profile
-dart-define
FLUTTER_WEB_DEBUG_SHOW_SEMANTICS
true
With the flag activated, the semantic nodes appear on top of the widgets;
you can verify that the semantic elements are placed where they should be.
If the semantic nodes are incorrectly placed, please file a bug report.
Accessibility release checklist
Here is a non-exhaustive list of things to consider as you prepare your
app for release. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-9 | Active interactions. Ensure that all active interactions do
something. Any button that can
be pushed should do something when pushed. For example, if you have a
no-op callback for an onPressed event, change it to show a SnackBar
on the screen explaining which control you just pushed.
Screen reader testing. The screen reader should be able to
describe all controls on the page when you tap on them, and the
descriptions should be intelligible. Test your app with TalkBack
(Android) and VoiceOver (iOS).
Contrast ratios. We encourage you to have a contrast ratio of at
least 4.5:1 between controls or text and the background, with the
exception of disabled components. Images should also be vetted for
sufficient contrast.
Context switching. Nothing should change the user’s context
automatically while typing in information. Generally, the widgets
should avoid changing the user’s context without some sort of
confirmation action. | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
eeb0280474c9-10 | Tappable targets. All tappable targets should be at least 48x48
pixels.
Errors. Important actions should be able to be undone. In fields
that show errors, suggest a correction if possible.
Color vision deficiency testing. Controls should be usable and
legible in colorblind and grayscale modes.
Scale factors. The UI should remain legible and usable at very
large scale factors for text size and display scaling.
More information
For more information, particularly about how to configure
the semantics tree,
see the following articles written by community members:
A deep dive into Flutter’s accessibility widgets
Semantics in Flutter | https://docs.flutter.dev/development/accessibility-and-localization/accessibility/index.html |
7fc538c9fab6-0 | Accessibility & internationalization
a11y & i18n
Topics:
Accessibility
Internationalization | https://docs.flutter.dev/development/accessibility-and-localization/index.html |
84c3db05f57f-0 | Internationalizing Flutter apps
a11y & i18n
i18n
Introduction to localizations in Flutter
Setting up an internationalized app: the Flutter_localizations package
Overriding the Locale
Adding your own localized messages
Placeholders, plurals, and selects
Escaping syntax
Messages with numbers and currencies
Messages with dates
Localizing for iOS: Updating the iOS app bundle
Advanced topics for further customization
Advanced locale definition
Tracking the locale: The Locale class and the Localizations widget
Specifying the app’s supportedLocales parameter
Configuring the l10n.yaml file
How internationalization in Flutter works
Loading and retrieving localized values
Defining a class for the app’s localized resources
Adding support for a new language
Alternative internationalization workflows | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-1 | Alternative internationalization workflows
An alternative class for the app’s localized resources
Using the Dart intl tools
What you’ll learn
How to track the device’s locale (the user’s preferred language).
How to enable locale-specific Material or Cupertino widgets.
How to manage locale-specific app values.
How to define the locales an app supports.
If your app might be deployed to users who speak another language then
you’ll need to internationalize it. That means you need to write
the app in a way that makes it possible to localize values like text
and layouts for each language or locale that the app
supports. Flutter provides widgets and classes that help with
internationalization and the Flutter libraries themselves are
internationalized. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-2 | This page covers concepts and workflows necessary to localize a
Flutter application using the MaterialApp and CupertinoApp
classes, as most apps are written that way. However, applications
written using the lower level WidgetsApp class can also
be internationalized using the same classes and logic.
Sample internationalized apps
If you’d like to start out by reading the code for an internationalized
Flutter app, here are two small examples. The first one is intended to
be as simple as possible, and the second one uses the APIs and tools
provided by the intl package.
If Dart’s intl package is new to you,
see Using the Dart intl tools.
Minimal internationalization
Internationalization based on the intl package
Introduction to localizations in Flutter
This section provides a tutorial on how to internationalize
a new Flutter application, along with any additional setup that a
target platform might require. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-3 | Setting up an internationalized app: the Flutter_localizations package
By default, Flutter only provides US English localizations.
To add support for other languages,
an application must specify additional MaterialApp (or CupertinoApp)
properties, and include a package called
flutter_localizations. As of January 2023,
this package supports 79 languages.
To begin, start by creating a new Flutter application
in a directory of your choice with the flutter create command.
flutter create <name_of_flutter_app>
To use flutter_localizations,
add the package as a dependency to your pubspec.yaml file,
as well as the intl package:
flutter pub add flutter_localizations
-sdk
=flutter
flutter pub add intl:any
This results in a pubspec.yml with the following entries: | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-4 | This results in a pubspec.yml with the following entries:
Then import the flutter_localizations library and specify
localizationsDelegates and supportedLocales for
your MaterialApp or CupertinoApp:
After introducing the flutter_localizations package
and adding the code above, the Material and Cupertino
packages should now be correctly localized in
one of the 78 supported locales. Widgets should be
adapted to the localized messages, along with
correct left-to-right and right-to-left layout.
Try switching the target platform’s locale to
Spanish (es) and notice that the messages should
be localized.
Apps based on WidgetsApp are similar except that the
GlobalMaterialLocalizations.delegate isn’t needed.
The full Locale.fromSubtags constructor is preferred
as it supports scriptCode, though the Locale default
constructor is still fully valid. | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-5 | The elements of the localizationsDelegates list are factories that produce
collections of localized values. GlobalMaterialLocalizations.delegate
provides localized strings and other values for the Material Components
library. GlobalWidgetsLocalizations.delegate defines the default
text direction, either left-to-right or right-to-left, for the widgets
library.
More information about these app properties, the types they
depend on, and how internationalized Flutter apps are typically
structured, can be found below.
Overriding the Locale
Localizations.override is a factory constructor for the Localizations widget
that allows for (the typically rare) situation where a section of your application
needs to be localized to a different locale than the locale configured for your device.
To observe this behavior, add a call to Localizations.override
and a simple CalendarDatePicker:
Hot reload the app and observe that the CalendarDatePicker widget re-renders in Spanish.
Adding your own localized messages | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-6 | Adding your own localized messages
Once the flutter_localizations package is added, use the
following instructions to add localized text to your application.
Add the intl package as a dependency,
using the version pinned by flutter_localizations with any:
$ flutter pub add intl:any
Then in the pubspec.yaml file, enable the generate flag.
This is added to the section of the pubspec that is specific to Flutter,
and usually comes later in the pubspec file.
# The following section is specific to Flutter.
flutter:
generate: true # Add this line
Add a new yaml file to the root directory of the Flutter project
called l10n.yaml with the following content:
arb-dir: lib/l10n
template-arb-file: app_en.arb
output-localization-file: app_localizations.dart | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
84c3db05f57f-7 | This file configures the localization tool; in this example,
the input files are located in ${FLUTTER_PROJECT}/lib/l10n,
the app_en.arb file provides the template, and the generated
localizations are placed in the app_localizations.dart file.
In ${FLUTTER_PROJECT}/lib/l10n,
add the app_en.arb template file. For example:
{
"helloWorld": "Hello World!",
"@helloWorld": {
"description": "The conventional newborn programmer greeting"
}
}
Next, add an app_es.arb file in the same directory with a
Spanish translation of the same message:
{
"helloWorld": "¡Hola Mundo!"
} | https://docs.flutter.dev/development/accessibility-and-localization/internationalization/index.html |
Subsets and Splits