LunadeckLunadeck

Vibe code to app stores

Android on Linux

10 min read

A step-by-step guide for shipping a vibe-coded Flutter app to Google Play from a Linux machine — covering Flutter SDK installation (Debian/Ubuntu and Fedora/RHEL), signing, and the full Play Store submission process.

If you're using Lunadeck, the build and signing steps (Parts 3–5) are handled for you automatically. This guide is for building and publishing locally, or for understanding what Lunadeck does under the hood.

What you'll need before starting:

  • A Linux computer (Debian/Ubuntu or Fedora-based)
  • At least 10 GB of free disk space
  • At least 8 GB of RAM
  • A credit/debit card ($25 one-time Google Play fee)
  • Your exported Flutter project (ZIP from your AI coding tool, or a git clone)
  • About 2–4 hours for initial setup, then ~3 weeks for the publishing process

Part 1: Install the Required Tools

You need three things: Flutter SDK, Java (JDK 17), and Android Studio.

1.1 Install baseline utilities

Debian/Ubuntu:

sudo apt update
sudo apt install -y curl wget unzip git xz-utils clang cmake ninja-build pkg-config libgtk-3-dev

Fedora:

sudo dnf install -y curl wget unzip git xz clang cmake ninja-build pkgconf gtk3-devel

1.2 Install the Flutter SDK

Step 1: Download Flutter

Go to https://docs.flutter.dev/get-started/install/linux and download the latest stable .tar.xz for Linux, then:

mkdir -p ~/development
cd ~/development
tar xf ~/Downloads/flutter_linux_*.tar.xz

Step 2: Add Flutter to your PATH

Add to your ~/.bashrc (or ~/.zshrc):

export PATH="$PATH:$HOME/development/flutter/bin"

Reload:

source ~/.bashrc
flutter --version

Step 3: Run flutter doctor

flutter doctor

flutter doctor lists everything Flutter needs and shows what's missing. Resolve any issues it reports before continuing — it will guide you through each one.

1.3 Install Java (JDK 17)

Debian/Ubuntu:

sudo apt update
sudo apt install -y openjdk-17-jdk
java -version

Fedora:

sudo dnf install -y java-17-openjdk-devel
java -version

1.4 Install Android Studio

Step 1: Install prerequisite libraries

Debian/Ubuntu (64-bit):

sudo apt update
sudo apt install -y libc6:i386 libncurses5:i386 libstdc++6:i386 \
  lib32z1 libbz2-1.0:i386 libfontconfig1 libfreetype6 \
  libx11-6 libxext6 libxrender1 libxtst6 libxi6

Fedora (64-bit):

sudo dnf install -y zlib.i686 ncurses-libs.i686 bzip2-libs.i686 \
  libstdc++.i686 libX11 libXext libXrender libXtst \
  fontconfig freetype

Step 2: Download and install

Download the Linux .tar.gz from https://developer.android.com/studio, then:

sudo tar -xzf ~/Downloads/android-studio-*.tar.gz -C /opt/
/opt/android-studio/bin/studio.sh

Step 3: First-time setup

When Android Studio launches:

  1. Choose "Do not import settings"
  2. Select "Standard" installation type
  3. Let it download the Android SDK, build tools, and emulator

Step 4: Install SDK components

Go to Tools > SDK Manager:

  • SDK Platforms tab: check Android 14 (API 34) or newer
  • SDK Tools tab: check Android SDK Build-Tools, Android SDK Command-line Tools, Android Emulator, Android SDK Platform-Tools

Step 5: Set environment variables

Add to your ~/.bashrc (or ~/.zshrc):

export ANDROID_HOME="$HOME/Android/Sdk"
export ANDROID_SDK_ROOT="$HOME/Android/Sdk"
export PATH="$PATH:$ANDROID_HOME/platform-tools"
export PATH="$PATH:$ANDROID_HOME/cmdline-tools/latest/bin"

Reload and verify:

source ~/.bashrc
adb --version

Step 6: Accept Android licenses

Flutter requires all Android licenses to be accepted:

flutter doctor --android-licenses

Type y at each prompt.

1.5 Configure Flutter to use Android Studio

flutter config --android-studio-dir /opt/android-studio
flutter doctor

All Android checks in flutter doctor should now show a green checkmark.

1.6 Create a desktop shortcut (optional)

cat > ~/.local/share/applications/android-studio.desktop << 'EOF'
[Desktop Entry]
Name=Android Studio
Comment=Android IDE
Exec=/opt/android-studio/bin/studio.sh
Icon=/opt/android-studio/bin/studio.png
Terminal=false
Type=Application
Categories=Development;IDE;
EOF

Part 2: Export and Prepare Your Project

2.1 Get your project files

If your AI tool provides a ZIP export, download and unzip it:

mkdir ~/my-app
cd ~/my-app
unzip ~/Downloads/your-project.zip -d .

If you're working from a git repository:

git clone https://github.com/yourname/your-app.git ~/my-app
cd ~/my-app

2.2 Verify the project structure

A valid Flutter project looks like:

my-app/
  android/
  ios/          # may be absent on Linux-only exports
  lib/
    main.dart
  pubspec.yaml

If pubspec.yaml is missing, the project was not exported as Flutter.

2.3 Get dependencies

cd ~/my-app
flutter pub get

Common issues:

  • Pub resolution failure — a package version conflict. Read the error — it names the conflicting packages. Update version constraints in pubspec.yaml and run flutter pub get again.
  • Missing Flutter SDK version — your project requires a newer Flutter SDK. Run flutter upgrade to update.

2.4 Check your app configuration

Open pubspec.yaml and confirm:

name: my_app
description: A new Flutter application.
version: 1.0.0+1   # human version + build number
 
environment:
  sdk: '>=3.0.0 <4.0.0'

The version field uses the format versionName+versionCode — for example 1.0.0+1. The part before + is the display version; the part after is the integer that must increment with each Play Store upload.

Open android/app/build.gradle and note the applicationId:

defaultConfig {
    applicationId "com.yourname.myapp"
    ...
}

applicationId is permanent. Once you publish to Google Play, you cannot change it. If it says something generic like com.example.myapp, change it now before your first upload.

Part 3: Test Your App

3.1 Run on an emulator

In Android Studio > Device Manager, create a virtual device (Pixel 7, API 34+). Start it, then:

flutter run

Flutter auto-detects running emulators and devices. If multiple are running, it will ask which one to use.

3.2 Run on a physical device

  1. Enable Developer Options: Settings > About Phone > tap "Build Number" 7 times
  2. Enable USB Debugging: Settings > Developer Options > USB Debugging
  3. Connect via USB and accept the debugging prompt
  4. Verify Flutter sees the device:
flutter devices

Then run:

flutter run

3.3 Common issues

"No devices found" — check flutter devices. If the emulator isn't listed, make sure it's fully booted (the home screen is visible, not just the boot animation).

Build fails with Gradle errors — run flutter doctor and resolve any outstanding issues. Also try flutter clean before building again.

Plugin errors — a Flutter plugin may require a minimum Android SDK version. Check the plugin's documentation and update minSdkVersion in android/app/build.gradle if needed.

Extremely slow emulator — enable KVM hardware acceleration:

Debian/Ubuntu:

sudo apt install qemu-kvm
sudo adduser $USER kvm
# Log out and back in

Fedora:

sudo dnf install @virtualization
sudo usermod -aG kvm $USER
# Log out and back in

Part 4: Prepare for Release

4.1 Set your app icon

Replace the default Flutter icon by placing your icon (at least 1024×1024 px) at assets/icon.png, then use the flutter_launcher_icons package:

Add to pubspec.yaml:

dev_dependencies:
  flutter_launcher_icons: ^0.14.0
 
flutter_launcher_icons:
  android: true
  ios: false
  image_path: "assets/icon.png"
  adaptive_icon_background: "#FFFFFF"
  adaptive_icon_foreground: "assets/icon-foreground.png"

Run:

flutter pub get
dart run flutter_launcher_icons

Alternatively, replace the icon files directly in android/app/src/main/res/mipmap-*/.

4.2 Set your splash screen

Use the flutter_native_splash package:

Add to pubspec.yaml:

dev_dependencies:
  flutter_native_splash: ^2.4.0
 
flutter_native_splash:
  color: "#FFFFFF"
  image: assets/splash.png
  android: true
  ios: false

Run:

flutter pub get
dart run flutter_native_splash:create

4.3 Update your app version

In pubspec.yaml:

version: 1.0.0+1
#         ^^^^^  versionName (shown to users)
#               ^ versionCode (must increment with each Play Store upload)

You do not need to update android/app/build.gradle manually — Flutter reads pubspec.yaml and writes the version to the native project at build time.

4.4 Configure app permissions

In android/app/src/main/AndroidManifest.xml, inside the <manifest> tag:

<!-- Internet access — required for most apps -->
<uses-permission android:name="android.permission.INTERNET" />
 
<!-- Add only what your app actually uses: -->
<!-- <uses-permission android:name="android.permission.CAMERA" /> -->
<!-- <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> -->
<!-- <uses-permission android:name="android.permission.RECORD_AUDIO" /> -->

Part 5: Sign and Build the Release Bundle

5.1 Generate a signing key

keytool -genkey -v -keystore ~/my-app-release.keystore \
  -alias my-app-key \
  -keyalg RSA \
  -keysize 2048 \
  -validity 10000

Back up this keystore file and both passwords. Losing it means you can never update your app on Google Play. Store a copy in a password manager and on external storage.

5.2 Configure Flutter signing

Create android/key.properties (do NOT commit this to git — add it to .gitignore):

storeFile=/home/YOUR_USERNAME/my-app-release.keystore
storePassword=your_keystore_password
keyAlias=my-app-key
keyPassword=your_key_password

Edit android/app/build.gradle — add above the android { block:

def keystorePropertiesFile = rootProject.file("key.properties")
def keystoreProperties = new Properties()
if (keystorePropertiesFile.exists()) {
    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
}

Inside the android { block, add signing config and update build types:

android {
    // ... existing config ...
 
    signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            storePassword keystoreProperties['storePassword']
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
        }
    }
 
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

5.3 Build the release bundle

cd ~/my-app
flutter build appbundle --release

Your signed .aab file will be at:

build/app/outputs/bundle/release/app-release.aab

If the build fails — run flutter doctor to check for environment issues. Also try flutter clean and then rebuild.

Part 6: Create a Google Play Developer Account

  1. Go to https://play.google.com/console
  2. Sign in with your Google account
  3. Choose Personal or Organization account (Personal is fine for indie developers)
  4. Pay the one-time $25 USD registration fee
  5. Complete identity verification
  6. Wait 24–48 hours for activation

Personal accounts created after November 2023 require a device verification step. Install the Google Play Console mobile app on an Android device, sign in with the same Google account, and follow the verification steps.

Part 7: The Closed Testing Requirement

New personal developer accounts cannot publish directly to production. Google requires:

  1. Uploading your app to a closed test track
  2. Having at least 12 testers opted in
  3. Those testers must remain opted in for 14 consecutive days
  4. Only then can you apply for production access

7.1 Create your app listing

In Google Play Console, click Create app and work through all required sections:

  • Store listing — app description, at least 2 phone screenshots, 1024×500 feature graphic, 512×512 icon, category, contact details
  • Content rating — complete the IARC questionnaire honestly
  • Target audience — if not specifically for children, do not select children as target
  • Privacy policy — required if your app collects any user data; a simple page on GitHub Pages or Notion works

7.2 Set up closed testing and upload your build

  1. Go to Testing > Closed testing in the left sidebar
  2. Under Testers, create a list with at least 12 Gmail addresses
  3. Click Create new release, accept Play App Signing, and upload your .aab file
  4. Add release notes and click Start rollout
  5. Share the generated opt-in link with your testers

Testers must click the link on an Android device, accept the invitation, and install the app. After 14 days with all testers opted in, you can apply for production access from the app Dashboard.

Part 8: Publish to Production

Once you have production access:

  1. Go to Production > Create new release
  2. Upload your .aab file
  3. Add release notes and select distribution countries
  4. Click Start rollout to production

First-submission review typically takes a few hours to several days. If approved, your app goes live.

Part 9: Updating Your App

# 1. Make your code changes
 
# 2. Increment the build number in pubspec.yaml
#    e.g., 1.0.0+1 → 1.0.0+2
 
# 3. Rebuild
flutter build appbundle --release
 
# 4. Upload the new .aab in Google Play Console
#    Production > Create new release > upload > rollout

Quick Reference

# === SETUP ===
flutter pub get
flutter doctor --android-licenses
 
# === TESTING ===
flutter devices
flutter run
 
# === RELEASE BUILD ===
flutter build appbundle --release
# Output: build/app/outputs/bundle/release/app-release.aab
 
# === CLEAN BUILD ===
flutter clean
flutter pub get
flutter build appbundle --release

Troubleshooting

"Flutter SDK not found" — flutter is not in your PATH. Follow step 1.2 and reload your shell.

"Android licenses not accepted" — run flutter doctor --android-licenses and type y at each prompt.

"JAVA_HOME is not set" — add to ~/.bashrc:

# Debian/Ubuntu:
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
# Fedora:
export JAVA_HOME=/usr/lib/jvm/java-17-openjdk

Gradle build fails — run flutter clean then flutter build appbundle --release again. Check the full error message — Gradle errors usually name the specific file or dependency causing the problem.

flutter pub get fails with version conflict — read the error message. It names the conflicting packages. Try running flutter pub upgrade to update dependencies to compatible versions, or manually adjust version constraints in pubspec.yaml.

App crashes at launch — run flutter run (debug mode) and read the stack trace in the terminal. Debug mode gives you full error output; release builds suppress it.

"No devices found" — ensure the emulator is fully booted (home screen visible). Run flutter devices to see what Flutter can see. If adb devices shows your device but flutter devices doesn't, try flutter doctor.

Realistic Expectations

The timeline is longer than you expect. Between the 14-day testing requirement, Google's review process, and debugging, plan for 3–4 weeks from start to live.

AI-generated Flutter code frequently has plugin issues. Flutter plugins often require minimum SDK versions, specific Android permissions, or setup steps beyond pub get. Expect to spend time resolving plugin-specific issues.

Google can reject your app. Common reasons: missing privacy policy, misleading store listing, or the app crashing during review. Read Google's developer policies before submitting.

Finding 12 testers is harder than it sounds. Start recruiting before you finish building. Developer communities on Discord and Reddit (r/flutterdev, r/androiddev, r/betatesting) organize tester exchanges.