Android (Google Play) Publishing Guide

Register at play.google.com/console with a Google account. A one-time 25 USD account fee is charged at signup; it does not recur annually and is non-refundable even if the account is later closed.

• Personal account: for individual developers; requires ID + address verification. Personal accounts created after November 13, 2023 must satisfy a closed-testing requirement before production access.
• Organization account: registered to a company; requires a D-U-N-S number or legal business registration, verification can take longer but there is no closed-testing requirement.

The applicationId in android/app/build.gradle.kts is your app's permanent identity on the Play Store (e.g. com.vibeloy.myapp). It cannot be changed after publishing — changing it means creating a brand-new listing with zero reviews and installs.

• Use reverse-domain notation (com.company.app), do not start with a digit, avoid special characters other than underscore.
• versionCode is a monotonically increasing integer (each aab must be unique and higher than the previous one); versionName is the user-facing string like "1.2.0".
• In pubspec.yaml, version: 1.0.0+1 carries versionName+versionCode together.

dev_dependencies:
  flutter_launcher_icons: ^0.14.1

flutter_launcher_icons:
  android: true
  image_path: "assets/icon/icon.png"
  min_sdk_android: 21

dart run flutter_launcher_icons

Google Play requires every AAB you upload to be signed with an "upload key". You generate this key with the standard keytool command documented in Flutter's official docs.

keytool -genkey -v -keystore ~/upload-keystore.jks \
  -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 \
  -alias upload

• The -storetype JKS flag matters: keytool defaults to PKCS12 since Java 9; without it, the file would have a .jks extension but actually contain PKCS12 data.
• On Windows, run flutter doctor -v and find the "Java binary at:" line in its output to confirm which JDK is in use; keytool lives in that directory's bin folder. Adjust the -keystore path to your own user directory.
• Store the requested store password and key password in a password manager; these same passwords will also go into key.properties.

Create a file named key.properties inside android/ (this file must never be committed to git — add it to .gitignore).

storePassword=<store-şifreniz>
keyPassword=<key-şifreniz>
keyAlias=upload
storeFile=/Users/kullanici/upload-keystore.jks

import java.util.Properties
import java.io.FileInputStream

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

android {
    // ... namespace, compileSdk, defaultConfig ...

    signingConfigs {
        create("release") {
            keyAlias = keystoreProperties["keyAlias"] as String
            keyPassword = keystoreProperties["keyPassword"] as String
            storeFile = keystoreProperties["storeFile"]?.let { file(it) }
            storePassword = keystoreProperties["storePassword"] as String
        }
    }

    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            isMinifyEnabled = true
            isShrinkResources = true
        }
    }
}

flutter build appbundle --release

The output file is created at build/app/outputs/bundle/release/app-release.aab. You upload this file directly to Play Console; since Play App Signing is active, Google adds its own distribution signature on top.

Before every new upload, remember to increment the versionCode part after the + sign in pubspec.yaml's version field; otherwise Play Console rejects the upload.

flutter build appbundle --release \
  --obfuscate \
  --split-debug-info=build/app/outputs/symbols

• Play Console > Create app: choose app name, default language, app vs. game, free vs. paid (paid can later be switched to free, but not the reverse).
• When you upload the first AAB (usually to the closed testing track), Play App Signing kicks in automatically; Google takes the package signed with your upload key and re-signs it with its own secure key for distribution.
• Declarations (export compliance, whether the app contains ads, target audience, etc.) begin at this stage and are completed in subsequent steps.

• App name: max 30 characters. Short description: max 80 characters (shown in search results). Full description: max 4000 characters.
• High-res icon: 512x512 px, 32-bit PNG (with alpha channel/transparency).
• Feature graphic: exactly 1024x500 px, JPEG or 24-bit PNG, NO alpha channel; avoid text near edges since Google may crop it in promotional placements.
• Phone screenshots: at least 2, up to 8; short side at least 320px, long side at most 3840px, aspect ratio between 1:2 and 2:1. The most common size is 1080x1920 px (portrait).
• 7" and 10" tablet screenshots are not mandatory but strongly recommended for better placement in tablet-specific searches.

In Play Console > Policy > App content, fill out the Data safety survey: which data (location, email, device identifiers, advertising ID, etc.) is collected, for what purpose, whether it is shared with third parties, whether it is encrypted in transit, and whether there is a deletion request mechanism.

• If you use AdMob: you must declare that the Advertising ID is collected and used for ad personalization purposes.
• If you use Firebase Analytics/Crashlytics: you must declare that usage data (app interactions), crash logs, and device identifiers are collected.

Fill out the IARC (International Age Rating Coalition) questionnaire in Play Console > Policy > App content > Content ratings. Based on your answers about violence, sexual content, gambling-like mechanics, user-generated content, and in-app chat, region-specific age ratings (PEGI, ESRB, etc.) are calculated automatically.

If your content changes (e.g. you add a chat feature), you must resubmit the questionnaire.

In Play Console > Testing > Closed testing, create a track, upload your AAB, and invite testers via an email list or Google Group. The rule applies to personal (individual) accounts created after November 13, 2023; personal accounts opened before that date and organization accounts are exempt.

• At least 12 testers must accept the invite and open the app on a real Android device with a genuine Google account; emulators, bots, or duplicate accounts do not count.
• The 14-day countdown starts only after your release is approved by Google AND at least 12 people have opted in; if the participant count drops below 12, the streak can reset.
• After the period completes, you must go through the "Apply for production access" flow in Play Console and answer questions about your app, your testing process, and production readiness.

Once closed testing and required declarations are complete, create a new release in Play Console > Production and upload your AAB. Google's review typically takes anywhere from a few hours to a few days; it can take longer for new developer accounts or apps using sensitive permissions (location, SMS, accessibility).

• Staged rollout: release to a small percentage of users (e.g. 5-20%) first, monitor crash rates and ANR (app not responding) data, then gradually increase to 100%.
• If you detect a problem you can pause or halt the rollout; pausing prevents new users from getting the update without affecting the previous version.

<manifest ...>
  <application ...>
    <meta-data
        android:name="com.google.android.gms.ads.APPLICATION_ID"
        android:value="ca-app-pub-XXXXXXXXXXXXXXXX~YYYYYYYYYY"/>
  </application>
</manifest>

If this meta-data tag is missing, the app crashes; use the real app ID from your AdMob console, do not leave the sample/test ID in production.

• Enter a domain you control in the "Developer website" field in Play Console — AdMob verifies this by matching it to your Play Store listing.
• Add the line AdMob console gives you to that domain's root (https://yoursite.com/app-ads.txt), e.g.: google.com, pub-0000000000000000, DIRECT, f08c47fec0942fa0