SDK Platform: vad är det, versioner och Android SDK Manager

Vad är SDK Platform

SDK Platform — är en grundläggande komponent i Android SDK, som utgör en komplett uppsättning bibliotek och verktyg för att utveckla appar under en specifik Android-version. Varje plattform identifieras av API Level — ett heltal som ökar med nya OS-versioner. Till exempel motsvarar Android 13 API Level 33, Android 14 — API Level 34, Android 15 — API Level 35.

Till skillnad från Android Studio (IDE) innehåller SDK Platform ingen kodredigerare eller debugger. Det är ett systemlager som ansluts till kompilatorn och byggverktyget. När en utvecklare skriver import android.app.Activity hämtar kompilatorn denna klass från android.jar för en specifik SDK Platform. Utan installerad plattform med rätt API Level kommer koden inte att kompileras.

Google släpper en ny SDK Platform för varje stabil Android-version. Historiken omfattar mer än 35 API Level — från Android 1.0 (API 1) till Android 15 (API 35). Varje plattform är bakåtkompatibel: kod skriven för API Level 21 fungerar på API Level 35, men inte tvärtom.

Varför en separat SDK Platform behövs för varje version

Android utvecklas snabbt: varje version lägger till nya API:er, ändrar beteendet hos befintliga och inför begränsningar. Till exempel Android 10 (API 29) införde Scoped Storage, Android 12 (API 31) — SplashScreen API, Android 14 (API 34) — obligatoriska BroadcastReceiver-flaggor. Utvecklaren måste bygga appen mot den aktuella plattformen för att använda dessa möjligheter.

Samtidigt kan appen köras på gamla OS-versioner. För detta anges minSdk i Gradle — den lägsta API Level som appen körs på. Koden använder versionskontroller och villkorliga API-anrop. Detta tillvägagångssätt säkerställer kompatibilitet utan att förlora nya funktioner.

Sammansättning av SDK Platform: huvudkomponenter

SDK Platform — är inte en enda fil, utan en uppsättning komponenter som tillsammans möjliggör kompilering, byggning och testning av appen. Huvudelementet är android.jar — ett arkiv med Android API-klasser som ingår i denna version. Denna fil ansluts till Kotlin- eller Java-kompilatorn och avgör vilka klasser, metoder och annoteringar som är tillgängliga för utvecklaren.

Systemavbildningar och emulator

Varje SDK Platform innehåller en System Image — en avbildning av operativsystemet för Android Virtual Device-emulatorn. Utan motsvarande avbildning kan emulatorn inte starta en virtuell enhet med rätt API Level. System Images finns i olika typer: Google APIs (med Google-tjänster), Google Play (med Play Store) och AOSP (ren Android utan Google-tjänster).

Bygg- och debugverktyg

SDK Platform innehåller en version av Build-Tools och Platform-Tools optimerade för denna API Level. Build-Tools inkluderar aapt2 (Android Asset Packaging Tool), dx/d8 (Dalvik/ART-kompilator) och ApkSigner. Platform-Tools tillhandahåller ADB (Android Debug Bridge), fastboot och SQLite. Dessa verktyg uppdateras oberoende av SDK Platform via SDK Manager.

Plattformsresurser

Varje plattform innehåller standard Android-resurser — systemteman, stilar, animationer, färger och storlekar. Dessa resurser används under kompilering: om en utvecklare refererar till @android:style/Theme.Material.Light hämtar byggverktyget definitionen från SDK Platform-resurserna. Detta garanterar ett enhetligt utseende på systemkomponenter på alla enheter.

API Level och versioner av SDK Platform

API Level — är en heltalsidentifierare för Android SDK-versionen. Varje Android-utgåva har en API Level som ökar monotont. Utvecklaren anger API Level i tre nyckelparametrar i build.gradle: compileSdk, minSdk och targetSdk. Valet av dessa parametrar avgör vilka API:er som är tillgängliga och hur systemet hanterar appen.

Google rekommenderar att hålla minSdk inte lägre än den nuvarande distributionsgränsen — enligt Android Studio Distribution Dashboard (2026) körs cirka 95 % av enheterna på Android 8.0 (API 26) och högre. compileSdk bör vara den senaste stabila — detta ger tillgång till nya API:er och låter lint-kontroller upptäcka föråldrade metoder.

Evolution av API Level: viktiga förändringar

Med varje ny API Level introducerar Google betydande förändringar. Android 6.0 (API 23) lade till runtime-behörigheter — appen begär behörigheter under körning, inte vid installation. Android 8.0 (API 26) införde automatisk ifyllning av formulär och notifikationskanaler. Android 12 (API 31) ändrade radikalt synen på intents — SplashScreen API och export av komponenter via exported-attributet dök upp. Android 14 (API 34) gjorde det obligatoriskt att ange flaggor för BroadcastReceiver och införde strikta begränsningar för foreground services.

Att förstå historien bakom API Level hjälper utvecklaren att välja rätt kompatibilitetsstrategi. Om appen använder compileSdk 35 men minSdk 26 kan koden anropa metoder från API 35 endast efter versionskontroll via Build.VERSION.SDK_INT. Detta tillvägagångssätt kallas version-gated development och är industristandard.

SDK Manager: installation och konfiguration

SDK Manager — är ett verktyg för att hantera Android SDK-komponenter: installation av nya SDK Platform, uppdatering av befintliga och borttagning av föråldrade. SDK Manager finns både som grafiskt gränssnitt i Android Studio och som kommandorad via sdkmanager. Via kommandoraden är SDK Manager bekväm att använda i CI/CD-pipelines där det inte finns något grafiskt gränssnitt.

SDK Manager installerar plattformar i Android SDK-katalogen, som som standard finns i $HOME/Android/Sdk på Linux och macOS eller %LOCALAPPDATA%\Android\Sdk på Windows. Inuti platforms-katalogen finns mappar med namnet android-{API Level}, som var och en innehåller en komplett SDK Platform.

Installation av SDK Platform via sdkmanager

Kommandot sdkmanager accepterar ett paket-ID i formatet "platforms;android-{API}". Till exempel, för att installera SDK Platform 35 ser kommandot ut så här:

# Installera SDK Platform för API Level 35
sdkmanager "platforms;android-35"

# Installera flera plattformar med ett kommando
sdkmanager "platforms;android-34" "platforms;android-33" "platforms;android-31"

# Lista över installerade plattformar
sdkmanager --list_installed | grep platforms

# Ta bort föråldrad plattform
sdkmanager --uninstall "platforms;android-28"

Automatisk installation via Gradle

Moderna Android-projekt använder Gradle Plugin som automatiskt kan installera SDK Platform vid första bygget. För detta måste du ange compileSdk i build.gradle och lägga till SDK-katalogen i den lokala konfigurationen. Android Studio erbjuder också att installera den saknade plattformen när du öppnar ett projekt — klicka bara på "Install SDK Platform" i Gradle-synkroniseringsfönstret.

Det är viktigt att regelbundet uppdatera SDK Platform via SDK Manager — tillsammans med plattformen uppdateras Build-Tools och Platform-Tools, vilket påverkar byggprestanda och debugstabilitet. Google rekommenderar att kontrollera SDK-uppdateringar var 2–3:e vecka, särskilt innan du publicerar en ny version av appen i Google Play.

Konfiguration av systemavbildning för emulatorn

För att starta emulatorn med en specifik API Level måste du installera System Image av samma version. SDK Manager tillåter nedladdning av avbildningar för olika arkitekturer (x86_64, arm64-v8a) och typer (Google APIs, Google Play, AOSP). Efter nedladdning av avbildningen skapar AVD Manager en virtuell enhet baserad på den.

# Installera System Image med Google APIs för API 35
sdkmanager "system-images;android-35;google_apis;x86_64"

# Skapa AVD via kommandoraden
avdmanager create avd -n pixel8 -k "system-images;android-35;google_apis;x86_64"

# Lista över skapade AVD:er
avdmanager list avd

compileSdk, targetSdk och minSdk i Gradle

Tre parametrar i build.gradle bestämmer hur appen arbetar med SDK Platform. compileSdk — API Level som används för kompilering. Denna parameter anger vilka Android API-klasser som är tillgängliga i koden. compileSdk bör vara den senaste av alla tre och påverkar inte runtime-beteendet — appen kompileras men använder endast de API:er som finns på enheten.

minSdk — den lägsta API Level som appen kan installeras på. Google Play tillåter inte installation av appen på en enhet med en version lägre än minSdk. Denna parameter bestämmer kompatibilitetströskeln och påverkar målgruppens täckning. Ju lägre minSdk, desto fler enheter stöds, men desto färre nya API:er kan användas utan kontroller.

targetSdk — API Level som appen testats på. Android-systemet använder targetSdk för att tillämpa beteendeförändringar: om appen inte har uppdaterats till den nya API Level aktiverar systemet kompatibilitetsläge för äldre versioner. Google Play kräver targetSdk inte lägre än en viss nivå — för 2026 är detta API 34 (Android 14).

Exempel på Gradle-konfiguration

android {
    compileSdk 35

    defaultConfig {
        applicationId "com.example.app"
        minSdk 26
        targetSdk 35
        versionCode 1
        versionName "1.0"
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

// Android SDK-versionen måste installeras via SDK Manager
// sdkmanager "platforms;android-35"

Hur man väljer compileSdk, minSdk och targetSdk

Valstrategin beror på projektets mål. För en ny app: compileSdk — senaste stabila (35 i början av 2026), minSdk — API 26 (Android 8.0, täcker 95 % av enheterna), targetSdk — senaste stabila. För att uppdatera en befintlig app: höj compileSdk omedelbart, targetSdk — efter testning av alla beteendeförändringar, minSdk — endast om det är nödvändigt att överge äldre enheter.

Google kräver att targetSdk uppdateras inom ett år efter lanseringen av en ny Android-version. Appar som inte uppfyller detta krav kan inte publicera uppdateringar i Google Play. Använd den officiella Android OS-uppdateringskalendern för att hålla reda på deadlines.

Exempel på arbete med SDK Platform i kod

Vid utveckling för olika Android-versioner måste man ta hänsyn till API-tillgänglighet. Om appen använder compileSdk 35 men körs på en enhet med API 31 leder anrop av metoder som lagts till i API 34 till NoSuchMethodError eller AbstractMethodError. För säkra anrop av nya API:er används versionskontroller via Build.VERSION.SDK_INT.

Kontroll av API Level under körning

class FeatureChecker {
    fun registerNotificationChannel(context: Context) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            // Notification channels är tillgängliga från API 26
            val channel = NotificationChannel(
                "updates",
                "Uppdateringar",
                NotificationManager.IMPORTANCE_DEFAULT
            )
            val manager = context.getSystemService(NotificationManager::class.java)
            manager.createNotificationChannel(channel)
        }
    }
}

Användning av nya API:er med @RequiresApi

För metoder som bara anropas på vissa versioner, använd annoteringen @RequiresApi. Detta talar om för lint-kontroller att metoden är säker och stänger av varningar. I kombination med SDK_INT-kontroll gör annoteringen koden renare och mer förståelig för granskare.

@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
fun scheduleExactAlarm(manager: AlarmManager, time: Long) {
    // API 34: scheduleExact med flaggan SCHEDULE_EXACT_ALARM
    if (manager.canScheduleExactAlarms()) {
        manager.setExact(AlarmManager.RTC_WAKEUP, time, pendingIntent)
    } else {
        // Begär tillståndet SCHEDULE_EXACT_ALARM
        val intent = Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM)
        context.startActivity(intent)
    }
}

fun safeScheduleAlarm(context: Context, triggerTime: Long) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
        scheduleExactAlarm(getAlarmManager(context), triggerTime)
    } else {
        // Gamla metoden setExact utan tillståndskontroll
        getAlarmManager(context).setExact(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent)
    }
}

Bestämning av installerad SDK Platform

Ibland behöver man veta vilken version av SDK Platform som är installerad på utvecklarens enhet eller i CI. Detta kan göras via ADB eller programmatiskt i appkoden. Kunskap om enhetens API Level hjälper vid testning av versionsspecifikt beteende.

fun logDeviceInfo() {
    with (Build.VERSION) {
        Log.d("SDK_Demo", "SDK_INT: $SDK_INT")
        Log.d("SDK_Demo", "RELEASE: $RELEASE")
        Log.d("SDK_Demo", "CODENAME: $CODENAME")
        Log.d("SDK_Demo", "PREVIEW_SDK_INT: $PREVIEW_SDK_INT")
    }
    // Utdata: SDK_INT: 35, RELEASE: 15, CODENAME: REL
}