API Level: apa itu, versi API dan targetSdk

Apa itu API Level Android?

API Level Android adalah pengidentifikasi bilangan bulat yang ditetapkan untuk setiap rilis publik dari Android Framework API. Rilis pertama Android 1.0 memiliki API Level 1, Android 1.5 — API Level 3, Android 2.2 — API Level 8, Android 4.0 — API Level 14, Android 8.0 — API Level 26, Android 12 — API Level 31, Android 14 — API Level 34, Android 15 — API Level 35, Android 16 (2025) — API Level 36. Setiap API Level baru dapat menambahkan kelas, metode, konstanta, izin baru dan mengubah perilaku yang sudah ada.

API Level tidak selalu bertambah 1 dengan setiap rilis. Misalnya, Android 4.4W (Wear) memiliki API 20, sedangkan Android 5.0 — API 21. Kesenjangan terkait dengan iterasi internal dan perangkat Wear OS. Penting bagi pengembang untuk mengetahui bukan nama versi (KitKat, Lollipop, Tiramisu), tetapi API Level-nya — inilah yang digunakan dalam kode untuk pemeriksaan kompatibilitas.

Tujuan utama API Level adalah kompatibilitas mundur. Aplikasi yang dikompilasi terhadap API 34 dapat berjalan pada perangkat dengan API 34 dan di bawahnya (jika tidak menggunakan API baru tanpa pemeriksaan). Android Runtime (ART) memeriksa panggilan API di tingkat sistem dan menerapkan perubahan perilaku tergantung pada targetSdkVersion aplikasi.

Bagaimana Android menangani API Level

Saat menginstal aplikasi, PackageManager memeriksa apakah API Level perangkat >= minSdkVersion dari AndroidManifest.xml. Jika kondisi tidak terpenuhi — instalasi diblokir dengan pesan "App not installed". Selama runtime, Android Runtime memantau panggilan API yang memerlukan API Level lebih tinggi dan menghasilkan NoSuchMethodError atau UnsatisfiedLinkError jika metode tidak ada dalam versi saat ini.

minSdk, targetSdk, compileSdk: perbedaan dan peran setiap parameter

Dalam file build.gradle (Module: app), pengembang menentukan tiga parameter API Level: minSdkVersion, targetSdkVersion dan compileSdkVersion. Membingungkan mereka adalah salah satu kesalahan paling umum di kalangan pengembang Android pemula. Setiap parameter bertanggung jawab untuk aspek kompatibilitas yang berbeda, dan nilainya harus konsisten.

minSdkVersion

minSdkVersion adalah API Level minimum di mana aplikasi dapat diinstal dan dijalankan. Perangkat dengan API Level di bawah minSdk tidak melihat aplikasi di Google Play dan tidak dapat menginstalnya. Nilai dipilih berdasarkan target audiens: minSdk 21 (Android 5.0) mencakup 97% perangkat, minSdk 26 (Android 8.0) — sekitar 85%, minSdk 31 (Android 12) — sekitar 55% (data dari Android Studio Distribution Dashboard, 2026). Semakin rendah minSdk, semakin luas jangkauannya, tetapi semakin banyak kode kompatibilitas mundur yang diperlukan.

targetSdkVersion

targetSdkVersion adalah API Level yang digunakan untuk menguji aplikasi. Android menggunakan targetSdk untuk menerapkan perubahan perilaku: jika aplikasi menentukan targetSdk 33, sistem mengaktifkan semua perubahan perilaku yang diperkenalkan di API 33. Jika targetSdk adalah 31, sistem tidak menerapkan perubahan API 32-33, mempertahankan kompatibilitas dengan perilaku lama. Ini adalah parameter terpenting untuk keamanan: Google Play mensyaratkan targetSdk tidak lebih dari 1 tahun dari API Level saat ini.

compileSdkVersion

compileSdkVersion adalah versi Android SDK yang digunakan untuk mengkompilasi kode. Menentukan API mana yang tersedia saat kompilasi. compileSdk harus >= targetSdk dan, idealnya, sama dengan API Level stabil terbaru. Menaikkan compileSdk tidak mempengaruhi perilaku runtime — hanya ketersediaan API baru untuk kompilator. Setelah menaikkan compileSdk, Anda perlu memeriksa kode untuk API yang tidak digunakan lagi dan persyaratan izin baru.

// build.gradle.kts — contoh konfigurasi API Level
plugins {
    id("com.android.application") version "8.7.0"
    id("org.jetbrains.kotlin.android") version "2.1.0"
}

android {
    namespace = "com.example.myapp"
    compileSdk = 36  // Android 16

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

    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }

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

    kotlinOptions {
        jvmTarget = "17"
    }
}

dependencies {
    implementation("androidx.core:core-ktx:1.15.0")
    implementation("androidx.appcompat:appcompat:1.7.0")
    implementation("androidx.activity:activity-ktx:1.9.3")
}

Dalam contoh build.gradle.kts, compileSdk = 36 (terbaru pada saat penulisan), targetSdk = 36, minSdk = 26 (Android 8.0). compileSdk 36 memberikan akses ke semua API Android 16. targetSdk 36 mengaktifkan semua perubahan perilaku Android 16. minSdk 26 mencakup ~85% perangkat. AndroidX Activity KTX dan AppCompat menyediakan kompatibilitas mundur untuk fragmen dan tema.

AndroidManifest.xml

Parameter minSdk dan targetSdk juga dapat ditentukan di AndroidManifest.xml, tetapi proyek modern menggunakan build.gradle — nilai dari Gradle menimpa manifes. Di manifes, mungkin berguna untuk menentukan untuk pustaka dan modul yang tidak menggunakan konfigurasi build Gradle.

Perubahan Perilaku: bagaimana targetSdk mempengaruhi perilaku aplikasi

Perubahan perilaku adalah modifikasi cara kerja sistem Android yang hanya diterapkan pada aplikasi dengan targetSdk >= API Level tertentu. Setiap rilis Android baru memperkenalkan perubahan perilaku yang dapat merusak aplikasi yang ada jika tidak diperbarui. Ini adalah mekanisme keamanan utama Android: aplikasi lama terus bekerja seperti sebelumnya, yang baru mengikuti aturan saat ini.

Perubahan perilaku utama berdasarkan versi

Android 10 (API 29) — Scoped Storage: aplikasi dengan targetSdk 29+ tidak memiliki akses langsung ke sistem file bersama, hanya melalui MediaStore, SAF atau penyimpanan sendiri. Android 11 (API 30) — Package Visibility: filter paket, aplikasi hanya melihat paket yang diinstal yang berinteraksi dengannya. Android 12 (API 31) — Foreground Service Notification: semua layanan latar depan wajib menampilkan notifikasi dalam 10 detik setelah dimulai. Android 13 (API 33) — POST_NOTIFICATIONS: izin runtime untuk notifikasi push. Android 14 (API 34) — Foreground Service Types: deklarasi wajib jenis layanan latar depan di manifes.

// Penanganan perubahan perilaku Android 13 (API 33): POST_NOTIFICATIONS
import android.Manifest
import android.content.pm.PackageManager
import android.os.Build
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.ContextCompat

class NotificationHelper {

    fun requestNotificationPermission(activity: MainActivity) {
        // Izin POST_NOTIFICATIONS hanya berfungsi dengan API 33+
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
            return  // Di bawah API 33 izin tidak diperlukan
        }

        when {
            ContextCompat.checkSelfPermission(
                activity,
                Manifest.permission.POST_NOTIFICATIONS
            ) == PackageManager.PERMISSION_GRANTED -> {
                // Izin sudah diberikan, notifikasi dapat dikirim
                showNotification(activity)
            }

            activity.shouldShowRequestPermissionRationale(
                Manifest.permission.POST_NOTIFICATIONS
            ) -> {
                // Tampilkan penjelasan mengapa izin diperlukan
                activity.showRationale()
            }

            else -> {
                // Minta izin
                activity.requestPermissionLauncher.launch(
                    Manifest.permission.POST_NOTIFICATIONS
                )
            }
        }
    }

    private fun showNotification(context: Context) {
        // Buat dan tampilkan notifikasi
        val notification = android.app.Notification.Builder(context, "default_channel")
            .setSmallIcon(android.R.drawable.ic_dialog_info)
            .setContentTitle("Notifikasi")
            .setContentText("Pesan baru")
            .build()
        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE)
            as android.app.NotificationManager
        manager.notify(1, notification)
    }
}

// Daftarkan requestPermissionLauncher di Activity
class MainActivity : ComponentActivity() {
    val requestPermissionLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        if (isGranted) {
            // Izin diberikan
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Contoh penanganan POST_NOTIFICATIONS di Kotlin: periksa Build.VERSION.SDK_INT >= TIRAMISU, minta izin runtime melalui ActivityResultContracts.RequestPermission, tangani hasil di callback. Tanpa izin ini, aplikasi dengan targetSdk 33+ tidak dapat menampilkan notifikasi push. Di bawah API 33 izin tidak diperlukan — kode pemeriksaan mencegah pemanggilan API yang tidak tersedia.

Scoped Storage (Android 10+)

Scoped Storage adalah salah satu perubahan perilaku yang paling signifikan. Mulai dari API 29 (targetSdk 29+), aplikasi tidak dapat memperoleh akses file langsung ke direktori Pictures, Downloads, Music dan Documents. Sebagai gantinya, MediaStore digunakan untuk media, SAF (Storage Access Framework) untuk file arbitrer, dan getExternalFilesDir() untuk penyimpanan sendiri. Pengecualian adalah aplikasi dengan izin MANAGE_EXTERNAL_STORAGE, yang memerlukan persetujuan Google Play.

Persyaratan Google Play untuk API Level dan targetSdk

Google Play menetapkan persyaratan targetSdkVersion wajib untuk menerbitkan aplikasi. Sejak Agustus 2024, Google Play mensyaratkan targetSdkVersion >= API 33 (Android 13). Setiap tahun ambang batas meningkat: aplikasi dan pembaruan baru harus menentukan targetSdk tidak lebih dari 1 tahun dari API Level utama saat ini. Pelanggaran persyaratan mengakibatkan pemblokiran publikasi dan penghapusan aplikasi dari toko.

Mengapa Google Play memperketat persyaratan

Alasan utamanya adalah keamanan. Setiap API Level Android baru memperkenalkan perubahan perilaku yang menutup vektor serangan: Scoped Storage (API 29) mencegah pencurian file, POST_NOTIFICATIONS (API 33) melindungi dari notifikasi spam, Foreground Service Types (API 34) membatasi layanan latar belakang tersembunyi. Aplikasi dengan targetSdk rendah tidak menerima perlindungan ini dan menjadi ancaman bagi pengguna. Google Play tidak dapat mengizinkan aplikasi usang pada perangkat modern.

Memeriksa kepatuhan terhadap persyaratan

Google Play Console memeriksa targetSdkVersion saat mengunggah APK/AAB. Jika targetSdk di bawah yang disyaratkan — konsol memblokir publikasi dengan pesan: "Your app currently targets API level X and must target at least API level Y". Pengembang harus memperbarui build.gradle, mengkompilasi ulang aplikasi, menguji perubahan perilaku dan mengunggah ulang. Format AAB direkomendasikan untuk semua publikasi baru (wajib sejak Agustus 2021).

Memeriksa API Level dalam kode: Build.VERSION.SDK_INT

Build.VERSION.SDK_INT adalah konstanta bilangan bulat statis yang berisi API Level perangkat tempat aplikasi dijalankan. Ini adalah alat utama untuk pemeriksaan versi Android saat runtime. Build.VERSION_CODES berisi konstanta bernama untuk setiap API Level: VERSION_CODES.TIRAMISU (33), VERSION_CODES.UPSIDE_DOWN_CAKE (34), VERSION_CODES.VANILLA_ICE_CREAM (35). Perbandingan melalui if (SDK_INT >= VERSION_CODES.TIRAMISU) adalah pola standar.

// Contoh pemeriksaan API Level dalam kode Android
import android.os.Build
import android.os.Build.VERSION
import android.os.Build.VERSION_CODES
import android.graphics.drawable.AdaptiveIconDrawable

class ApiLevelHelper {

    // 1. Pemeriksaan API Level dasar
    fun isAtLeastTiramisu(): Boolean {
        return VERSION.SDK_INT >= VERSION_CODES.TIRAMISU  // 33
    }

    // 2. Panggilan API adaptif dengan pemeriksaan
    fun getAdaptiveIcon(drawable: android.graphics.drawable.Drawable):
            android.graphics.drawable.Drawable? {
        // AdaptiveIconDrawable hanya tersedia dengan API 26 (Android 8)
        if (VERSION.SDK_INT >= VERSION_CODES.O) {
            return AdaptiveIconDrawable(drawable, null)
        }
        return drawable  // fallback untuk perangkat lama
    }

    // 3. Pemeriksaan izin POST_NOTIFICATIONS (hanya API 33+)
    fun canRequestNotificationPermission(): Boolean {
        return VERSION.SDK_INT >= VERSION_CODES.TIRAMISU
    }

    // 4. Memilih penyedia gambar berdasarkan API Level
    fun getImagePickerProvider(): String {
        return when {
            VERSION.SDK_INT >= VERSION_CODES.UPSIDE_DOWN_CAKE -> {
                // API 34+ menggunakan PhotoPicker
                "photo_picker"
            }
            VERSION.SDK_INT >= VERSION_CODES.KITKAT -> {
                // API 19+ menggunakan Intent ACTION_OPEN_DOCUMENT
                "open_document"
            }
            else -> {
                // Legacy: ACTION_GET_CONTENT (semua versi)
                "get_content"
            }
        }
    }

    // 5. Pemeriksaan gaya Java melalui @TargetApi (untuk kompatibilitas mundur)
    @Suppress("DEPRECATION")
    fun checkLegacyStorage(): Boolean {
        // Perilaku Scoped Storage tergantung pada targetSdk, bukan SDK_INT
        return VERSION.SDK_INT < VERSION_CODES.Q  // Android 10
    }

    // 6. Informasi build untuk analitik
    fun getDeviceApiInfo(): Map<String, Any> {
        return mapOf(
            "sdk_int" to VERSION.SDK_INT,
            "release" to VERSION.RELEASE,
            "codename" to VERSION.CODENAME,
            "incremental" to VERSION.INCREMENTAL,
            "preview_sdk" to VERSION.PREVIEW_SDK_INT
        )
    }
}

// Pengujian
fun main() {
    val helper = ApiLevelHelper()
    println("API Level: ${VERSION.SDK_INT}")
    println("Is Tiramisu+: ${helper.isAtLeastTiramisu()}")
}

Kelas ApiLevelHelper mendemonstrasikan semua pola pemeriksaan API Level utama: isAtLeastTiramisu dengan SDK_INT >= VERSION_CODES, getAdaptiveIcon dengan fallback untuk versi lama, getImagePickerProvider dengan when multi-cabang, getDeviceApiInfo untuk analitik. Aturan utamanya adalah jangan memanggil API baru tanpa memeriksa SDK_INT, jika tidak aplikasi akan crash dengan NoSuchMethodError pada perangkat lama.

ANT (Android New API) dan lint

Android Studio menyertakan analis statis lint, yang memperingatkan tentang penggunaan API di atas minSdkVersion. Jika suatu metode dipanggil tanpa pemeriksaan SDK_INT, lint menyorotnya sebagai kesalahan: "Call requires API level 34 (current min is 26)". Solusi: tambahkan @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE) ke metode atau pemeriksaan if SDK_INT. @TargetApi adalah anotasi yang tidak digunakan lagi, @RequiresApi direkomendasikan.

Tabel korespondensi API Level dan versi Android

Tabel API Level adalah alat referensi bagi pengembang. Mengetahui API Level perangkat, Anda dapat menentukan versi Android dan fitur yang tersedia. Tabel mencantumkan semua rilis Android utama dari API Level 1 (2008) hingga API Level 36 (2025). Nama kode (Cupcake, Donut, Tiramisu, VanillaIceCream) digunakan secara internal di Google dan di VERSION_CODES.

Tabel: API Level ambang untuk perubahan perilaku

Tabel berikut menunjukkan API Level utama yang memperkenalkan perubahan perilaku yang merusak kompatibilitas mundur saat menaikkan targetSdk: