Setting up a complete Flutter Android development environment requires more than installing
Flutter alone. Android Studio provides the Android development environment, the Android SDK
provides the platform and build tools, the Android Emulator provides a virtual Android device,
and Flutter connects these components so that Flutter applications can be built, run, and
debugged on Android.
Flutter's current Android setup documentation specifically requires the Flutter SDK in addition
to Android Studio. Installing only the Flutter plugin is not sufficient; the Flutter SDK and
its bin directory must also be configured.
target="_blank" rel="noopener noreferrer">
JustAcademy Flutter Training
target="_blank" rel="noopener noreferrer">
Register for Flutter Course Demo
A Flutter Android development environment can be understood as four major components:
These components work together to provide a complete environment for developing Flutter
applications for Android.
| Component | Main Purpose |
|---|---|
| Android Studio | IDE and Android development environment. |
| Android SDK | Provides Android platforms, build tools, platform tools, and other SDK components. |
| Android Emulator | Runs a virtual Android device on your computer. |
| Flutter SDK | Provides Flutter framework, Dart, CLI, and Flutter development tools. |
| Flutter Plugin | Adds Flutter development support to Android Studio. |
Android Studio is the official IDE for Android application development. It provides an
integrated environment for writing code, managing Android projects, debugging applications,
using Android SDK tools, and running Android devices and emulators.
Android Studio is based on IntelliJ IDEA and includes Android-specific development features,
including Gradle integration, testing tools, lint tools, and an Android Emulator.
Android Studio is also commonly used as the IDE for Flutter Android development when the
Flutter and Dart plugins are installed.
Flutter applications are written using Dart and use the Flutter framework, but Android
deployment requires Android-specific tooling. Android Studio provides access to those Android
tools.
Android SDK stands for Android Software Development Kit. It is a collection
of tools and platform packages required to develop, compile, test, and debug Android
applications.
For Flutter Android development, the Android SDK provides the underlying Android tooling that
Flutter uses when building an Android application.
SDK Platforms contain Android API platform packages. A platform package is required when
building an application against that Android API level.
Android SDK Manager provides access to different Android platform versions.
Android Studio
↓
Tools
↓
SDK Manager
If Android Studio is displaying its welcome screen, SDK Manager can also be accessed through
the additional actions menu.
The SDK Platforms tab allows you to install and manage Android API platforms and related
system images.
A system image is required when you want to create an Android Emulator using a particular
Android version.
Android SDK Build-Tools contain utilities required to compile and package Android applications.
They are used as part of the Android build process.
For Flutter Android applications, the Android build system uses the Android tooling configured
through the project and installed SDK components.
Platform-Tools provide utilities for communicating with Android devices.
One of the most important tools included in Platform-Tools is ADB.
ADB stands for Android Debug Bridge. It allows the computer to communicate
with Android devices and emulators.
adb devices
This command can be used to check whether an Android device or emulator is available through
ADB.
Android SDK Command-Line Tools provide command-line utilities for managing Android SDK
components and performing Android development tasks.
They are particularly useful for command-line workflows and automation.
Flutter setup may depend on Android SDK command-line tooling being correctly installed and
available through the Android development environment.
Android Emulator is software that creates a virtual Android device on your computer. It allows
developers to run and test applications without requiring a physical Android phone.
The Android Emulator is included with Android Studio and can be managed through Device
Manager.
AVD stands for Android Virtual Device.
An AVD is a configuration that defines the characteristics of a virtual Android device.
It includes information such as the hardware profile, system image, storage, and other
device properties.
Android Studio's Device Manager is used to create and manage AVDs.
| Feature | Android Studio | Android SDK | Emulator |
|---|---|---|---|
| Type | IDE | Development toolkit | Virtual device |
| Purpose | Development environment | Build and platform tools | Run Android apps virtually |
| Provides editor | Yes | No | No |
| Provides SDK tools | Manages them | Yes | Uses them |
| Runs Android application | Can launch/debug | Provides tooling | Yes |
| Creates AVD | Yes, through Device Manager | Supports AVD tooling | Represents the created device |
Flutter SDK is the development toolkit provided by Flutter for building applications using
Dart and the Flutter framework.
The Flutter SDK is different from the Android SDK. Flutter SDK provides Flutter development
capabilities, while Android SDK provides Android-specific development tooling.
The Flutter plugin adds Flutter development support to Android Studio.
Android Studio
↓
File
↓
Settings
↓
Plugins
↓
Marketplace
↓
Search "Flutter"
↓
Install
↓
Restart Android Studio
On macOS, the Settings/Preferences entry is available from the Android Studio application
menu.
The Flutter plugin works with Dart support to provide features such as Flutter project
creation, Dart editing, debugging, and Flutter development tools.
A common beginner mistake is assuming that installing the Android SDK installs Flutter.
These are separate development toolkits.
| Flutter SDK | Android SDK |
|---|---|
| Develops Flutter applications. | Provides Android platform tooling. |
| Includes Dart. | Includes Android SDK components. |
| Provides flutter command. | Provides Android build/device tools. |
| Used for Flutter code. | Used for Android-specific build and device operations. |
Before running a Flutter Android application, the following components should be configured:
First install the Flutter SDK according to your operating system.
After installing Flutter, verify it with:
flutter --version
Also verify Dart:
dart --version
Flutter's Android setup documentation emphasizes that installing the Flutter plugin is not
enough; the Flutter SDK itself must be installed and its bin directory must be
available in PATH.
Download Android Studio from the official Android Developers website.
target="_blank" rel="noopener noreferrer">
Download Android Studio
Open Android Studio and install the Flutter plugin.
File
↓
Settings
↓
Plugins
↓
Marketplace
↓
Flutter
↓
Install
↓
Restart
Dart support is required for Flutter development and may be installed or enabled along with
the Flutter plugin.
Android Studio needs to know where your Flutter SDK is located.
C:\Users\Student\develop\flutter
The Flutter SDK root should be selected rather than the bin directory.
C:\Users\Student\develop\flutterC:\Users\Student\develop\flutter\bin
Android Studio provides SDK Manager for installing and managing Android SDK components.
Android Studio
↓
Tools
↓
SDK Manager
From the Android Studio welcome screen, SDK Manager can also be accessed from the additional
actions menu.
Open the SDK Platforms tab.
Install the Android platform versions needed for your development environment and projects.
The Android SDK platform package is required to compile applications for that Android API
level, while system images are used for emulator configurations.
Open the SDK Tools tab.
Commonly relevant components include:
Additional components such as NDK and CMake may be required by particular Flutter plugins or
projects that use native Android code.
After installing the Android SDK, Flutter may ask you to accept Android SDK licenses.
Run:
flutter doctor --android-licenses
Read the displayed license terms and accept the required licenses.
After completing the process, run:
flutter doctor
Flutter's official Android setup documentation uses this command to review and accept Android
SDK licenses.
Device Manager is used to create and manage Android Virtual Devices.
Android Studio
↓
Tools
↓
Device Manager
From the welcome screen, Device Manager can also be accessed through the additional actions
menu.
An Android Virtual Device simulates a particular Android device configuration.
Android's Device Manager documentation describes an AVD as a configuration containing a
hardware profile, system image, storage area, and other device properties.
A system image contains the Android operating system that will run inside the emulator.
Choose an image compatible with your development computer's processor architecture and the
Android version you want to test.
Depending on the computer architecture, Android Studio may provide different image choices,
such as x86_64 or ARM64 variants.
Images labeled Google APIs include Google APIs, while images labeled Google Play include the
Google Play Store.
Emulator performance can be improved using hardware acceleration when supported by the
development computer.
Flutter's current Android setup instructions recommend selecting a graphics option that uses
hardware acceleration when configuring an emulator.
After creating the AVD, start it from Device Manager.
Android Studio
↓
Device Manager
↓
Select AVD
↓
Run
Wait for the Android operating system to start completely.
Open a terminal and run:
flutter emulators
This lists configured emulators available to Flutter.
You can also run:
flutter devices
The running Android Emulator should appear as an available Android device.
Run:
flutter doctor
For detailed diagnostic information:
flutter doctor -v
If Flutter Doctor reports a problem, follow the suggested action and run the command again.
Run:
flutter devices
A successful configuration should show at least one available Android target if an emulator
or physical device is connected.
flutter emulators && flutter devices
This can be useful for quickly checking configured emulators and available Flutter devices.
After the environment is configured, create a new Flutter project.
flutter create my_flutter_appMove into the project:
cd my_flutter_appNew Flutter Project
↓
Flutter
↓
Select Flutter SDK
↓
Next
↓
Project Name
↓
Finish
Start the Android Emulator and open the Flutter project.
Then run:
flutter run
Alternatively, select the emulator from Android Studio's Flutter target/device selector and
click the Run button.
import 'package:flutter/material.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
debugShowCheckedModeBanner: false,
home: Scaffold(
appBar: AppBar(
title: const Text('Flutter Android Setup'),
),
body: const Center(
child: Text(
'Hello Flutter!',
style: TextStyle(fontSize: 24),
),
),
),
);
}
}
Run the application:
flutter run
The application should appear inside the selected Android emulator or connected physical
Android device.
my_flutter_app/
│
├── android/
│ ├── app/
│ └── ...
│
├── ios/
├── lib/
│ └── main.dart
│
├── test/
├── web/
├── windows/
├── macos/
├── linux/
│
├── pubspec.yaml
└── README.md
The android/ directory contains Android-specific project files.
When you need to configure Android-specific settings, Gradle configuration, Android manifest
settings, native Android code, or platform-specific integrations, this directory becomes
important.
Flutter must be available from the command line.
The Flutter SDK's bin directory should be included in the operating system's
PATH.
C:\Users\Student\develop\flutter\binflutter --version
If this command works from a new terminal, Flutter is generally available through PATH.
Android Studio normally manages the Android SDK installation and its location. You can see
the SDK location from SDK Manager.
C:\Users\Student\AppData\Local\Android\Sdk
The exact location depends on the operating system and installation configuration.
If Flutter cannot locate Android tooling, run:
flutter doctor -v
The diagnostic output can help identify Android SDK configuration problems.
| Android Emulator | Physical Android Device |
|---|---|
| Runs virtually on the computer. | Runs on a real Android phone or tablet. |
| No physical device required. | Requires an Android device. |
| Can test different device profiles. | Provides real hardware behavior. |
| Requires computer resources. | Uses the device's hardware. |
| Useful for early development and testing. | Important for real-device testing. |
Android's documentation recommends testing on a real device before release, while the
Emulator is useful for testing different Android versions and screen configurations.
You can run Flutter applications on a real Android device instead of an emulator.
flutter devices.adb devicesflutter devices
Flutter provides a fast development cycle through Stateful Hot Reload.
After changing Dart code, developers can use Hot Reload to quickly see many UI and code
changes without restarting the entire application.
Write Code
↓
Run Application
↓
Modify Code
↓
Save
↓
Hot Reload
↓
Check Result| Hot Reload | Hot Restart |
|---|---|
| Applies many code changes quickly. | Restarts the Flutter application. |
| Usually preserves current application state. | Resets application state. |
| Useful for UI development. | Useful when a complete application restart is needed. |
Android Studio provides debugging functionality for Flutter applications.
flutter run
Android Studio can also start the application using its Run and Debug actions.
Flutter Inspector helps developers understand and inspect the widget tree of a Flutter
application.
If the terminal displays an error indicating that flutter cannot be found,
Flutter's PATH configuration may be incorrect.
flutter --version
If the command fails:
bin folder.bin path to PATH.flutter --version again.
If flutter doctor reports an Android toolchain problem, check:
Then run:
flutter doctor -v
If the emulator does not appear in Flutter:
flutter emulators.flutter devices.
The Android Emulator requires significant computer resources. Performance depends on CPU,
RAM, storage, graphics, and hardware virtualization support.
If Flutter reports that Android SDK licenses have not been accepted, execute:
flutter doctor --android-licenses
Accept the required licenses and then run:
flutter doctor
If a physical Android device is not detected:
adb devices.flutter devices.flutter doctor.| Command | Purpose |
|---|---|
flutter --version | Check Flutter version. |
dart --version | Check Dart version. |
flutter doctor | Check development environment. |
flutter doctor -v | Display detailed diagnostic information. |
flutter doctor --android-licenses | Review and accept Android SDK licenses. |
flutter devices | List available Flutter devices. |
flutter emulators | List available emulators. |
flutter create my_app | Create a new Flutter project. |
flutter run | Run a Flutter application. |
flutter clean | Remove generated build files. |
flutter pub get | Download project dependencies. |
Install Flutter SDK
↓
Add Flutter bin to PATH
↓
Verify Flutter
↓
Install Android Studio
↓
Install Flutter Plugin
↓
Configure Flutter SDK Path
↓
Open SDK Manager
↓
Install Android SDK
↓
Install SDK Platforms
↓
Install SDK Tools
↓
Accept Android Licenses
↓
Open Device Manager
↓
Create AVD
↓
Download System Image
↓
Configure Emulator
↓
Start Emulator
↓
flutter doctor
↓
flutter devices
↓
Create Flutter Project
↓
flutter run
↓
Test & Debug
Suppose a developer wants to create a Flutter application on Windows.
C:\Users\Student\develop\flutterC:\Users\Student\develop\flutter\binflutter --versionDownload
↓
Install
↓
LaunchSettings
↓
Plugins
↓
Marketplace
↓
Flutter
↓
Install
↓
RestartTools
↓
SDK Manager
↓
SDK Platforms
↓
SDK Tools
↓
Install Required Componentsflutter doctor --android-licensesTools
↓
Device Manager
↓
Create Device
↓
Select Hardware
↓
Select System Image
↓
FinishDevice Manager
↓
Run AVDflutter doctor
flutter devicesflutter create my_flutter_appcd my_flutter_app
flutter run| Setup Item | Completed |
|---|---|
| Flutter SDK installed | ☐ |
| Flutter added to PATH | ☐ |
| Flutter version verified | ☐ |
| Android Studio installed | ☐ |
| Flutter plugin installed | ☐ |
| Dart support enabled | ☐ |
| Flutter SDK path configured | ☐ |
| Android SDK installed | ☐ |
| SDK Platform configured | ☐ |
| SDK Build-Tools installed | ☐ |
| SDK Platform-Tools installed | ☐ |
| SDK Command-Line Tools configured | ☐ |
| Android Emulator installed | ☐ |
| Android licenses accepted | ☐ |
| AVD created | ☐ |
| Emulator started | ☐ |
| flutter doctor verified | ☐ |
| Flutter device detected | ☐ |
| Flutter project created | ☐ |
| Flutter application successfully executed | ☐ |
Android Studio is the official IDE for Android development and provides tools for coding,
debugging, building, testing, and managing Android applications.
Android SDK is a collection of Android development tools, platform packages, build tools,
platform tools, and other components required for Android application development.
Android Emulator is a virtual Android device that runs on a computer and allows developers
to test Android applications without a physical device.
AVD stands for Android Virtual Device. It defines the configuration of a virtual Android
device used by the Android Emulator.
Flutter SDK provides the Flutter framework, Dart SDK, Flutter CLI, and Flutter development
tools. Android SDK provides Android-specific platform and build tooling required to build
and run Android applications.
The Flutter plugin adds Flutter and Dart development functionality to Android Studio,
including Flutter project support, editing, debugging, and development tools.
flutter doctorflutter devicesflutter emulatorsflutter doctor --android-licensesflutter create my_appflutter runflutter doctor is the primary Flutter environment diagnostic command.flutter devices checks available Flutter devices.flutter emulators checks available emulators.
For structured Flutter learning, including Flutter setup, Dart programming, widgets, layouts,
navigation, APIs, state management, and practical application development, explore the
following resource:
target="_blank" rel="noopener noreferrer">
JustAcademy Flutter Training Course
For a course demo and registration:
target="_blank" rel="noopener noreferrer">
Register for Flutter Course Demo
Android Studio, Android SDK, Android Emulator, and Flutter SDK form the core environment for
Flutter Android development. Android Studio provides the development interface, the Android
SDK provides Android-specific tools and platform packages, the Emulator provides a virtual
Android device, and Flutter SDK provides the Flutter and Dart development environment.
A correctly configured environment allows developers to create Flutter projects, run them on
Android devices, use Hot Reload, debug applications, inspect widgets, and build Android
packages.
Complete setup:
Flutter SDK
+
Android Studio
+
Android SDK
+
Flutter Plugin
+
Android Emulator / Physical Device
↓
Complete Flutter Android Development Environment