Belajar Mobile Developer - Arsitektur Platform Mobile

#Pendahuluan

Setelah memahami peran mobile developer di episode 1, sekarang kita turun ke tingkat paling bawah: bagaimana platform mobile bekerja. Android dan iOS bukan sekadar "tema yang berbeda" — keduanya punya filosofi, lifecycle, dan model sandboxing yang berbeda secara fundamental. Memahami lapisan ini adalah pembeda antara developer yang hanya "menempel kode" dan developer yang bisa membangun aplikasi stabil.

Dua konsep kunci yang harus kalian kuasai sejak awal: lifecycle (bagaimana OS menghidupkan/mematikan aplikasi) dan sandboxing (batas keamanan antar aplikasi). Keduanya menentukan hampir semua keputusan desain yang akan kita bahas di episode-episode berikutnya.

#Anatomi Aplikasi Android

#Proses dan Sandbox

Setiap aplikasi Android berjalan dalam proses Linux terpisah dengan UID (User ID) sendiri — ini adalah sandbox OS-level. Aplikasi tidak bisa membaca file aplikasi lain tanpa izin eksplisit (permission). Konsekuensi praktisnya: Android mendukung banyak aplikasi berjalan bersamaan, dan OS bebas "membunuh" proses aplikasi kalian kapan saja saat memori penuh.

#Activity dan Lifecycle

Unit layar di Android adalah Activity (dengan Compose, komponen UI di dalamnya). Lifecycle activity: onCreate → onStart → onResume → (running) → onPause → onStop → onDestroy. Saat aplikasi dibunuh OS, tidak ada callback perpisahan — inilah kenapa state harus disimpan sebelum onStop.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            FitkuTheme {
                HomeScreen()
            }
        }
    }
}

#Thread dan Main Thread

Semua update UI wajib terjadi di main thread. Operasi berat (network, database) harus dipindah ke background thread. Kotlin memudahkan ini dengan coroutines:

lifecycleScope.launch(Dispatchers.IO) {
    val data = fetchWorkoutFromApi()
    withContext(Dispatchers.Main) {
        uiState.value = data
    }
}

Melanggar aturan main-thread menyebabkan ANR (Application Not Responding) — dialog "app is not responding" yang merusak reputasi aplikasi.

#Anatomi Aplikasi iOS

#App Sandbox dan App Bundle

iOS menerapkan sandbox lebih ketat: setiap aplikasi punya container directory sendiri dan hanya bisa membaca wilayahnya. Tidak ada multitasking penuh seperti Android — iOS menampilkan satu aplikasi foreground, dan aplikasi background di-suspend (dibekukan). App Store Review juga memvalidasi perilaku ini.

#App Lifecycle dan State

Di SwiftUI, lifecycle diwakili oleh scene state: active, inactive, background. Semua inisialisasi dimulai dari @main App struct:

@main
struct FitkuApp: App {
    var body: some Scene {
        WindowGroup {
            HomeView()
        }
    }
}

Saat aplikasi masuk background, iOS memberikan brief window (beberapa detik) untuk menyimpan state. Setelah itu proses di-suspend — berbeda dengan Android yang bisa tetap jalan via background service (topik episode 14).

#Main Queue dan Concurrency

Sama seperti Android, update UI wajib di main queue. Swift menawarkan async/await dan MainActor untuk keamanan thread:

func loadWorkouts() async {
    let data = await api.fetchWorkouts()
    await MainActor.run {
        viewModel.workouts = data
    }
}

#Perbandingan Kedua Platform

Kedua platform sama-sama menuntut: update UI di main thread, simpan state sebelum background, dan hormati batas sandbox.

#Praktik: Hello World di Dua Platform

#Android

Buat proyek baru Empty Views Activity, lalu ganti setContent dengan teks sederhana:

Hello World Android

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Text(text = "Halo dari Fitku (Android)")
        }
    }
}

Jalankan di emulator. Perhatikan: Gradle mengunduh dependensi di build pertama, wajar jika memakan waktu beberapa menit.

#iOS

Buat proyek baru SwiftUI App di Xcode, lalu ganti isi ContentView:

struct ContentView: View {
    var body: some View {
        Text("Halo dari Fitku (iOS)")
    }
}

Tekan Run (⌘R) untuk menjalankan di simulator.

#Penutup

Pada episode 2 ini, kalian telah membongkar lapisan dasar kedua platform:

• Android dan iOS sama-sama menerapkan sandboxing dan main-thread rule, tapi dengan mekanisme berbeda (proses Linux vs app container).
• Android memberi kontrol background lebih bebas; iOS lebih ketat dengan suspensi otomatis.
• Lifecycle adalah kunci: state wajib disimpan sebelum onStop/background.
• Hello world pertama di dua platform sukses dijalankan.

Di episode 3 selanjutnya kita masuk ke Android secara mendalam dengan Kotlin & Jetpack Compose — struktur proyek, composable functions, state, Material 3, dan membangun halaman pertama aplikasi Fitku. Pastikan emulator kalian siap, karena mulai sekarang kita menulis aplikasi sungguhan!