Editing Android applications: from APK decompilation to rebuilding with changes

Editing Android applications is a task that attracts both developers and advanced users who want to adapt the software to their needs. Possibilities for modifying APK files range from simple interface changes to deep reworking of functionality, removing ads or adding new features. However, this process requires not only technical skills, but also an understanding of legal risks: not all applications can be legally modified, especially if they are protected by a license or DRM.

In this article we will analyze the entire editing cycle from extracting the source code from the APK to the final assembly and installation of the modified file. You will learn what tools are needed for decompilation (for example, JADX or Apktool), how to work with resources in res/ and smalicode, as well as what mistakes beginners most often make. We will pay special attention to bypassing signature checks and compatibility with modern versions of Android (including Android 14+).

We warn you right away: editing other people's applications without the permission of the copyright holder may violate license agreements copyright laws. This instruction is intended solely for educational purposes and working with your own projects or open source software.

1. Preparation: what you need to edit APK

Before you start modifying, make sure you have everything you need. The minimum set of tools includes:

• 📱 Android device with an unlocked bootloader (for testing) or an emulator (Android Studio, Genymotion).
• 💻 Computer running Windows, Linux or macOS (for decompilation and assembly).
• 🛠️ Java JDK 11+ (required for working with Apktool i JADX).
• 🔧 ADB (Android Debug Bridge) to install APK on the device.

You will also need specialized utilities:

Important: Tool versions must be compatible with the target Android version. For example, Apktool 2.9+ supports Android 13/14, and older releases may not process new APK formats correctly (for example, .aab instead of .apk).

⚠️ Attention: If you are working with an APK downloaded from Google Play, remember that many applications (especially banking or DRM ones) have modification protection. Editing them may lead to account blocking or software inoperability.

2. APK decompilation: extracting source code and resources

The first step is to disassemble the APK into its components. To do this, we use Apktool or JADX. Let's consider both options.

Method 1: Apktool (for deep editing)

This utility allows you not only to view the code, but also to make changes, and then assemble the APK back. Commands for operation:

# Decompilation
apktool d your_application.apk -o output_folder

Build (after editing)
apktool b source_folder -o modified.apk

As a result, the output folder will contain:

• 📁 res/ — resources (pictures, lines, layouts).
• 📄 AndroidManifest.xml — application manifest.
• 📄 smali/ — decompiled bytecode (analogous to Java, but in a low-level form).

Method 2: JADX (for code analysis)

JADX converts bytecode into readable Java code, which is convenient for logic analysis, but not always suitable for editing. Launch:

jadx-gui your_application.apk

The app interface allows you to:

• 🔍 Search by classes and methods.
• 📋 Copy code fragments for further use.
• 🌐 View dependencies and function calls.

Key difference: JADX shows the code in a convenient way, but does not save changes back to the APK. Editing will still require Apktool.

3. Editing resources: images, strings, layouts

The simplest type of modification is changing static resources: icons, texts or screen layouts. These files are located in the folder res/ and have a clear structure:

• 🖼️ res/drawable/ — images (.png, .xml for vector graphics).
• 📝 res/values/strings.xml — text strings (for example, labels on buttons).
• 📱 res/layout/ — XML markup screens (activity_main.xml).

Example of editing a line:

<string name="app_name">Original App</string>
→
Modified Application

Important: When changing images, keep the original resolution and format (for example, png with transparency). Otherwise, the application may crash due to mismatch resources.

⚠️ Attention: If you delete or rename resources, be sure to check the references to them in the code (for example, in R.java or smaliUnused resources can be safely deleted, but it is better to test the assembly first.

<vector android:height="24dp" android:width="24dp">
<path android:fillColor="#FF0000" android:pathData="M10,5 L14,12 10,19"/>
</vector>

4. Working with code: smali and Java decompiled files

Editing application logic is the most difficult part: There are two approaches:

1. Editing smalicode (low-level bytecode, requires knowledge of syntax).
2. Editing decompiled Java (more convenient, but not always possible due to obfuscation).

What is smali?

Smali is an assembly-like language for Dalvik bytecode (used in Android). Example of a simple change:

.method public onCreate(Landroid/os/Bundle;)V
.locals 3
invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V

# Source code: sets the "Hello" header
const-string v0,"Hello"
→
# Modified code: sets the "Modified" header
const-string v0,"Modified"

invoke-virtual {p0, v0}, Landroid/app/Activity;->setTitle(Ljava/lang/CharSequence;)V
return-void
.end method

To find the desired method, use grep or built-in search in the code editor. For example, to find all mentions of advertising (AdMob), look for lines like com/google/android/gms/ads.

Editing Java code (via JADX)

If the code is not obfuscated, JADX will show almost original Java. For example, to remove the license check, you can comment out the block:

// Source code
if (!LicenseChecker.checkLicense) {
finish;
return;
}
// → Replace with
// if (false) { // Always skip the check
finish;
return;
// }

Critical: after editing the Java code it needs to be done again compile in smaliotherwise Apktool it will not compile the APK. To do this, use FernFlower or CFR.

5. Assembly and signing of the modified APK

After making changes, you need to assemble the APK back and sign it. Without a signature, Android will not install the application.

Building via Apktool

Build command:

apktool b source_folder --use-aapt2

Flag --use-aapt2 required for modern APKs (otherwise the build will fail with an error). If you have problems with resources, try:

apktool b folder_with_sources -f --use-aapt2

APK signature

For signature we use Uber APK Signer or keytool from Java JDK. Example with Uber APK Signer:

1. Run the app and select modified.apk.
2. Click Sign the APK (the signature will be created automatically).
3. Save the signed file as signed.apk.

For manual signature via keytool:

# Key creation (one time)
keytool -genkey -v -keystore mykey.keystore -alias alias_name -keyalg RSA -keysize 2048 -validity 10000

Signature APK
jarsigner -verbose -sigalg SHA256withRSA -digestalg SHA-256 -keystore mykey.keystore modified.apk alias_name

⚠️ Attention: If you sign an APK with a key different from the original one, some functions (for example, updates through Google Play or working with Google Services) may stop working. For testing, use ADB:

adb install -r -t signed.apk

The flag -t allows you to install an APK over an existing one, and -r to replace it.

6. Testing and debugging a modified APK

Successful assembly is not a guarantee of performance. The modified application needs to be tested on:

• 📱 A real device (preferably) or an emulator.
• 🔄 Different versions of Android (if the target audience is wide).
• 🛡️ Absence of crashes at startup and use of key functions.

Frequent errors and their solutions:

For debugging use adb logcat:

adb logcat | grep"your_package"

If the application crashes, look in the logs for lines with FATAL EXCEPTION or java.lang.RuntimeException.

7. Common mistakes and how to avoid them

Even experienced modifiers encounter common problems. Here are the most common ones:

• 🔧 Missed resources: If you deleted an image or a line, but there is still a link to it somewhere in the code, the application crashes with an error ResourceNotFoundException. Solution: search the entire project (grep -r"resource_name").
• 🔒 Signature problems: If you use a self-signed certificate, some APIs (for example Google Maps) will stop working. Solution: use the original key (if you have access) or patch signature verification in smali.
• 📱 Incompatibility with the new version of Android: Starting from Android 9, Google has tightened the requirements for APKs. If the target application is built for Android 8, and you are testing on Android 13, there may be problems with permissions or libraries. Solution: update targetSdkVersion in AndroidManifest.xml.

Another common mistake is incorrect operation with smali. For example, if you remove a method call but leave a reference to it elsewhere, you will get NoSuchMethodError. Always check the call chains!

To automate the search for errors, you can use the script:

#!/bin/bash
Checking for broken links in smali
grep -r"invoke-virtual" folder_with_smali | grep -i"non-existent_class"

8. Legal aspects: what can be edited and what cannot

Before distributing modified APKs, read the legal risks:

• 📜 License agreements: Most applications prohibit changing the code without the permission of the copyright holder. The exception is open source software (GPL, MIT).
• 🛡️ DRM and protection: Applications with Google Play Licensing, DexGuard or Root checks can block modified versions.
• ⚖️ Copyright: Distribution of hacked versions of paid applications is punishable by law (including through DMCA Google Play).

What you can do legally:

• ✅ Modify your own applications.
• ✅ Make changes to open source software (subject to the license).
• ✅ Use modifications for personal needs (without distribution).

What is prohibited:

• ❌ Remove license checks in paid applications.
• ❌ Distribute modified APKs without the author's permission.
• ❌ Bypass security in banking or government applications.

⚠️ Attention: Even if you do not distribute the modified APK, some applications (for example, games with online checks) may ban your account for using a modified client. Always check the service rules.

FAQ: Frequently asked questions about editing APK

apktool b --use-aapt2 -c folder_with_sources