Android: apa itu, arsitektur sistem dan pengembangan di Kotlin

Apa itu Android?

Android adalah sistem operasi seluler berbasis kernel Linux, dikembangkan oleh Google sejak 2007. Kode sumber terbuka di bawah lisensi Apache 2.0 sebagai bagian dari Android Open Source Project (AOSP). Setiap produsen dapat memodifikasi sistem dan menginstalnya di perangkat mereka.

Menurut StatCounter (2026), Android menguasai sekitar 72% pasar OS seluler global. Produsen terbesar adalah Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentasi adalah masalah utama platform: ribuan model dengan versi OS berbeda digunakan secara bersamaan.

Arsitektur Android dibangun di atas prinsip izin (permissions): setiap aplikasi berjalan di bawah UID Linux terpisah dan hanya memiliki akses ke datanya sendiri. Akses ke sumber daya sistem (kamera, mikrofon, kontak) diminta melalui Android Permissions saat runtime, dimulai dari Android 6 (API 23).

Sejarah Versi Android

Android 1.0 dirilis pada 2008 di HTC Dream. Tonggak penting: Android 4.0 Ice Cream Sandwich (UI terpadu untuk ponsel dan tablet), Android 5.0 Lollipop (Material Design), Android 6.0 (izin runtime), Android 10 (tema gelap, gestur), Android 12 (Material You). Sejak 2023, Google beralih ke rilis besar tahunan tanpa nama makanan penutup.

Arsitektur Android: Empat Lapisan Kunci

Arsitektur Android terdiri dari empat lapisan utama yang mengisolasi perangkat keras dari aplikasi pengguna. Setiap lapisan menggunakan layanan lapisan di bawahnya melalui antarmuka yang ditentukan secara ketat.

Kernel Linux dan HAL

Lapisan terbawah adalah kernel Linux yang dimodifikasi (LTS, versi 6.x di Android 15). Ia menangani manajemen memori, proses, tumpukan jaringan, dan driver. Hardware Abstraction Layer (HAL) menyediakan API terpadu untuk berinteraksi dengan perangkat keras: kamera, Bluetooth, Wi-Fi, sensor. Produsen mengimplementasikan modul HAL tanpa memengaruhi lapisan atas.

Android Runtime (ART)

ART menjalankan bytecode DEX aplikasi. Mulai dari Android 5.0, ART menggantikan Dalvik dan menggunakan kompilasi Ahead-of-Time (AOT) untuk meningkatkan kinerja. Setiap aplikasi memiliki prosesnya sendiri dengan instance ART terpisah. Pengumpulan sampah (GC) bekerja dengan jeda minimal — jeda GC tipikal adalah 2–4 ms.

Application Framework

Framework adalah lapisan yang langsung digunakan pengembang. Ini mencakup Activity Manager (tumpukan layar), Content Providers (akses data), Resource Manager (lokalisasi, sumber daya), Notification Manager, Location Manager. Semua layanan sistem dipanggil melalui Binder IPC — mekanisme komunikasi antar-proses Android.

// Contoh bekerja dengan Binder melalui antarmuka AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementasi layanan
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

Aplikasi Sistem

Lapisan atas terdiri dari aplikasi sistem standar: Telepon, Kontak, Kamera, Pengaturan, Peramban. Mereka tidak memiliki hak istimewa lebih tinggi dari aplikasi pengguna, tetapi dapat diganti dengan aplikasi pihak ketiga. Di Android 15, aplikasi sistem diperbarui melalui Google Play System Updates secara independen dari pembaruan OTA produsen.

Kotlin — Bahasa Utama Pengembangan Android

Kotlin adalah bahasa pemrograman bertipe statis dari JetBrains yang berjalan di JVM. Google mengumumkan Kotlin sebagai bahasa resmi Android pada 2017 di Google I/O. Kotlin sepenuhnya kompatibel dengan Java tetapi menghilangkan kekurangannya: keamanan null, kelas data, fungsi ekstensi, dan coroutine.

Keamanan Null dan Tipe

Fitur utama Kotlin adalah perlindungan bawaan terhadap NullPointerException. Tipe dibagi menjadi nullable (String?) dan non-null (String). Kompiler memeriksa akses nullable pada waktu kompilasi. Operator safe call (?.) dan operator Elvis (?:) menyederhanakan bekerja dengan nilai opsional tanpa pemeriksaan bersarang.

// Contoh kode Kotlin dengan coroutine dan Flow
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

Contoh menunjukkan coroutine (fungsi suspend) untuk akses jaringan dan basis data asinkron, Flow untuk pengamatan reaktif terhadap perubahan data, dan Result untuk penanganan kesalahan yang aman. Coroutine menggantikan callback dan RxJava tanpa overhead utas.

Coroutine Kotlin dan Flow

Coroutine Kotlin adalah utas ringan yang berjalan di kumpulan utas bersama. Dispatchers.IO untuk jaringan dan disk, Dispatchers.Main untuk UI, Dispatchers.Default untuk tugas intensif CPU. viewModelScope dan lifecycleScope secara otomatis membatalkan coroutine saat komponen dihancurkan.

// ViewModel dengan coroutine dan StateFlow
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio dan Alat Pengembangan

Android Studio adalah IDE resmi berbasis IntelliJ IDEA, dikembangkan oleh Google. Ini mencakup editor kode, Layout Inspector, emulator perangkat, APK Analyzer, Profiler (CPU, Memori, Jaringan, Energi) dan integrasi Firebase. Android Studio 2024 (Ladybug) mendukung Kotlin 2.0 dengan mode multi-platform KMP.

Emulator Android

Emulator Android menggunakan KVM (Linux) atau Hyper-V (Windows) untuk akselerasi perangkat keras. Ini mendukung simulasi GPS, sensor, kamera, panggilan, dan SMS. Google Pixel 9 Pro adalah konfigurasi yang direkomendasikan untuk pengujian dengan API 35 dan 8 GB RAM emulator.

Android Profiler dan Debugging

Profiler menampilkan beban CPU, alokasi memori, permintaan jaringan, dan konsumsi daya secara real-time. Memory Profiler memungkinkan pembuangan heap dan analisis kebocoran melalui pohon referensi. Network Inspector mencatat semua permintaan HTTP/HTTPS dengan body dan header. Untuk analisis mendalam, Android Studio Canary digunakan.

Komponen Aplikasi Android

Aplikasi Android terdiri dari empat jenis komponen, masing-masing dengan titik entri dan siklus hidupnya sendiri. Komponen didaftarkan di file AndroidManifest.xml.

Activity dan Intent

Activity adalah komponen dasar antarmuka pengguna. Setiap layar adalah Activity terpisah atau Fragment di dalam Activity. Navigasi antar layar dilakukan melalui Intent — objek yang berisi tindakan (ACTION_VIEW, ACTION_SEND) dan data (URI). Di Jetpack Navigation Graph, navigasi dijelaskan dalam XML.

Service dan WorkManager

Service menjalankan tugas latar belakang, tetapi mulai Android 8, layanan latar belakang dibatasi. WorkManager adalah pustaka yang direkomendasikan untuk tugas latar belakang yang ditunda dan dijamin dengan dukungan rantai, batasan (misalnya, hanya saat mengisi daya), dan mulai ulang setelah crash.

Jetpack Compose vs XML Layouts

Pilihan antara Jetpack Compose dan tata letak XML tradisional adalah keputusan arsitektur utama saat memulai proyek Android. Tata letak XML (RecyclerView, ConstraintLayout, FrameLayout) telah menjadi standar sejak 2008. Jetpack Compose diperkenalkan pada 2021 sebagai alternatif deklaratif.

Google merekomendasikan Jetpack Compose untuk semua proyek baru. Tata letak XML tetap relevan untuk dukungan proyek lama dan untuk kasus di mana kustomisasi View maksimal (Canvas, SurfaceView) diperlukan. Kode Compose rata-rata 40% lebih pendek dari XML + ViewBinding yang setara.

// Jetpack Compose — layar profil pengguna
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Avatar pengguna",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("Edit profil")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Anna Petrova", "anna@example.com"),
            onEditClick = {}
        )
    }
}

Fungsi ProfileScreen dideklarasikan sebagai @Composable — ia mendeskripsikan UI secara deklaratif tanpa membuat instance View. Compose secara otomatis memperbarui layar saat user berubah. @Preview menunjukkan hasil langsung di IDE tanpa membangun dan menjalankan di emulator.

Siklus Hidup Activity dan Fragment

Setiap Activity di Android melewati enam keadaan siklus hidup: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment menambahkan onAttach, onCreateView, onViewCreated. Memahami siklus hidup sangat penting untuk manajemen memori dan pencegahan kebocoran.

Keadaan Utama Activity

onCreate — dipanggil sekali saat Activity dibuat. Di sini inisialisasi dilakukan: setContentView, pengaturan adaptor, langganan LiveData. onResume — Activity di latar depan dan berinteraksi dengan pengguna. onPause — Activity kehilangan fokus (dialog, Activity lain). onStop — Activity tidak terlihat. onDestroy — Activity dihancurkan.

// Activity dengan penanganan siklus hidup melalui LifecycleScope
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

Penggunaan repeatOnLifecycle memastikan bahwa pengumpulan data berhenti saat Activity masuk ke latar belakang dan dilanjutkan saat kembali ke latar depan. Ini mencegah kebocoran dan permintaan jaringan yang tidak perlu. onSaveInstanceState menyimpan keadaan sementara saat rotasi layar.

Google Play: Publikasi dan Persyaratan

Google Play adalah toko aplikasi Android resmi. Pendaftaran akun pengembang biayanya $25 sekali. Setiap aplikasi menjalani pemeriksaan otomatis Google Play Integrity untuk kode berbahaya, pelanggaran kebijakan, dan penggunaan izin yang salah.

Persyaratan Publikasi

Google mewajibkan penandatanganan aplikasi melalui Android App Bundle (AAB) atau APK. AAB adalah format yang direkomendasikan, memungkinkan pembuatan APK yang dioptimalkan untuk setiap konfigurasi perangkat. Aplikasi harus ditandatangani dengan kunci (keystore) dengan sertifikat yang valid. Google Play App Signing adalah enkripsi kunci opsional di sisi Google.

Kebijakan Privasi

Semua aplikasi yang meminta akses ke data pribadi harus menyediakan Kebijakan Privasi. Sejak 2024, Google mewajibkan deklarasi Data Safety — formulir yang menentukan jenis data yang dikumpulkan dan tujuan pemrosesan. Aplikasi yang menargetkan Android 14+ harus menggunakan API Declarations untuk mendeklarasikan izin.