High-Level Guide to Android APK: Structure, Compilation, and Analysis

Introduction

This guide provides a high-level overview of the Android APK structure, compilation process, and analysis techniques. It has been compiled from various sources, including official Android documentation and community resources.

What is an APK

An APK (Android Package) is the package file format used by the Android operating system for the distribution and installation of mobile applications. Think of it as a container that holds all the elements necessary for your Android app to function.

Key Characteristics

Standard Android application package format
Contains all application code and resources
Digitally signed for security
Required for app distribution via Play Store
Essential for app installation on Android devices

APK Structure

An APK file is essentially a ZIP archive that contains multiple files and directories, each serving specific purposes.

Core Components

1. META-INF/

Contains package signature information
MANIFEST.MF: File containing resource signatures
CERT.RSA: The certificate of the application
CERT.SF: List of all resources and SHA-1 digests

2. lib/

Native libraries organized by architecture
Contains .so files (shared libraries)
Subdirectories for different CPU architectures:
- armeabi-v7a
- arm64-v8a
- x86
- x86_64

3. res/

Organized by resource type:
- drawable/
- layout/
- values/
- raw/
- etc.

4. assets/

Raw application assets
Accessed through AssetManager
Maintains original formats
Often contains:
- Fonts
- Game levels
- Textures
- Pre-bundled files

5. AndroidManifest.xml

Binary XML file containing app metadata
Declares:
- Package name
- Permissions
- Required features
- Components (Activities, Services, etc.)
- Supported screen sizes
- Required SDK versions

6. classes.dex

Dalvik Executable files
Contains compiled application code
Multiple DEX files possible (multidex)

7. resources.arsc

Compiled resource file
Contains binary resource data
Mapping of resource IDs to values
Supports multiple configurations

Compilation Process

From Source to APK

compilation process

1. Source Code Compilation

Source Files (.java, .kotlin)
        ↓
Java Bytecode (.class)
        ↓
DEX Files (.dex)

2. Resource Processing

Resource Files
        ↓
AAPT2 Processing
        ↓
Compiled Resources

3. Final Packaging

DEX Files + Compiled Resources + Native Libraries
        ↓
APK Packaging
        ↓
APK Signing
        ↓
ZIP Alignment

D8: Modern converter from Java bytecode (.class) to DEX bytecode (.dex)
R8: Modern replacement for ProGuard, handling code optimization and obfuscation
Both tools are designed for modern Android development while maintaining compatibility with the DEX format

Android Runtime Evolution

Historical Progression

1. Dalvik Virtual Machine

Original Android runtime
Register-based architecture
Just-In-Time compilation
Optimized for mobile constraints
Battery-efficient design

2. Android Runtime (ART)

Replaced Dalvik in Android 5.0
Ahead-Of-Time compilation
Improved performance
Better memory management
Reduced battery impact

3. Modern ART (Android 7.0+)

Hybrid compilation (JIT + AOT)
Profile-guided compilation
Adaptive optimization
Enhanced garbage collection
Improved memory management

Runtime Characteristics

runtime comparision

Dalvik vs. ART Comparison

Compilation approach
- Dalvik: JIT (Just-In-Time)
- ART: Primarily AOT (Ahead-Of-Time)
Memory usage
- Dalvik: Lower initial storage, higher runtime
- ART: Higher storage, lower runtime
Performance
- Dalvik: Good performance with optimization
- ART: Better overall performance
Battery efficiency
- Dalvik: More CPU usage during runtime
- ART: More efficient CPU usage

Format vs Runtime Separation:

The .dex format is independent of the runtime (Dalvik/ART)
ART reads and executes the same DEX bytecode format
This separation allowed Google to evolve the runtime without breaking compatibility

Platform Architecture:

The DEX format remains fundamental to how Android organizes compiled code
Maintaining this format ensures compatibility across the entire Android ecosystem
Tools, workflows, and existing apps continue to work without disruption
The relationship between Dalvik and ART is not about replacement but evolution - ART improved how the bytecode is executed while preserving the crucial DEX format that is the foundation of Android’s application architecture.

APK Analysis

Using APK Analyzer

There are three ways to access the APK Analyzer when a project is open:

Drag an APK or app bundle into the Editor window of Android Studio.
Switch to the Project view in the Project window, then double-click the APK in the default build/output/apks/ directory.
Select Build > Analyze APK in the menu bar, then select your APK or app bundle.

1. Basic Analysis

File size inspection
Component breakdown
Resource examination
Manifest analysis

2. Advanced Analysis

DEX file inspection
Method count verification
Resource duplication check
Native library examination

3. Size Analysis

Raw file sizes
Download size
Installation size
Component size contribution

Size Optimization

Optimization Strategies

1. Code Optimization

Proguard/R8 configuration
Dead code elimination
Code shrinking
Multidex optimization

2. Resource Optimization

Image compression
Resource shrinking
Drawable optimization
Alternative resources management

3. Native Library Optimization

Architecture-specific inclusion
Library consolidation
Unnecessary library removal
Version optimization

Real-World Example: Photo Filter App

Initial APK Structure:

Base APK size: 8.2MB
Components:
- Basic UI resources: 0.5MB
- Filter processing library (arm64-v8a): 4MB
- Sample filter images: 2.5MB
- Other resources: 1.2MB

After Optimization:

Implemented resource shrinking
- Removed unused sample images
- Compressed remaining images
Split native libraries by architecture
Implemented dynamic feature delivery for filters

Final Result:

Base APK: 2.8MB
Dynamic feature module (filters): 1.5MB
Architecture-specific libraries: Download only what’s needed

Real-World Example: Language Resource Organization (Not a real app, just for Understanding)

Common Structure Issue:
/res
  /drawable
    - app_icon.png (1MB - high res)
    - background.jpg (2MB)
  /values
    - strings.xml (English)
  /values-es
    - strings.xml (Spanish)
  /values-fr
    - strings.xml (French)
  /values-de
    - strings.xml (German)

Optimized Structure:

Implemented drawable density splits
Used language packs for non-primary languages
Optimized image assets

Results:

Original APK size: 4.8MB
Optimized base APK (English only): 1.2MB
Each language pack: ~200KB
Users download only needed languages