An APK (Android Package Kit) is the package file format used to install Android applications. In Flutter, an Android APK can be generated from a Flutter project using the flutter build apk command.
Flutter supports both APK and Android App Bundle (AAB) release formats. Google Play generally recommends App Bundles, while APKs are useful for direct installation, testing, and distribution through channels that require APK files. :contentReference[oaicite:0]{index=0}
APK stands for Android Package Kit. It is an installable package containing the components required to install an Android application on a device.
A Flutter APK generally contains the compiled application code, Flutter runtime components, native Android resources, assets, and other required files.
Flutter Project
↓
Dart Code
↓
Flutter Build Process
↓
Android Build System
↓
APK
↓
Android DeviceBefore creating an APK, make sure the Flutter development environment and Android tooling are properly configured.
flutter doctorThe flutter doctor command helps identify problems with the Flutter SDK, Android tooling, connected devices, licenses, and other development requirements.
If you do not already have a project, create one using the Flutter CLI.
flutter create my_appMove into the project directory:
cd my_appmy_app/
├── android/
├── ios/
├── lib/
│ └── main.dart
├── test/
├── web/
├── windows/
├── macos/
├── linux/
├── assets/
├── pubspec.yaml
└── build/The android/ directory contains the Android-specific project configuration used when creating an Android build.
Before creating an APK, make sure all packages declared in pubspec.yaml are resolved.
flutter pub getThis downloads or resolves the dependencies required by the Flutter project.
It is good practice to test the application before generating a release APK.
flutter testYou can also run the application on an Android device or emulator:
flutter runThe basic command for creating an Android APK is:
flutter build apkThe flutter build command defaults to a release build unless another build mode is explicitly selected. :contentReference[oaicite:1]{index=1}
cd my_appflutter doctorflutter pub getflutter testflutter build apkThe generated release APK is placed in the Flutter project's build output directory.
build/app/outputs/flutter-apk/app-release.apkThe exact generated files can vary depending on the build options used.
Source Code
↓
pubspec.yaml
↓
Dependency Resolution
↓
Dart Compilation
↓
Flutter Build
↓
Android/Gradle Build
↓
Release Packaging
↓
APK
↓
Testing / DistributionA debug APK can be useful for development and testing. To explicitly create a debug APK, use:
flutter build apk --debugA debug APK is intended for development/testing and should not be treated as a production release artifact.
Profile mode is designed for performance analysis.
flutter build apk --profileProfile builds are useful when analyzing application performance in an environment closer to release behavior.
A release APK is intended for production-oriented testing and distribution.
flutter build apk --releaseBecause flutter build apk defaults to release mode, the following is also commonly used:
flutter build apk| Mode | Command | Purpose |
|---|---|---|
| Debug | flutter build apk --debug | Development and debugging |
| Profile | flutter build apk --profile | Performance analysis |
| Release | flutter build apk --release | Production-oriented build and distribution |
When you run flutter build apk, several stages take place.
Android devices can use different CPU architectures. Flutter's Android release documentation identifies armeabi-v7a, arm64-v8a, and x86-64 as supported release architectures. :contentReference[oaicite:2]{index=2}
| ABI | Description |
|---|---|
| armeabi-v7a | ARM 32-bit architecture. |
| arm64-v8a | ARM 64-bit architecture. |
| x86_64 | 64-bit x86 architecture, commonly relevant to certain emulators and devices. |
Flutter can generate separate APK files for different Android architectures.
flutter build apk --split-per-abiThis creates separate APKs instead of one APK containing binaries for all supported target ABIs. Flutter's Android documentation recommends split APKs when distributing APKs because a single fat APK can be larger than necessary. :contentReference[oaicite:3]{index=3}
build/app/outputs/flutter-apk/
├── app-armeabi-v7a-release.apk
├── app-arm64-v8a-release.apk
└── app-x86_64-release.apkA fat APK is a single APK that contains binaries for multiple supported ABIs.
flutter build apkThe advantage is that one APK can support multiple architectures. The disadvantage is that the APK can be larger because it contains native binaries that may not be needed by a particular device. :contentReference[oaicite:4]{index=4}
| Feature | Split APK | Fat APK |
|---|---|---|
| Command | flutter build apk --split-per-abi | flutter build apk |
| Number of APKs | Multiple | Single |
| File Size | Usually smaller per architecture | Usually larger |
| Architecture | Architecture-specific | Multiple architectures |
| Distribution | Requires selecting the appropriate APK | Simple single-file distribution |
The Android applicationId uniquely identifies the Android application. It is normally configured in the Android project's Gradle configuration.
defaultConfig {
applicationId = "com.example.myapp"
}For an application intended for distribution, use a unique application ID rather than leaving a generic example identifier. Flutter's Android documentation notes that the application ID identifies the app on Google Play and on Android devices. :contentReference[oaicite:5]{index=5}
Flutter application version information can be specified in pubspec.yaml.
version: 1.0.0+1| Value | Meaning |
|---|---|
| 1.0.0 | Version name |
| 1 | Build number |
For Android, Flutter maps the build name to versionName and the build number to versionCode. :contentReference[oaicite:6]{index=6}
The build name and build number can also be specified during the build.
flutter build apk --build-name=1.2.0 --build-number=10This can be useful when automated build systems need to generate versioned APKs.
The Android manifest is located at:
android/app/src/main/AndroidManifest.xmlIt contains Android-specific application configuration such as the application label and permissions.
android:label="My Flutter App"
android:icon="@mipmap/ic_launcher">
If the Flutter application needs Internet access, verify that the Android manifest contains the required Internet permission.
This is particularly important for applications that communicate with REST APIs, Firebase services, web services, or other Internet-based systems. Flutter's Android release documentation specifically describes reviewing the manifest and adding the Internet permission when the application needs Internet access. :contentReference[oaicite:7]{index=7}
An Android application needs an appropriate launcher icon. Flutter projects include a default launcher icon that can be replaced with a custom icon.
Android launcher resources are commonly located under:
android/app/src/main/res/The Android manifest references the launcher icon through the application's android:icon attribute. :contentReference[oaicite:8]{index=8}
Android release applications need appropriate signing for distribution. For Play Store publishing, Flutter's Android release documentation explains the use of an upload key and Play App Signing. :contentReference[oaicite:9]{index=9}
Keystore
↓
Signing Configuration
↓
Release Build
↓
Signed APKA keystore can be generated using Java's keytool.
keytool -genkey -v -keystore $env:USERPROFILE\upload-keystore.jks `
-storetype JKS -keyalg RSA -keysize 2048 -validity 10000 `
-alias uploadkeytool -genkey -v -keystore ~/upload-keystore.jks \
-keyalg RSA -storetype JKS -keysize 2048 -validity 10000 \
-alias uploadKeep the keystore private and do not commit it to a public source-control repository. :contentReference[oaicite:10]{index=10}
A Flutter Android project can use a key.properties file to reference signing information.
storePassword=
keyPassword=
keyAlias=upload
storeFile=This file contains sensitive information and should be kept private. :contentReference[oaicite:11]{index=11}
Upload Keystore
↓
key.properties
↓
Gradle Signing Configuration
↓
Release Build
↓
Signed APKFlutter's Android release documentation states that R8 code shrinking is enabled by default for release APK and App Bundle builds. :contentReference[oaicite:12]{index=12}
Code shrinking can reduce the amount of unused Android code included in the final application.
Flutter supports Dart code obfuscation for APK builds.
flutter build apk --obfuscate --split-debug-info=build/symbolsObfuscation renames Dart symbols to make the compiled code more difficult to understand. It is not encryption. Flutter recommends securely keeping the generated symbol information because it may be needed to interpret obfuscated stack traces later. :contentReference[oaicite:13]{index=13}
If the project has stale generated files or unexpected build problems, you can clean the build artifacts.
flutter clean
flutter pub get
flutter build apkA clean build is useful for troubleshooting but does not need to be performed before every APK build.
After connecting an Android device with developer options enabled, Flutter provides the flutter install command for installing an APK.
flutter installFlutter's Android release documentation lists connecting the device, navigating to the project, and running flutter install as the installation process. :contentReference[oaicite:14]{index=14}
After creating the APK, test the actual generated application rather than relying only on the development build.
Build APK
↓
Locate app-release.apk
↓
Transfer to Android Device
↓
Install APK
↓
Launch Application
↓
Test FunctionalityFlutter Android flavors can be used when an application has separate configurations such as development, staging, and production.
flutter build apk --flavor stagingThe Flutter documentation provides the --flavor option for building an APK or App Bundle for a configured Android product flavor. :contentReference[oaicite:15]{index=15}
Development
↓
staging flavor
↓
flutter build apk --flavor staging
Production
↓
production flavor
↓
flutter build apk --flavor production
Flavors can be configured to use different API endpoints, themes, application behavior, or other environment-specific settings.
| Feature | APK | AAB |
|---|---|---|
| Full Name | Android Package Kit | Android App Bundle |
| Direct Installation | Yes | Not normally installed directly as a single file |
| Testing | Very convenient | Can be tested through appropriate tooling/channels |
| Google Play | Supported distribution format in relevant contexts | Preferred format |
| Flutter Command | flutter build apk | flutter build appbundle |
Google Play recommends app bundles because they allow more efficient delivery to users, while APKs remain useful for direct distribution and stores that do not support app bundles. :contentReference[oaicite:16]{index=16}
Possible Cause: Flutter is not correctly added to the system PATH.
Check:
flutter doctorPossible Cause: Android SDK or Android development environment is not correctly configured.
Solution: Open Android Studio, verify the Android SDK configuration, and run:
flutter doctorPossible Cause: Packages are missing or incompatible.
Try:
flutter pub getPossible Causes:
A clean rebuild can sometimes help identify whether generated files are contributing to the problem.
flutter clean
flutter pub get
flutter build apkPossible Cause: An asset path is missing or incorrectly declared in pubspec.yaml.
flutter:
assets:
- assets/images/Possible Cause: The keystore, signing properties, alias, password, or Gradle signing configuration is incorrect.
flutter pub get after dependency changes.flutter doctor errors.key.properties to public source control.flutter doctor before troubleshooting environment problems.1. Create Flutter Project
↓
2. Configure Application
↓
3. Add Dependencies
↓
4. Configure Assets
↓
5. Set Application ID
↓
6. Set Version
↓
7. Configure Android Settings
↓
8. Configure Signing
↓
9. Run Tests
↓
10. Build Release APK
↓
11. Install APK
↓
12. Test APK
↓
13. Distribute APKflutter doctor
flutter pub get
flutter test
flutter clean
flutter pub get
flutter build apk --releaseflutter clean
flutter pub get
flutter build apk --release --split-per-abiThis produces separate release APKs for supported Android ABIs instead of one fat APK. :contentReference[oaicite:17]{index=17}
flutter build apk --release \
--obfuscate \
--split-debug-info=build/symbolsOn Windows, use the appropriate command-line continuation syntax for the shell being used.
Suppose you have developed a Flutter food-delivery application containing login, restaurant listing, cart, payment, and order tracking.
Flutter Food Delivery App
↓
Test Login
↓
Test Restaurant Listing
↓
Test Cart
↓
Test Payment
↓
Test Orders
↓
Configure Version
↓
Configure Signing
↓
Build APK
↓
app-release.apk
↓
Install on Android Device
↓
Final Testing
↓
Distribution| Task | Status |
|---|---|
| Flutter environment checked | ☐ |
| Android SDK configured | ☐ |
| Dependencies installed | ☐ |
| Application tested | ☐ |
| Application ID configured | ☐ |
| Version updated | ☐ |
| Assets verified | ☐ |
| Signing configured | ☐ |
| Release APK generated | ☐ |
| APK installed on device | ☐ |
| Release APK tested | ☐ |
APK stands for Android Package Kit and is an installable Android application package.
flutter build apkflutter build apk --releaseflutter build apk --split-per-abiA fat APK is a single APK containing binaries for multiple Android architectures.
An APK is an installable Android package, while an AAB is an Android App Bundle intended primarily for store distribution and optimized delivery.
It is generated under the project's build/app/outputs/flutter-apk/ directory.
Signing establishes the application's signing identity and is required for appropriate Android release distribution.
flutter build apk --obfuscate --split-debug-info=build/symbolsflutter installCreating an Android APK in Flutter involves preparing the Flutter project, resolving dependencies, testing the application, configuring Android settings, selecting the appropriate build mode, and running the Flutter build command.
The most important commands are:
flutter doctor
flutter pub get
flutter test
flutter clean
flutter build apk
flutter build apk --release
flutter build apk --debug
flutter build apk --profile
flutter build apk --split-per-abi
flutter installFor production distribution, also pay attention to application ID, versioning, release signing, code shrinking, testing, and secure handling of signing credentials. When publishing through Google Play, consider using an Android App Bundle because Google Play recommends AAB for more efficient application delivery. :contentReference[oaicite:18]{index=18}
JustAcademy Flutter Training Course
Register for Flutter Course Demo
