Flutter in Android Studio: The Complete Production Setup & Build Guide

Introduction

Building Android applications with Flutter inside Android Studio offers one of the most productive mobile development workflows available today. You get the hot-reload agility of Flutter combined with Android Studio's unmatched native profiling tools, layout inspectors, logcat debugging, and Gradle build optimizations.

However, moving from a hobbyist setup to a production-ready Android architecture requires configuring modern Gradle Kotlin DSL (build.gradle.kts), managing Android SDK 34+ permissions, setting up R8/ProGuard code shrinking, and securing release keystores.

In this practical engineering guide, we walk through the exact steps we use at Dev Pattern Labs to configure, optimize, and build enterprise-grade Flutter Android apps using Android Studio.

---

Prerequisites

• Android Studio (Hedgehog, Iguana, or newer) installed with the official Flutter and Dart plugins
• Flutter SDK 3.24+ added to your system environment PATH
• JDK 17 or JDK 21 (required for Gradle 8+)
• Basic understanding of Dart and mobile app lifecycles

---

1. Android Studio Workspace & SDK Tooling Setup

Before writing any Flutter code, your Android toolchain must be clean.

Run the diagnostic in your terminal:

flutter doctor -v

If Android licenses or command-line tools are missing, open Android Studio → Settings → Languages & Frameworks → Android SDK → SDK Tools tab:

1. Check Android SDK Command-line Tools (latest)
2. Check Android SDK Build-Tools 34.0.0
3. Check Android Emulator
4. Click Apply and accept the licenses

Accept all licenses via terminal:

flutter doctor --android-licenses

Once every checkbox is green, create or open your Flutter project in Android Studio:

flutter create --org com.devpatternlabs --platforms android,ios my_mobile_app

---

2. Modern Gradle 8+ Kotlin DSL Migration

Legacy Flutter projects use Groovy (build.gradle). Modern Android Studio uses Kotlin DSL (build.gradle.kts) for type safety, autocomplete, and cleaner dependency declarations.

Root android/settings.gradle.kts

pluginManagement {
    val flutterSdkPath = run {
        val properties = java.util.Properties()
        file("local.properties").inputStream().use { properties.load(it) }
        val flutterSdkPath = properties.getProperty("flutter.sdk")
        require(flutterSdkPath != null) { "flutter.sdk not set in local.properties" }
        flutterSdkPath
    }

    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")

    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

plugins {
    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
    id("com.android.application") version "8.5.2" apply false
    id("org.jetbrains.kotlin.android") version "2.0.20" apply false
}

include(":app")

App Level android/app/build.gradle.kts

Configure compile and target SDK versions with strict Java 17 compatibility:

plugins {
    id("com.android.application")
    id("kotlin-android")
    id("dev.flutter.flutter-gradle-plugin")
}

android {
    namespace = "com.devpatternlabs.mymobileapp"
    compileSdk = 34
    ndkVersion = flutter.ndkVersion

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = "17"
    }

    defaultConfig {
        applicationId = "com.devpatternlabs.mymobileapp"
        minSdk = 24 // Android 7.0 (covers 95%+ of active devices)
        targetSdk = 34 // Android 14 requirements
        versionCode = flutter.versionCode
        versionName = flutter.versionName
        multiDexEnabled = true
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("release")
        }
    }
}

flutter {
    source = "../.."
}

---

3. R8 / ProGuard Optimization for Flutter

When releasing your APK or Android App Bundle (AAB), code shrinking (minifyEnabled = true) cuts down app size by 30–50% and obfuscates native Kotlin code.

However, Flutter plugins using reflection need explicit ProGuard keep rules.

Create android/app/proguard-rules.pro:

# Flutter Wrapper
-keep class io.flutter.app.** { *; }
-keep class io.flutter.plugin.**  { *; }
-keep class io.flutter.util.**  { *; }
-keep class io.flutter.view.**  { *; }
-keep class io.flutter.** { *; }
-keep class io.flutter.plugins.** { *; }

# Keep native methods and JNI bindings
-keepclasseswithmembernames class * {
    native <methods>;
}

# Preserve serialized JSON models if using reflection
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    !static !transient <fields>;
    !private <fields>;
    !static !transient <methods>;
    !private <methods>;
}

---

4. Secure Keystore & Production App Signing

Never commit keystores or raw passwords into Git. Use a detached key.properties file:

Step 1: Generate your release keystore via Keytool

keytool -genkey -v -keystore android/app/upload-keystore.jks \
  -keyalg RSA -keysize 2048 -validity 10000 -alias upload

Step 2: Create android/key.properties

storePassword=YourSecretStorePasswordHere
keyPassword=YourSecretKeyPasswordHere
keyAlias=upload
storeFile=upload-keystore.jks

Step 3: Add key.properties and *.jks to .gitignore

**/android/key.properties
**/android/app/*.jks
**/android/app/*.keystore

Step 4: Hook into build.gradle.kts

val keystorePropertiesFile = rootProject.file("key.properties")
val keystoreProperties = java.util.Properties()
if (keystorePropertiesFile.exists()) {
    keystorePropertiesFile.inputStream().use { keystoreProperties.load(it) }
}

android {
    signingConfigs {
        create("release") {
            keyAlias = keystoreProperties.getProperty("keyAlias")
            keyPassword = keystoreProperties.getProperty("keyPassword")
            storeFile = file(keystoreProperties.getProperty("storeFile"))
            storePassword = keystoreProperties.getProperty("storePassword")
        }
    }
}

---

5. Android Studio Profiler & Logcat Debugging

One of the greatest benefits of Android Studio over VS Code for Flutter engineers is the Android Profiler:

1. Run your Flutter app in profile mode:

   flutter run --profile
   

2. In Android Studio, open View → Tool Windows → Profiler.
3. Inspect CPU usage, Memory allocation leaks, and Energy consumption in real-time.
4. Use Logcat 2.0 with custom tag filters (package:mine level:error) to isolate crash stack traces instantly.

---

6. Building the Production Android App Bundle (AAB)

Google Play requires the AAB (Android App Bundle) format for dynamic delivery:

flutter build appbundle --release --obfuscate --split-debug-info=./debug-symbols

This command:

• Compiles AOT (Ahead-of-Time) arm64-v8a and armeabi-v7a native binaries.
• Obfuscates Dart code symbols for reverse-engineering protection.
• Outputs the release bundle at build/app/outputs/bundle/release/app-release.aab.

---

Conclusion & Best Practices

Setting up Flutter inside Android Studio gives your development team enterprise-grade tooling:

• Migrate to Gradle Kotlin DSL for type-safe build scripts.
• Always enable R8 minification and resource shrinking before release.
• Store signing keys outside version control with key.properties.
• Take advantage of Android Studio's Profiler to eliminate 60fps jank and memory leaks early.

Companion Mobile Engineering Guides

• Flutter State Management in 2026: BLoC vs Riverpod — Scalable state architecture.
• Building Offline-First Flutter Apps with Dio & Hive — Local database synchronization.
• Flutter Platform Channels: Calling Native Kotlin APIs — Bridging Flutter with Android hardware.