Android: cos'è, architettura di sistema e sviluppo in Kotlin

Cos'è Android?

Android è un sistema operativo mobile basato sul kernel Linux, sviluppato da Google dal 2007. Il codice sorgente è aperto sotto licenza Apache 2.0 nell'ambito del progetto Android Open Source Project (AOSP). Ogni produttore può modificare il sistema e installarlo sui propri dispositivi.

Secondo StatCounter (2026), Android detiene circa il 72% del mercato mondiale dei sistemi operativi mobili. I maggiori produttori sono Samsung, Xiaomi, Oppo, Vivo, Google Pixel. La frammentazione è un problema chiave della piattaforma: migliaia di modelli con diverse versioni del sistema operativo vengono utilizzati contemporaneamente.

L'architettura di Android è costruita sul principio dei permessi (permissions): ogni applicazione viene eseguita con un UID Linux separato e ha accesso solo ai propri dati. L'accesso alle risorse di sistema (fotocamera, microfono, contatti) viene richiesto tramite Android Permissions in fase di esecuzione, a partire da Android 6 (API 23).

Storia delle versioni di Android

Android 1.0 è stato rilasciato nel 2008 su HTC Dream. Tappe fondamentali: Android 4.0 Ice Cream Sandwich (interfaccia unificata per telefoni e tablet), Android 5.0 Lollipop (Material Design), Android 6.0 (permessi in fase di esecuzione), Android 10 (tema scuro, gesti), Android 12 (Material You). Dal 2023, Google è passata a versioni annuali senza nomi di dessert.

Architettura di Android: quattro livelli chiave

L'architettura di Android è composta da quattro livelli principali che isolano l'hardware dalle applicazioni utente. Ogni livello utilizza i servizi del livello sottostante attraverso interfacce strettamente definite.

Kernel Linux e HAL

Il livello inferiore è un kernel Linux modificato (LTS, versione 6.x in Android 15). Gestisce la memoria, i processi, lo stack di rete e i driver. L'Hardware Abstraction Layer (HAL) fornisce un'API unificata per interagire con l'hardware: fotocamera, Bluetooth, Wi-Fi, sensori. I produttori implementano moduli HAL senza influenzare i livelli superiori.

Android Runtime (ART)

ART esegue il bytecode DEX delle applicazioni. A partire da Android 5.0, ART ha sostituito Dalvik e utilizza la compilazione Ahead-of-Time (AOT) per migliorare le prestazioni. Ogni applicazione ha il proprio processo con una propria istanza ART. La garbage collection (GC) funziona con pause minime — una pausa tipica del GC è di 2–4 ms.

Application Framework

Il Framework è il livello con cui lo sviluppatore lavora direttamente. Include Activity Manager (stack di schermate), Content Providers (accesso ai dati), Resource Manager (localizzazione, risorse), Notification Manager, Location Manager. Tutti i servizi di sistema vengono chiamati tramite Binder IPC — il meccanismo di comunicazione inter-processo di Android.

// Esempio di lavoro con Binder tramite interfaccia AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementazione del servizio
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
}

App di sistema

Il livello superiore è costituito dalle applicazioni di sistema standard: Telefono, Contatti, Fotocamera, Impostazioni, Browser. Non hanno privilegi superiori rispetto alle app utente, ma possono essere sostituite da applicazioni di terze parti. In Android 15, le app di sistema vengono aggiornate tramite Google Play System Updates indipendentemente dagli aggiornamenti OTA del produttore.

Kotlin — linguaggio principale dello sviluppo Android

Kotlin è un linguaggio di programmazione staticamente tipizzato di JetBrains che funziona sulla JVM. Google ha annunciato Kotlin come lingua ufficiale di Android nel 2017 al Google I/O. Kotlin è completamente compatibile con Java ma ne elimina i difetti: null safety, classi dati, funzioni di estensione e coroutine.

Null Safety e tipi

La caratteristica principale di Kotlin è la protezione integrata contro NullPointerException. I tipi sono divisi in nullable (String?) e non-null (String). Il compilatore controlla l'accesso nullable in fase di compilazione. L'operatore safe call (?.) e l'operatore Elvis (?:) semplificano il lavoro con i valori opzionali senza controlli annidati.

// Esempio di codice Kotlin con coroutine e 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)
    }
}

L'esempio mostra le coroutine (funzione suspend) per l'accesso asincrono a rete e database, Flow per l'osservazione reattiva dei cambiamenti dei dati e Result per la gestione sicura degli errori. Le coroutine sostituiscono callback e RxJava senza overhead di thread.

Coroutine Kotlin e Flow

Le coroutine Kotlin sono thread leggeri eseguiti su un pool di thread condiviso. Dispatchers.IO per rete e disco, Dispatchers.Main per l'interfaccia utente, Dispatchers.Default per attività intensive di CPU. viewModelScope e lifecycleScope annullano automaticamente le coroutine quando il componente viene distrutto.

// ViewModel con coroutine e 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 e strumenti di sviluppo

Android Studio è l'IDE ufficiale basato su IntelliJ IDEA, sviluppato da Google. Include un editor di codice, Layout Inspector, emulatore di dispositivi, APK Analyzer, Profiler (CPU, Memoria, Rete, Energia) e integrazione con Firebase. Android Studio 2024 (Ladybug) supporta Kotlin 2.0 con modalità multipiattaforma KMP.

Emulatore Android

L'emulatore Android utilizza KVM (Linux) o Hyper-V (Windows) per l'accelerazione hardware. Supporta la simulazione di GPS, sensori, fotocamera, chiamate e SMS. Google Pixel 9 Pro è la configurazione consigliata per i test con API 35 e 8 GB di RAM dell'emulatore.

Android Profiler e debug

Il Profiler mostra in tempo reale il carico della CPU, l'allocazione della memoria, le richieste di rete e il consumo energetico. Memory Profiler consente il dump dell'heap e l'analisi delle perdite tramite l'albero dei riferimenti. Network Inspector registra tutte le richieste HTTP/HTTPS con corpo e intestazioni. Per analisi approfondite si utilizza Android Studio Canary.

Componenti di un'app Android

Un'app Android è composta da quattro tipi di componenti, ciascuno con il proprio punto di ingresso e ciclo di vita. I componenti vengono registrati nel file AndroidManifest.xml.

Activity e Intent

Activity è il componente base dell'interfaccia utente. Ogni schermata è un'Activity separata o un Fragment all'interno di un'Activity. La navigazione tra le schermate avviene tramite Intent — un oggetto contenente un'azione (ACTION_VIEW, ACTION_SEND) e dati (URI). In Jetpack Navigation Graph, la navigazione è descritta in XML.

Service e WorkManager

Service esegue attività in background, ma a partire da Android 8, i servizi in background sono limitati. WorkManager è la libreria consigliata per attività in background differite e garantite con supporto per catene, vincoli (ad esempio, solo durante la ricarica) e riavvio dopo un crash.

Jetpack Compose vs XML Layouts

La scelta tra Jetpack Compose e i layout XML tradizionali è la decisione architetturale principale all'avvio di un progetto Android. I layout XML (RecyclerView, ConstraintLayout, FrameLayout) sono lo standard dal 2008. Jetpack Compose è stato introdotto nel 2021 come alternativa dichiarativa.

Google raccomanda Jetpack Compose per tutti i nuovi progetti. I layout XML rimangono rilevanti per il supporto di progetti legacy e per i casi in cui è necessaria la massima personalizzazione della View (Canvas, SurfaceView). Il codice Compose è in media il 40% più corto del codice XML + ViewBinding equivalente.

// Jetpack Compose — schermata del profilo utente
@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 utente",
            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("Modifica profilo")
        }
    }
}

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

La funzione ProfileScreen è dichiarata come @Composable — descrive l'interfaccia utente in modo dichiarativo senza creare istanze di View. Compose aggiorna automaticamente la schermata quando user cambia. @Preview mostra il risultato direttamente nell'IDE senza compilare ed eseguire sull'emulatore.

Ciclo di vita di Activity e Fragment

Ogni Activity in Android attraversa sei stati del ciclo di vita: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment aggiunge onAttach, onCreateView, onViewCreated. Comprendere il ciclo di vita è fondamentale per la gestione della memoria e la prevenzione di perdite.

Stati principali dell'Activity

onCreate — chiamato una volta quando l'Activity viene creata. Qui viene eseguita l'inizializzazione: setContentView, configurazione degli adapter, sottoscrizione a LiveData. onResume — l'Activity è in primo piano e interagisce con l'utente. onPause — l'Activity perde il focus (dialogo, altra Activity). onStop — l'Activity non è visibile. onDestroy — l'Activity viene distrutta.

// Activity con gestione del ciclo di vita tramite 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", "")
    }
}

L'uso di repeatOnLifecycle garantisce che la raccolta dati si interrompa quando l'Activity va in background e riprenda quando torna in primo piano. Ciò previene perdite e richieste di rete non necessarie. onSaveInstanceState salva lo stato temporaneo durante la rotazione dello schermo.

Google Play: pubblicazione e requisiti

Google Play è il negozio ufficiale di app Android. La registrazione dell'account sviluppatore costa $25 una tantum. Ogni applicazione viene sottoposta a un controllo automatico di Google Play Integrity per rilevare codice dannoso, violazioni delle policy e uso errato dei permessi.

Requisiti di pubblicazione

Google richiede la firma dell'app tramite Android App Bundle (AAB) o APK. AAB è il formato consigliato, che consente di generare APK ottimizzati per ogni configurazione del dispositivo. L'applicazione deve essere firmata con una chiave (keystore) con un certificato valido. Google Play App Signing è una crittografia opzionale della chiave lato Google.

Informativa sulla privacy

Tutte le applicazioni che richiedono l'accesso a dati personali devono fornire un'Informativa sulla privacy. Dal 2024, Google richiede una dichiarazione Data Safety — un modulo che specifica i tipi di dati raccolti e le finalità del trattamento. Le applicazioni destinate ad Android 14+ devono utilizzare l'API Declarations per dichiarare i permessi.