How to build an APK file in Android Studio: from debug to release

Creation APK file is a key stage of development Android applications. Without it, it is impossible to test the app on a real device or publish it in Google Play. But how to properly assemble an APK in Android Studioso that it works without errors? This instruction will help you understand the types of assemblies, application signatures and optimization nuances. The first one is created automatically when the project starts, but is not suitable for distribution. The second requires a signature and additional settings. We will analyze both options in detail, and also tell you how to reduce the size of the APK and avoid common mistakes.

Many newbies get confused debug APK (for testing) and release APK (for publication). The first one is created automatically when the project starts, but is not suitable for distribution. The second requires a signature and additional settings. We will analyze both options in detail, and also tell you how to reduce the APK size and avoid common mistakes.

If you are just starting to develop for Android, this guide will become your cheat sheet. Experienced developers will find here up-to-date tips on optimizing the build and working with Gradle. Don't miss the section about Automatic APK signing via CI/CD —it will save hours of working time!

Types of APK files: which one to choose for your task

Q Android Studio You can build three main types of APK: debug (debug), release (release) and universal (universal). Each has its own characteristics and application.

Debug APK is generated automatically when you start the project through Run 'app'. It is signed with a standard key Android Debug Keystore, which is stored in ~/.android/debug.keystore. Such a file cannot be published - it is intended only for testing on an emulator or connected device.

Required for publication in stores release APK. It requires its own signing certificate, which you create once and keep secure. Without the correct signature Google Play Console simply will not accept your application.

The third option is universal APK (universal APK). It combines code and resources for all architectures (armeabi-v7a, arm64-v8a, x86), which increases its size. To save user traffic, it is better to use App Bundle, but more on that later.

• 🔧 Debug APK: for testing, signed automatically, not suitable for distribution
• 📦 Release APK: for publication, requires manual signature, optimized
• 🌍 Universal APK: contains all architectures, large size, compatible with all devices

Since 2021 Google Play recommends downloading Android App Bundle (.aab), and not APK. However, the ability to assemble APKs remains an important skill - for example, for testing on devices without access Play Market or for enterprise distribution.

Preparing the project before assembling the APK

Before building the APK, you need to check several key project parameters. This will get rid of signature errors, compatibility problems and excess file weight.

First, update build.gradle (Module: app). Make sure that the correct minSdkVersion, targetSdkVersion and compileSdkVersions are specified. For example, if your application supports Android 8.0 (Oreo)then minSdkVersion should be at least 26.

Second - check the dependencies in build.gradle. Outdated libraries may cause conflicts or increase the size of the APK. Use the command ./gradlew dependencies in the terminal to see the full list of connected modules.

Third - configure proguard-rules.pro. This file is responsible for reducing the code size and protecting against decompilation. Even if you don't use ProGuard, check that there are no rules that break functionality.

Update SDK versions in build.gradle|

Checking dependencies for relevance|

Setting up proguard-rules.pro (if used)|

Clearing the cache (Build → Clean Project)-->

Don't forget about AndroidManifest.xml. Make sure that all the necessary permissions (<uses-permission>) and the correct ones intent-filter for MainActivityare written there. Errors in the manifest are one of the main causes of crashes after installing an APK.

⚠️ Attention: If you use Firebase, Google Maps API or other services with keys, make sure that the release build contains working keys and not stubs from debug-versions.

Building a debug APK: a quick way for testing

A debug APK is created automatically every time you start the project via Android Studio. But sometimes you need to get the file itself - for example, for installation on several devices or transfer to a tester.

To collect debug APK manually:

1. Select from the menu Build → Build Bundle(s) / APK(s) → Build APK
2. Wait for the build to complete (a notification will appear at the bottom APK(s) generated successfully)
3. Click locate in the notification or find the file along the path app/build/outputs/apk/debug/app-debug.apk

The finished file can be immediately installed on the device via adb:

adb install app/build/outputs/apk/debug/app-debug.apk

The debug APK has limitations:

• 🚫 Does not work on devices with USB debugging disabled
• 🚫 Has a "DEBUG" watermark in the package name
• 🚫 Not suitable for publication in stores

If you need an APK for testing on devices without Android Studio, but with debugging capabilities, use the command:

./gradlew assembleDebug

Creation release APK: signing and optimization

The release APK requires a signature with a digital certificate. Without it Google Play and most devices simply will not install the application. The process consists of two stages: generating a key and signing the APK itself.

Step 1. Creating a signature key

Use the command:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

Where:

• my-release-key.jks — key file name
• my-alias — key alias
• validity 10000 — validity period (in days)

Step 2. Configuration signatures in Android Studio

1. Go to File → Project Structure → Modules → app → Signing
2. Specify the path to the .jksfile, password and alias
3. In build.gradle add a block:

   android {
   signingConfigs {
   release {
   storeFile file('my-release-key.jks')
   storePassword 'yourpassword'
   keyAlias 'my-alias'
   keyPassword 'yourpassword'
   }
   }
   buildTypes {
   release {
   signingConfig signingConfigs.release
   minifyEnabled true
   proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
   }
   }
   }

buildTypes {
release {
minifyEnabled true
shrinkResources true
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}

splits {
abi {
enable true
reset()
include 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
universalApk false
}
}

configurations {
all {
exclude group: 'com.squareup.okhttp3', module: 'okhttp'
}
}

-keep class com.example.MyClass { *; }

name: Build Release APK

on:
push:
tags:
- 'v*'

jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up JDK 17
uses: actions/setup-java@v3
with:
java-version: '17'
distribution: 'temurin'
- name: Build Release APK
run: ./gradlew assembleRelease
- name: Upload APK
uses: actions/upload-artifact@v3
with:
name: app-release.apk
path: app/build/outputs/apk/release/app-release-unsigned.apk

jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256
-keystore $SIGNING_KEY_STORE
-storepass $SIGNING_STORE_PASSWORD
-keypass $SIGNING_KEY_PASSWORD
app-release-unsigned.apk my-alias