Android: ce este, arhitectura sistemului și dezvoltare în Kotlin

Ce este Android?

Android este un sistem de operare mobil bazat pe nucleul Linux, dezvoltat de Google din 2007. Codul sursă este deschis sub licența Apache 2.0 ca parte a proiectului Android Open Source Project (AOSP). Fiecare producător poate modifica sistemul și îl poate instala pe dispozitivele sale.

Potrivit StatCounter (2026), Android deține aproximativ 72% din piața globală a sistemelor de operare mobile. Cei mai mari producători sunt Samsung, Xiaomi, Oppo, Vivo, Google Pixel. Fragmentarea este o problemă cheie a platformei: mii de modele cu diferite versiuni ale sistemului de operare sunt utilizate simultan.

Arhitectura Android este construită pe principiul permisiunilor (permissions): fiecare aplicație rulează sub un UID Linux separat și are acces doar la propriile date. Accesul la resursele sistemului (cameră, microfon, contacte) este solicitat prin Android Permissions în timpul rulării, începând cu Android 6 (API 23).

Istoria versiunilor Android

Android 1.0 a fost lansat în 2008 pe HTC Dream. Repere cheie: Android 4.0 Ice Cream Sandwich (interfață unificată pentru telefoane și tablete), Android 5.0 Lollipop (Material Design), Android 6.0 (permisiuni runtime), Android 10 (temă întunecată, gesturi), Android 12 (Material You). Din 2023, Google a trecut la lansări majore anuale fără nume de deserturi.

Arhitectura Android: patru straturi cheie

Arhitectura Android constă din patru straturi principale care izolează hardware-ul de aplicațiile utilizatorului. Fiecare strat folosește serviciile stratului inferior prin intermediul unor interfețe strict definite.

Nucleul Linux și HAL

Stratul inferior este un nucleu Linux modificat (LTS, versiunea 6.x în Android 15). Gestionează memoria, procesele, stiva de rețea și driverele. Hardware Abstraction Layer (HAL) oferă o API unificată pentru interacțiunea cu hardware-ul: cameră, Bluetooth, Wi-Fi, senzori. Producătorii implementează module HAL fără a afecta straturile superioare.

Android Runtime (ART)

ART execută bytecode DEX al aplicațiilor. Începând cu Android 5.0, ART a înlocuit Dalvik și folosește compilarea Ahead-of-Time (AOT) pentru performanță îmbunătățită. Fiecare aplicație are propriul proces cu o instanță ART separată. Colectarea gunoiului (GC) funcționează cu pauze minime — o pauză tipică GC este de 2–4 ms.

Application Framework

Framework-ul este stratul cu care dezvoltatorul lucrează direct. Include Activity Manager (stiva de ecrane), Content Providers (acces la date), Resource Manager (localizare, resurse), Notification Manager, Location Manager. Toate serviciile de sistem sunt apelate prin Binder IPC — mecanismul de comunicare inter-proces al Android.

// Exemplu de lucru cu Binder prin interfața AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementare serviciu
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
}

Aplicații de sistem

Stratul superior constă în aplicații standard de sistem: Telefon, Contacte, Cameră, Setări, Browser. Nu au privilegii mai mari decât aplicațiile utilizatorului, dar pot fi înlocuite de aplicații terțe. În Android 15, aplicațiile de sistem sunt actualizate prin Google Play System Updates independent de actualizările OTA ale producătorului.

Kotlin — limbaj principal de dezvoltare Android

Kotlin este un limbaj de programare tipizat static de la JetBrains care rulează pe JVM. Google a anunțat Kotlin ca limbaj oficial Android în 2017 la Google I/O. Kotlin este complet compatibil cu Java, dar elimină deficiențele sale: siguranța null, clase de date, funcții de extensie și corutine.

Siguranța Null și tipuri

Caracteristica principală a Kotlin este protecția integrată împotriva NullPointerException. Tipurile sunt împărțite în nullable (String?) și non-null (String). Compilatorul verifică accesul nullable în timpul compilării. Operatorul safe call (?.) și operatorul Elvis (?:) simplifică lucrul cu valori opționale fără verificări imbricate.

// Exemplu de cod Kotlin cu corutine și 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)
    }
}

Exemplul demonstrează corutinele (funcție suspend) pentru acces asincron la rețea și bază de date, Flow pentru observarea reactivă a modificărilor datelor și Result pentru gestionarea sigură a erorilor. Corutinele înlocuiesc callback-urile și RxJava fără overhead de fire de execuție.

Corutine Kotlin și Flow

Corutinele Kotlin sunt fire de execuție ușoare care rulează pe un pool comun de fire. Dispatchers.IO pentru rețea și disc, Dispatchers.Main pentru UI, Dispatchers.Default pentru sarcini intensive CPU. viewModelScope și lifecycleScope anulează automat corutinele când componentul este distrus.

// ViewModel cu corutine și 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 și instrumente de dezvoltare

Android Studio este IDE-ul oficial bazat pe IntelliJ IDEA, dezvoltat de Google. Include editor de cod, Layout Inspector, emulator de dispozitive, APK Analyzer, Profiler (CPU, Memorie, Rețea, Energie) și integrare Firebase. Android Studio 2024 (Ladybug) acceptă Kotlin 2.0 cu modul multi-platformă KMP.

Emulator Android

Emulatorul Android folosește KVM (Linux) sau Hyper-V (Windows) pentru accelerare hardware. Acceptă simulare GPS, senzori, cameră, apeluri și SMS. Google Pixel 9 Pro este configurația recomandată pentru testare cu API 35 și 8 GB RAM de emulator.

Android Profiler și depanare

Profilerul afișează în timp real încărcarea CPU, alocarea memoriei, cererile de rețea și consumul de energie. Memory Profiler permite dump heap și analiza scurgerilor prin arborele de referințe. Network Inspector înregistrează toate cererile HTTP/HTTPS cu corp și antete. Pentru analiză aprofundată se folosește Android Studio Canary.

Componente ale aplicației Android

O aplicație Android constă din patru tipuri de componente, fiecare cu propriul punct de intrare și ciclu de viață. Componentele sunt înregistrate în fișierul AndroidManifest.xml.

Activity și Intent

Activity este componenta de bază a interfeței de utilizator. Fiecare ecran este o Activity separată sau un Fragment în cadrul unei Activity. Navigarea între ecrane se face prin Intent — un obiect care conține o acțiune (ACTION_VIEW, ACTION_SEND) și date (URI). În Jetpack Navigation Graph, navigarea este descrisă în XML.

Service și WorkManager

Service execută sarcini în fundal, dar începând cu Android 8, serviciile de fundal sunt restricționate. WorkManager este biblioteca recomandată pentru sarcini de fundal amânate și garantate, cu suport pentru lanțuri, constrângeri (de exemplu, doar în timpul încărcării) și repornire după cădere.

Jetpack Compose vs XML Layouts

Alegerea între Jetpack Compose și aspectele XML tradiționale este principala decizie arhitecturală la începerea unui proiect Android. Aspectele XML (RecyclerView, ConstraintLayout, FrameLayout) sunt standardul din 2008. Jetpack Compose a fost introdus în 2021 ca alternativă declarativă.

Google recomandă Jetpack Compose pentru toate proiectele noi. Aspectele XML rămân relevante pentru suportul proiectelor moștenite și pentru cazurile în care este necesară o personalizare maximă a View (Canvas, SurfaceView). Codul Compose este în medie cu 40% mai scurt decât XML + ViewBinding echivalent.

// Jetpack Compose — ecran de profil utilizator
@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 = "Avatarul utilizatorului",
            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("Editează profilul")
        }
    }
}

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

Funcția ProfileScreen este declarată ca @Composable — descrie UI declarativ fără a crea instanțe View. Compose actualizează automat ecranul când user se schimbă. @Preview arată rezultatul direct în IDE fără compilare și rulare pe emulator.

Ciclul de viață al Activity și Fragment

Fiecare Activity din Android trece prin șase stări ale ciclului de viață: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment adaugă onAttach, onCreateView, onViewCreated. Înțelegerea ciclului de viață este esențială pentru gestionarea memoriei și prevenirea scurgerilor.

Stări principale ale Activity

onCreate — apelat o dată la crearea Activity. Aici se efectuează inițializarea: setContentView, configurarea adaptoarelor, abonarea LiveData. onResume — Activity este în prim-plan și interacționează cu utilizatorul. onPause — Activity pierde focalizarea (dialog, altă Activity). onStop — Activity nu este vizibilă. onDestroy — Activity este distrusă.

// Activity cu gestionarea ciclului de viață prin 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", "")
    }
}

Folosirea repeatOnLifecycle asigură că colectarea datelor se întrerupe când Activity trece în fundal și se reia când revine în prim-plan. Aceasta previne scurgerile și cererile de rețea inutile. onSaveInstanceState salvează starea temporară la rotirea ecranului.

Google Play: publicare și cerințe

Google Play este magazinul oficial de aplicații Android. Înregistrarea contului de dezvoltator costă 25 USD o singură dată. Fiecare aplicație trece printr-o verificare automată Google Play Integrity pentru cod malițios, încălcări ale politicilor și utilizare incorectă a permisiunilor.

Cerințe de publicare

Google cere semnarea aplicației prin Android App Bundle (AAB) sau APK. AAB este formatul recomandat, permițând generarea de APK-uri optimizate pentru fiecare configurație de dispozitiv. Aplicația trebuie semnată cu o cheie (keystore) cu un certificat valid. Google Play App Signing este criptarea opțională a cheii pe partea Google.

Politica de confidențialitate

Toate aplicațiile care solicită acces la date personale trebuie să furnizeze o Politică de confidențialitate. Din 2024, Google cere o declarație Data Safety — un formular care specifică tipurile de date colectate și scopurile procesării. Aplicațiile care vizează Android 14+ trebuie să utilizeze API-ul Declarations pentru declararea permisiunilor.