compileSdkVersion: grunder, nya API:er och konfiguration i Gradle

Vad är compileSdkVersion i Android?

compileSdkVersion — en heltalsparameter i build.gradle som anger mot vilken version av Android SDK koden ska kompileras. När du skriver kod som använder klasser från android.* eller androidx.*, kontrollerar kompilatorn dem mot API:er som är tillgängliga i den angivna compileSdk-versionen. Om en metod dök upp i API 36 och compileSdk = 35, kommer koden inte att kompileras. Om compileSdk = 36 — kommer koden att kompileras, men på en enhet med API 35 vid anrop av denna metod utan kontroll kommer ett fel att uppstå.

compileSdkVersion laddas från Android SDK Platform, installerad via SDK Manager i Android Studio. Varje API Level har sin egen plattform: android-21, android-29, android-34, android-35, android-36. Plattformen innehåller android.jar — en uppsättning klasser, metoder och konstanter som Kotlin/Java-kompilatorn arbetar med. Om plattformen inte är installerad kommer Gradle att ladda ner den automatiskt via sdkmanager vid första bygget.

AGP (Android Gradle Plugin) version 8.7+ rekommenderar att ange compileSdk som ett heltal via compileSdk = 36 i Kotlin DSL, utan prefixet android-. compileSdk kan också anges via compileSdkVersion 36 i Groovy DSL eller compileSdkPreview för förhandsversioner av SDK (developer previews). compileSdkPreview används för att testa kommande API Level före officiell release.

// build.gradle.kts — konfiguration av compileSdkVersion
android {
    namespace = "com.example.myapp"

    // compileSdk = 36 — senaste stabila API Level (Android 16)
    compileSdk = 36

    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 26
        targetSdk = 36
        versionCode = 1
        versionName = "1.0.0"
    }
}

// Alternativt: compileSdkPreview för förhandsversioner
// compileSdkPreview = "Baklava"

I exemplet ger compileSdk = 36 tillgång till alla API:er i Android 16 (Baklava). Android SDK Platform 36 måste vara installerad i SDK Manager. compileSdkPreview med namnet "Baklava" kan användas för att testa instabila API:er före plattformens officiella release. Efter releasen ersätts preview med stabil compileSdk = 36.

compileSdkVersion vs targetSdkVersion vs minSdkVersion

Tre API Level-parametrar i build.gradle — compileSdkVersion, targetSdkVersion och minSdkVersion — blandas ofta ihop. Var och en ansvarar för en annan aspekt av kompatibilitet, och deras värden måste samordnas enligt regeln compileSdk >= targetSdk >= minSdk. minSdk — nedre gräns: enheter under denna ser inte applikationen. targetSdk — testpunkt: behavioural changes aktiveras upp till denna nivå. compileSdk — tak: API:er ovanför denna nivå är inte tillgängliga för kompilatorn.

Viktig praktisk regel: compileSdk kan höjas utan någon testning på enheter. Detta är en säker operation som bara ger kompilatorn en ny version av android.jar. Den enda risken — deprecated API:er som kan tas bort i den nya versionen av plattformen, men detta upptäcks i kompileringsfasen och åtgärdas enkelt. Höjning av targetSdk kräver däremot en full QA-cykel.

Varför kan compileSdk vara högre än targetSdk? Föreställ dig att Android 16 (API 36) släpptes med nya API:er du vill använda i koden, men behavioural changes för API 36 har du inte testat än. Du ställer in compileSdk = 36 (nya API:er tillgängliga), targetSdk = 35 (behavioural changes för API 36 avaktiverade). Koden kommer att kompileras, använda nya metoder under SDK_INT-kontroller, och behavioural changes för API 36 kommer inte att bryta applikationen eftersom targetSdk = 35.

Exempel på korrekta kombinationer

compileSdk = 36, targetSdk = 36, minSdk = 26 — full kompatibilitet med de senaste API:erna och behavioural changes, täckning 85% av enheter. compileSdk = 36, targetSdk = 34, minSdk = 26 — nya API:er tillgängliga, behavioural changes endast upp till API 34. compileSdk = 35, targetSdk = 36 — felaktigt: compileSdk lägre än targetSdk, API 36 inte tillgängligt, även om behavioural changes 36 är aktiva.

Hur man uppdaterar compileSdkVersion: steg-för-steg-guide

Uppdatering av compileSdkVersion — en av de enklaste och säkraste operationerna i ett Android-projekt. Till skillnad från targetSdk kräver det inte långvarig testning av behavioural changes. Det finns dock några steg som måste utföras för att undvika kompileringsfel och deprecated-varningar.

Steg 1 — installera den nya plattformen via SDK Manager i Android Studio: Tools → SDK Manager → SDK Platforms → välj den nya API Level. Om du inte installerar plattformen kommer Gradle att försöka ladda ner den automatiskt, men detta kan sakta ner första bygget. Steg 2 — ändra compileSdk i build.gradle till det nya värdet. Steg 3 — utför bygget (Build → Make Project) och åtgärda kompileringsfel.

Steg 4 — kontrollera deprecated API:er. Efter höjning av compileSdk kan vissa metoder vara märkta med @Deprecated med anteckningen "removed in API X". Android Studio markerar dem med genomstrykning och visar en varning. Ersätt deprecated-anrop med nya alternativ. Om alternativet kräver en högre API Level än minSdk, lägg till en runtime-kontroll. Steg 5 — kontrollera dependencies: vissa bibliotek kan kräva en specifik compileSdk-version. AGP 8.7+ rekommenderar compileSdk = 36.

// Efter höjning av compileSdk: ersättning av deprecated API:er
import android.os.Build
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES
import android.os.Process
import android.app.ActivityManager

class CompileSdkMigration {

    // FÖRE: deprecated metod (kan tas bort i nytt API)
    @Suppress("DEPRECATION")
    fun getMemoryClassOld(context: android.content.Context): Int {
        val am = context.getSystemService(
            android.content.Context.ACTIVITY_SERVICE
        ) as ActivityManager
        return am.memoryClass  // Kan vara deprecated i API 36
    }

    // EFTER: nytt alternativ (om tillgängligt)
    fun getMemoryClassNew(context: android.content.Context): Int {
        if (VERSION.SDK_INT >= VERSION_CODES.BAKLAVA) {
            // Nytt API från compileSdk 36
            val am = context.getSystemService(
                android.content.Context.ACTIVITY_SERVICE
            ) as ActivityManager
            return am.getMemoryClassSafe()  // Exempel på nytt API
        }
        @Suppress("DEPRECATION")
        return context.getSystemService(
            android.content.Context.ACTIVITY_SERVICE
        ) as ActivityManager
            .memoryClass
    }
}

Klassen CompileSdkMigration visar rätt migrationsmönster. Den gamla metoden memoryClass kan tas bort i det nya API:et — kompilatorn ger ett fel. Det nya alternativet getMemoryClassSafe är endast tillgängligt på API 36+, så det anropas under kontrollen SDK_INT >= BAKLAVA. För gamla enheter används fallback med @Suppress("DEPRECATION").

Arbeta med nya API:er: villkorliga kontroller och fallback

Nya API:er, tillgängliga tack vare höjning av compileSdkVersion, kan inte anropas direkt om minSdkVersion är lägre än denna API Level. Utan runtime-kontroll kommer applikationen att krascha med AbstractMethodError, NoSuchMethodError eller VerifyError på gamla enheter. Huvudskyddsmekanismen — kontroll av Build.VERSION.SDK_INT med anrop av det nya API:et endast vid tillräcklig API Level och fallback för gamla versioner.

AndroidX tillhandahåller bakåtporteringar av många nya API:er, vilket möjliggör användning av moderna metoder även vid låg compileSdk. Till exempel fungerar Activity Result API från androidx.activity:activity-ktx:1.9.3 på alla versioner av Android från och med API 14. NotificationCompat från AndroidX möjliggör moderna notiser på gamla API:er. PhotoPicker är tillgängligt via ActivityResultContracts.PickVisualMedia från och med API 34+.

// Säkert anrop av nytt API med compileSdk 36 och minSdk 26
import android.os.Build
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES
import android.graphics.Color

class NewApiHelper {

    // API 36+: ny metod för färghantering
    fun formatColor(colorInt: Int): String {
        if (VERSION.SDK_INT >= VERSION_CODES.BAKLAVA) {
            // Nytt API från compileSdk 36 — kräver API 36+
            return Color.toArgbHexString(colorInt)
        }
        // Fallback: manuell formatering för gamla API:er
        return String.format(
            "#%08X", (0xFFFFFFFF toLong() and colorInt.toLong())
        )
    }

    // AndroidX: bakåtportering krävs inte — SDK_INT-kontroll
    fun isEdgeToEdgeAvailable(): Boolean {
        return VERSION.SDK_INT >= VERSION_CODES.VANILLA_ICE_CREAM
    }
}

// Användning i Activity
class ColorActivity : android.app.Activity() {
    override fun onCreate(savedInstanceState: android.os.Bundle?) {
        super.onCreate(savedInstanceState)
        val helper = NewApiHelper()
        val colorStr = helper.formatColor(0xFF6200EE)
        println("Color: $colorStr")
    }
}

Klassen NewApiHelper demonstrerar säkert anrop av det nya API:et Color.toArgbHexString (hypotetiskt API 36) med fallback-formatering för gamla versioner. Nyckelprincip: compileSdk ger tillgång till att anropa nya metoder i koden, men runtime-kontrollen SDK_INT skyddar mot krasch på gamla enheter. Utan SDK_INT-kontroll kommer applikationen med minSdk 26 och compileSdk 36 att krascha på Android 8-15.

AGP (Android Gradle Plugin) och compileSdkVersion

Android Gradle Plugin (AGP) — huvudverktyget för att bygga Android-applikationer. Varje AGP-version stöder ett visst intervall av compileSdkVersion. AGP 8.7.x (släppt 2026) kräver compileSdk >= 34 och rekommenderar compileSdk = 36. AGP 8.5.x stöder compileSdk 33-35. Om compileSdk är lägre än minimum för AGP, kommer bygget att avslutas med felet "The SDK platform (X) is not supported by this version of the Android Gradle Plugin".

NDK (Native Development Kit) är också kopplat till compileSdkVersion. Om projektet använder native-kod i C/C++ via NDK, bestämmer compileSdk versionen av header-filer och bibliotek. NDK r27+ rekommenderar compileSdk 36. För bibliotek med .so-filer påverkar compileSdk den lägsta API Level för native-kod via APP_MIN_SDK_VERSION i Application.mk.

Gradle (7.6+) och Kotlin (2.0+) påverkar också kompatibiliteten med compileSdk. AGP 8.7+ kräver Gradle 8.9+ och Kotlin 2.0+. Vid höjning av compileSdk rekommenderas att uppdatera AGP, Gradle och Kotlin till de senaste stabila versionerna. Kontrollera kompatibilitet i den officiella tabellen Android Gradle Plugin compatibility.

Typiska problem vid höjning av compileSdk

Problem vid höjning av compileSdkVersion delas in i tre kategorier: compilation errors, deprecated warnings och runtime incompatibilities. Compilation errors — metoder borttagna från API och koden kompileras inte. Deprecated warnings — metoder märkta med @Deprecated, koden kompileras med varningar. Runtime incompatibilities — nya API:er är obligatoriska för viss funktionalitet och orsakar fel vid otillräcklig API Level på enheten.

Första typiska problemet — "Cannot resolve symbol X". Detta innebär att en klass eller metod har tagits bort från det offentliga API:et i den nya SDK-versionen. Lösning: hitta ett alternativ på den nya plattformen eller använd AndroidX-motsvarighet. Till exempel var klassen AsyncTaskLoader deprecated i API 28 och borttagen från det offentliga API:et i nyare versioner. Alternativ — Kotlin Coroutines eller WorkManager.

Andra problemet — ändring av metodsignatur. I den nya API-versionen kan metoden ha ändrat antal eller typer av parametrar. Kotlin/Java-kompilatorn ger felet "None of the following functions can be called with the arguments supplied". Lösning: uppdatera metodanropet till den nya signaturen eller lägg till SDK_INT-kontroll med anrop av den gamla signaturen för gamla enheter.

// Lösning av problem vid höjning av compileSdk
import android.os.Build
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES
import android.content.pm.PackageManager

class CompileSdkProblemFixer {

    // Problem: metoden hasSystemFeature ändrade signatur i API 36
    fun hasCamera(pm: PackageManager): Boolean {
        return if (VERSION.SDK_INT >= VERSION_CODES.BAKLAVA) {
            // Ny signatur: hasSystemFeature(String, FeatureType)
            pm.hasSystemFeature(
                PackageManager.FEATURE_CAMERA,
                PackageManager.FEATURE_TYPE_BACK
            )
        } else {
            // Gammal signatur: hasSystemFeature(String)
            @Suppress("DEPRECATION")
            pm.hasSystemFeature(PackageManager.FEATURE_CAMERA)
        }
    }

    // Problem: klass borttagen, använder AndroidX-motsvarighet
    fun loadFragment(manager: androidx.fragment.app.FragmentManager) {
        // Istället för android.app.FragmentManager (borttagen) använder
        // androidx.fragment.app.FragmentManager
        val fragment = CustomFragment()
        manager.beginTransaction()
            .replace(android.R.id.content, fragment)
            .commit()
    }
}

Klassen CompileSdkProblemFixer löser typiska problem: den ändrade signaturen för hasSystemFeature (hypotetisk ändring i API 36) hanteras via SDK_INT-kontroll med anrop av rätt version av metoden. Den borttagna klassen android.app.FragmentManager har ersatts med AndroidX-motsvarighet. För gamla anrop där det inte finns något alternativ används @Suppress("DEPRECATION") med en kommentar om orsaken till att behålla den.