Android: ano ito, arkitektura ng sistema at pag-develop sa Kotlin

Ano ang Android?

Android ay isang mobile operating system batay sa Linux kernel, na binuo ng Google mula noong 2007. Ang source code ay bukas sa ilalim ng lisensya ng Apache 2.0 bilang bahagi ng Android Open Source Project (AOSP). Bawat tagagawa ay maaaring magbago ng sistema at i-install ito sa kanilang mga device.

Ayon sa StatCounter (2026), ang Android ay humahawak ng halos 72% ng pandaigdigang merkado ng mobile OS. Ang pinakamalaking tagagawa ay Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Ang fragmentation ay isang pangunahing problema ng platform: libu-libong modelo na may iba't ibang bersyon ng OS ang ginagamit nang sabay-sabay.

Ang arkitektura ng Android ay binuo sa prinsipyo ng mga pahintulot (permissions): bawat app ay tumatakbo sa ilalim ng hiwalay na Linux UID at may access lamang sa sarili nitong data. Ang access sa mga mapagkukunan ng system (camera, mikropono, mga contact) ay hinihiling sa pamamagitan ng Android Permissions sa runtime, simula sa Android 6 (API 23).

Kasaysayan ng Bersyon ng Android

Android 1.0 ay inilabas noong 2008 sa HTC Dream. Mga pangunahing milyahe: Android 4.0 Ice Cream Sandwich (pinag-isang UI para sa mga telepono at tablet), Android 5.0 Lollipop (Material Design), Android 6.0 (mga pahintulot sa runtime), Android 10 (madilim na tema, mga kilos), Android 12 (Material You). Mula noong 2023, lumipat ang Google sa taunang pangunahing release na walang pangalan ng dessert.

Arkitektura ng Android: Apat na Pangunahing Layer

Ang arkitektura ng Android ay binubuo ng apat na pangunahing layer na naghihiwalay ng hardware mula sa mga application ng gumagamit. Bawat layer ay gumagamit ng mga serbisyo ng layer sa ibaba sa pamamagitan ng mahigpit na tinukoy na mga interface.

Linux Kernel at HAL

Ang pinakamababang layer ay isang binagong Linux kernel (LTS, bersyon 6.x sa Android 15). Ito ay humahawak ng pamamahala ng memorya, mga proseso, network stack, at mga driver. Ang Hardware Abstraction Layer (HAL) ay nagbibigay ng pinag-isang API para sa pakikipag-ugnayan sa hardware: camera, Bluetooth, Wi-Fi, sensor. Ang mga tagagawa ay nagpapatupad ng mga module ng HAL nang hindi naaapektuhan ang mga layer sa itaas.

Android Runtime (ART)

Ang ART ay nagpapatupad ng DEX bytecode ng mga application. Simula sa Android 5.0, pinalitan ng ART ang Dalvik at gumagamit ng Ahead-of-Time (AOT) compilation para sa pinabuting pagganap. Bawat app ay may sariling proseso na may hiwalay na instance ng ART. Ang pagtitipon ng basura (GC) ay gumagana nang may kaunting paghinto — isang tipikal na paghinto ng GC ay 2–4 ms.

Application Framework

Ang Framework ay ang layer na direktang ginagamit ng developer. Kabilang dito ang Activity Manager (stack ng screen), Content Providers (access sa data), Resource Manager (lokalisasyon, mapagkukunan), Notification Manager, Location Manager. Lahat ng serbisyo ng system ay tinatawag sa pamamagitan ng Binder IPC — mekanismo ng komunikasyon sa pagitan ng proseso ng Android.

// Halimbawa ng pagtatrabaho sa Binder sa pamamagitan ng AIDL interface
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Pagpapatupad ng serbisyo
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
}

Mga App ng Sistema

Ang pinakamataas na layer ay binubuo ng mga karaniwang system app: Telepono, Mga Contact, Camera, Setting, Browser. Wala silang mas mataas na pribilehiyo kaysa sa user app, ngunit maaaring palitan ng third-party app. Sa Android 15, ang mga system app ay ina-update sa pamamagitan ng Google Play System Updates nang hiwalay sa OTA update ng tagagawa.

Kotlin — Pangunahing Wika ng Pag-develop ng Android

Kotlin ay isang statically-typed programming language mula sa JetBrains na tumatakbo sa JVM. Inanunsyo ng Google ang Kotlin bilang opisyal na wika ng Android noong 2017 sa Google I/O. Ang Kotlin ay ganap na katugma sa Java ngunit inaalis ang mga kakulangan nito: kaligtasan sa null, mga klase ng data, mga extension function, at coroutine.

Kaligtasan sa Null at Mga Uri

Ang pangunahing tampok ng Kotlin ay ang built-in na proteksyon laban sa NullPointerException. Ang mga uri ay nahahati sa nullable (String?) at non-null (String). Sinusuri ng compiler ang nullable access sa oras ng pagbuo. Pinapasimple ng safe call (?.) at Elvis operator (?:) ang pagtatrabaho sa mga opsyonal na halaga nang walang nested na pagsusuri.

// Halimbawa ng Kotlin code na may coroutine at 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)
    }
}

Ang halimbawa ay nagpapakita ng coroutine (suspend function) para sa asynchronous na network at database access, Flow para sa reaktibong pagmamasid ng mga pagbabago sa data, at Result para sa ligtas na paghawak ng error. Pinapalitan ng coroutine ang callback at RxJava nang walang overhead ng thread.

Kotlin Coroutine at Flow

Ang Kotlin coroutine ay magaan na thread na tumatakbo sa isang shared thread pool. Dispatchers.IO para sa network at disk, Dispatchers.Main para sa UI, Dispatchers.Default para sa mga gawaing masinsinang CPU. Awtomatikong kinakansela ng viewModelScope at lifecycleScope ang coroutine kapag ang component ay nawasak.

// ViewModel na may coroutine at 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 at Mga Tool sa Pag-develop

Android Studio ay ang opisyal na IDE batay sa IntelliJ IDEA, na binuo ng Google. Kabilang dito ang editor ng code, Layout Inspector, emulator ng device, APK Analyzer, Profiler (CPU, Memorya, Network, Enerhiya) at integrasyon ng Firebase. Ang Android Studio 2024 (Ladybug) ay sumusuporta sa Kotlin 2.0 na may multi-platform na KMP mode.

Emulator ng Android

Ang emulator ng Android ay gumagamit ng KVM (Linux) o Hyper-V (Windows) para sa hardware acceleration. Sumusuporta ito sa simulation ng GPS, sensor, camera, tawag, at SMS. Ang Google Pixel 9 Pro ay ang inirerekomendang configuration para sa pagsubok na may API 35 at 8 GB RAM ng emulator.

Android Profiler at Pag-debug

Ang Profiler ay nagpapakita ng real-time na CPU load, paglalaan ng memorya, mga kahilingan sa network, at pagkonsumo ng enerhiya. Ang Memory Profiler ay nagpapahintulot ng heap dump at pagsusuri ng leak sa pamamagitan ng reference tree. Ang Network Inspector ay nagtatala ng lahat ng HTTP/HTTPS request na may body at header. Para sa malalim na pagsusuri, ginagamit ang Android Studio Canary.

Mga Bahagi ng Android App

Ang isang Android app ay binubuo ng apat na uri ng mga bahagi, bawat isa ay may sariling entry point at siklo ng buhay. Ang mga bahagi ay nirerehistro sa file na AndroidManifest.xml.

Activity at Intent

Activity ay ang pangunahing bahagi ng user interface. Bawat screen ay isang hiwalay na Activity o Fragment sa loob ng Activity. Ang nabigasyon sa pagitan ng mga screen ay ginagawa sa pamamagitan ng Intent — isang bagay na naglalaman ng aksyon (ACTION_VIEW, ACTION_SEND) at data (URI). Sa Jetpack Navigation Graph, ang nabigasyon ay inilalarawan sa XML.

Service at WorkManager

Service ay nagsasagawa ng mga background task, ngunit simula sa Android 8, ang mga background service ay limitado. Ang WorkManager ay ang inirerekomendang library para sa mga deferred at garantisadong background task na may suporta para sa mga chain, constraint (hal., habang nagcha-charge), at pag-restart pagkatapos ng crash.

Jetpack Compose kumpara sa XML Layouts

Ang pagpili sa pagitan ng Jetpack Compose at tradisyonal na XML layout ay ang pangunahing desisyong arkitektural kapag nagsisimula ng proyekto sa Android. Ang XML Layout (RecyclerView, ConstraintLayout, FrameLayout) ay ang pamantayan mula noong 2008. Ang Jetpack Compose ay ipinakilala noong 2021 bilang isang deklaratibong alternatibo.

Inirerekomenda ng Google ang Jetpack Compose para sa lahat ng bagong proyekto. Ang XML Layout ay nananatiling may kaugnayan para sa suporta ng legacy na proyekto at para sa mga kaso kung saan kailangan ang pinakamataas na pagpapasadya ng View (Canvas, SurfaceView). Ang Compose code ay average na 40% na mas maikli kaysa sa katumbas na XML + ViewBinding.

// Jetpack Compose — screen ng profile ng user
@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 ng user",
            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("I-edit ang profile")
        }
    }
}

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

Ang function na ProfileScreen ay idineklara bilang @Composable — inilalarawan nito ang UI nang deklaratibo nang hindi gumagawa ng mga instance ng View. Awtomatikong ina-update ng Compose ang screen kapag nagbago ang user. Ipinapakita ng @Preview ang resulta nang direkta sa IDE nang hindi nagbu-build at nagpapatakbo sa emulator.

Siklo ng Buhay ng Activity at Fragment

Bawat Activity sa Android ay dumadaan sa anim na estado ng siklo ng buhay: onCreate, onStart, onResume, onPause, onStop, onDestroy. Nagdaragdag ang Fragment ng onAttach, onCreateView, onViewCreated. Ang pag-unawa sa siklo ng buhay ay kritikal para sa pamamahala ng memorya at pag-iwas sa leak.

Mga Pangunahing Estado ng Activity

onCreate — tinawag nang isang beses kapag ginawa ang Activity. Dito isinasagawa ang pagsisimula: setContentView, pag-setup ng adapter, subscription sa LiveData. onResume — ang Activity ay nasa foreground at nakikipag-ugnayan sa user. onPause — nawawalan ng focus ang Activity (dialog, ibang Activity). onStop — hindi nakikita ang Activity. onDestroy — nawasak ang Activity.

// Activity na may paghawak ng siklo ng buhay sa pamamagitan ng 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", "")
    }
}

Ang paggamit ng repeatOnLifecycle ay tinitiyak na ang pagtitipon ng data ay hihinto kapag ang Activity ay napupunta sa background at magpapatuloy kapag bumalik ito sa foreground. Pinipigilan nito ang mga leak at hindi kinakailangang mga kahilingan sa network. Ine-save ng onSaveInstanceState ang pansamantalang estado sa pag-ikot ng screen.

Google Play: Pag-publish at Mga Kinakailangan

Google Play ay ang opisyal na tindahan ng Android app. Ang pagpaparehistro ng account ng developer ay nagkakahalaga ng $25 isang beses. Bawat app ay sumasailalim sa awtomatikong pagsusuri ng Google Play Integrity para sa malisyosong code, paglabag sa patakaran, at maling paggamit ng pahintulot.

Mga Kinakailangan sa Pag-publish

Kinakailangan ng Google ang pag-sign ng app sa pamamagitan ng Android App Bundle (AAB) o APK. Ang AAB ay ang inirerekomendang format, na nagpapahintulot sa pagbuo ng mga optimize na APK para sa bawat configuration ng device. Ang app ay dapat na sign ng isang key (keystore) na may wastong sertipiko. Ang Google Play App Signing ay opsyonal na pag-encrypt ng key sa panig ng Google.

Patakaran sa Pagkapribado

Lahat ng app na humihiling ng access sa personal na data ay dapat magbigay ng Patakaran sa Pagkapribado. Mula noong 2024, kinakailangan ng Google ang deklarasyon ng Data Safety — isang form na tumutukoy sa mga uri ng nakolektang data at mga layunin ng pagproseso. Ang mga app na nagta-target ng Android 14+ ay dapat gumamit ng Declarations API para sa pagdeklara ng mga pahintulot.