APK: vad det är, filstruktur och funktionsprincip

Vad är APK och vad används det till

APK (Android Package Kit) är ett arkivformat i vilket Android-applikationen paketeras för distribution. Tekniskt sett är APK ett ZIP-arkiv med en specifik struktur som innehåller alla komponenter som krävs för att applikationen ska fungera på enheten.

Formatets historia

APK-formatet dök upp tillsammans med den första versionen av Android 2008. Som grund togs JAR-standarden (Java Archive), som i sin tur är baserad på ZIP. Detta arv säkerställde kompatibilitet med befintliga arkivverktyg — vilket arkiveringsprogram som helst öppnar APK som en vanlig ZIP.

Användningsområden

Google Play är den huvudsakliga distributionskanalen för APK, men formatet används även i andra scenarier: direktinstallation via webbläsare (sideloading), företagsbutiker för applikationer, testning på utvecklarenheter och installation i emulatorer. Enligt Statista sker cirka 15% av Android-appinstallationerna 2025 utanför Google Play.

Intern struktur av APK-filen

Den inre strukturen av APK är strikt reglerad: varje applikation måste innehålla specifika filer och kataloger. Brott mot strukturen leder till installationsfel.

AndroidManifest.xml

Manifestet är applikationens centrala konfigurationsfil. I kompilerad binär form (inte i läsbar XML) innehåller det paketnamn, version, lista över aktiviteter, tjänster, behörigheter och SDK-krav. Utan manifest vet systemet inte hur applikationen ska startas.

DEX-filer

Källkoden i Java eller Kotlin kompileras till DEX-filer (Dalvik Executable). Huvudfilen heter classes.dex. Om byte koden överskrider gränsen på 64K metoder skapas classes2.dex, classes3.dex och så vidare — multidex-mekanismen.

Nativer bibliotek

Katalogen lib/ innehåller kompilerade C/C++-bibliotek för olika arkitekturer: armeabi-v7a, arm64-v8a, x86, x86_64. Varje bibliotek har ändelsen .so (Shared Object). Moderna applikationer levererar vanligtvis endast arm64-v8a.

Byggprocessen för APK via Gradle

Bygget av APK är en flerstegsprocess som automatiseras av byggsystemet Gradle och Android Gradle Plugin. Varje steg omvandlar källfiler till komponenter i det slutliga arkivet.

Byggsteg

Källkoden kompileras till Java-byte kod (.class), konverteras sedan till DEX via verktyget d8 (tidigare dx). Resurser kompileras till binärt format via AAPT2. Alla komponenter paketeras i ett ZIP-arkiv och signeras med en digital signatur.

// build.gradle.kts — grundläggande konfiguration av APK-bygge
android {
    defaultConfig {
        applicationId = "com.example.app"
        minSdk = 24
        targetSdk = 34
        versionCode = 1
        versionName = "1.0.0"
    }
    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt")
            )
        }
    }
}

ProGuard och storleksminskning

ProGuard eller R8 förmörker koden, tar bort oanvända klasser och metoder och minskar APK-storleken. Utan förmörkning innehåller APK fullständiga klassnamn, vilket förenklar dekompilering. R8 utför även byte kodsoptimering på DEX-nivå.

Signering av APK: v1, v2, v3 och v4 scheman

Digital signatur är ett obligatoriskt element i APK. Android installerar inte osignerade paket. Signaturen garanterar att applikationen inte har ändrats efter publicering och avgör vem paketet tillhör.

Utveckling av signeringsscheman

v1 (JAR signing) — ursprungligt schema baserat på signering av varje fil i arkivet. Sårbarhet: filer kan tas bort från META-INF utan upptäckt. v2 (APK Signature Scheme v2) dök upp i Android 7.0 — hela arkivet signeras, vilket förhindrar modifiering. v3 stöder nyckelrotation och v4 stöder inkrementell installation.

Google Play kräver v2 eller högre för alla nya applikationer från augusti 2021. Det rekommenderas att signera APK med alla tre scheman för maximal kompatibilitet med olika Android-versioner.

Signeringsprocess via Gradle

I build.gradle anges keystore, lösenord och alias. Den privata nyckeln lagras i ett krypterat lager. För publicering i Google Play används App Signing — Google lagrar den privata nyckeln och utvecklaren laddar upp den signerade APK-filen.

Installation av APK på Android-enhet

Installation av APK sker via systemets pakethanterare PackageManager. Processen innefattar verifiering av signatur, tolkning av manifest, kopiering av filer och DEX-optimering via dex2oat.

Installation via ADB

Verktyget ADB (Android Debug Bridge) gör det möjligt att installera APK direkt från utvecklarens dator. Kommandot `adb install app.apk` kopierar filen till enheten och startar installationen. Flaggan -r installerar om applikationen med bevarande av data, flaggan -d tillåter installation av en version med lägre versionCode.

Säkerhet vid installation

Från och med Android 8.0 kräver systemet bekräftelse av installation från okända källor för varje applikation separat. Android 14 har förstärkt kontrollen: installation av APK via butiker från tredje part är endast möjlig efter uttryckligt tillstånd i inställningarna. Google Play Protect skannar varje APK vid installation för skadlig kod.

APK Expansion Files (OBB)

För applikationer större än 150 MB stöder Google Play Expansion Files — ytterligare OBB-paket upp till 2 GB vardera. OBB-filer ingår inte i APK utan laddas ner separat efter installation. Formatet stöder två typer: main (grundläggande resurser) och patch (uppdateringar).

// Kontroll av APK-version via PackageManager
val pm = packageManager
val info = pm.getPackageInfo(
    "com.example.app",
    PackageManager.GET_ACTIVITIES
)
Log.d("APK", "Version: ${info.versionName}")

dex2oat-optimering

På enheter med ART (Android Runtime) startas kompilering av DEX till nativ kod via dex2oat efter installation. Processen kan ta några sekunder och ökar storleken på den installerade applikationen, men snabbar upp dess start.

APK vs AAB: vilket format välja

AAB (Android App Bundle) är ett format som Google främjar som alternativ till APK för publicering i Google Play. Skillnaden är grundläggande: AAB installeras inte direkt, utan fungerar som en behållare från vilken Google Play genererar optimerade APK-filer.

Google Play kräver AAB från augusti 2021 för nya applikationer. APK förblir dock det huvudsakliga formatet för distribution utanför Google Play — via webbplatser, företagsbutiker och testning.

Typiska problem med APK och deras lösningar

Utvecklare stöter regelbundet på problem vid bygge och installation av APK. De flesta är relaterade till versionsinkompatibilitet, signatur eller arkivstruktur.

INSTALL_FAILED_UPDATE_INCOMPATIBLE

Felet uppstår vid försök att installera en APK med samma paketnamn men annan signatur. Android tillåter inte ominstallation av en applikation med ändrat certifikat. Lösning — ta bort den gamla versionen före installation.

Överskridande av metodgräns (65K)

Om projektet överskrider gränsen på 65536 metoder misslyckas bygget med ett dex-fel. Lösning — aktivera multidex i build.gradle eller optimera beroenden genom att ta bort oanvända bibliotek.

APK för stor

Google Play begränsar APK-storleken till 150 MB. För större applikationer används APK Expansion Files (OBB). Det rekommenderas att minska storleken via R8, WebP-bilder och Android App Bundle. Varje extra megabyte påverkar installationskonverteringen negativt: enligt Google minskar varje 10 MB konverteringen med 1%.

Dekompilering av APK och säkerhet

APK kan dekompileras med verktygen JADX, APKTool eller Bytecode Viewer. JADX återställer den ursprungliga Java-koden från DEX, vilket gör applikationer utan förmörkning helt läsbara. För kodskydd används ProGuard/R8, som byter namn på klasser, metoder och fält till korta oläsbara namn och tar bort felsökningsinformation.

Analys av APK via verktyg

För analys av APK-innehåll används Android Studio Profiler, apkanalyzer (CLI-verktyg från Android SDK) och tredjepartsverktyg. apkanalyzer visar storleken på varje APK-komponent: DEX, resurser, nativer bibliotek och signatur. Analys hjälper till att identifiera vilka beroenden som tar mest plats och fatta beslut om att byta ut eller ta bort dem.