Native App: concetti chiave, sviluppo nativo iOS e Android

Cos'è Native App

Native App — un'applicazione mobile sviluppata specificamente per una piattaforma utilizzando il suo linguaggio di programmazione e strumenti nativi. Per iOS è Swift o Objective-C con Xcode, per Android Kotlin o Java con Android Studio. Il codice viene compilato direttamente in codice macchina della piattaforma (tramite LLVM per iOS, ART per Android), garantendo la massima velocità di esecuzione.

Architettura di un'app nativa include tre livelli. Livello di Presentazione — componenti UI (UIKit/SwiftUI su iOS, Jetpack Compose/Android Views su Android). Livello di Dominio — logica di business con casi d'uso e interfacce repository. Livello Dati — fonti dati: rete (URLSession/Alamofire su iOS, Retrofit/OkHttp su Android), database (CoreData/SwiftData, Room), file system. Ogni livello utilizza SDK nativi — ad esempio, un'app iOS può chiamare CoreLocation per geolocalizzazione, CoreBluetooth per BLE, AVFoundation per fotocamera, Metal per grafica 3D. Android offre alternative simili: FusedLocationProvider per geo, BluetoothAdapter per BLE, CameraX per fotocamera, OpenGL ES/Vulkan per grafica.

Ciclo di vita di native app differisce tra piattaforme. iOS utilizza un modello rigoroso con AppDelegate e SceneDelegate: l'app passa attraverso gli stati notRunning → foregroundInactive → foregroundActive → background → suspended. Android utilizza un modello più flessibile con Activity e Fragment: onCreate → onStart → onResume → onPause → onStop → onDestroy, inoltre i processi possono essere terminati dal sistema in caso di pressione di memoria. Lo sviluppatore deve gestire correttamente il salvataggio dello stato (iOS: state restoration, Android: onSaveInstanceState) per un'esperienza utente continua.

Sviluppo iOS: Swift e Xcode

Sviluppo iOS viene effettuato esclusivamente su macOS nell'ambiente Xcode — l'ambiente di sviluppo integrato di Apple che include editor di codice, Interface Builder, simulatore iOS e strumenti di profilazione (Instruments). Il linguaggio principale è Swift, presentato da Apple nel 2014. Swift combina sicurezza dei tipi con prestazioni vicine al C, e supporta paradigmi OOP, funzionale e orientato ai protocolli.

Framework iOS chiave:

• UIKit — il framework principale per costruire interfacce con approccio imperativo (UIViewController, UIView, Auto Layout)
• SwiftUI — un framework dichiarativo (iOS 13+) con @State, @Binding, @ObservedObject per aggiornamenti reattivi dell'UI
• Combine — un framework di programmazione reattiva con Publisher/Subscriber per gestire eventi asincroni
• CoreData / SwiftData — framework per archiviazione persistente dei dati con grafo oggetti e SQLite sottostante
• URLSession — un client HTTP nativo con supporto HTTP/2, caching e download in background
• ARKit, CoreML, Vision — framework per realtà aumentata, apprendimento automatico e visione artificiale sul dispositivo

Strumenti Xcode includono: Interface Builder per progettazione visiva UI, Asset Catalog per gestione risorse, Swift Package Manager per dipendenze, Test Navigator per test unitari e UI (XCTest), Organizer per pubblicazione su App Store. Instruments consente la profilazione di CPU, memoria, rete, grafica e consumo energetico. Per CI/CD si utilizzano Xcode Cloud o servizi di terze parti (GitHub Actions, Bitrise, Fastlane).

Sviluppo Android: Kotlin e Android Studio

Sviluppo Android viene effettuato in Android Studio — un IDE basato su IntelliJ IDEA di Google. Il linguaggio principale è Kotlin, diventato la scelta preferita nel 2017. Kotlin è completamente compatibile con Java ma offre una sintassi più concisa, null-safety tramite operatore Elvis, coroutine per asincronia e funzioni di estensione. Android Studio include un Layout Editor per progettazione visiva, un emulatore Android con Google Play Services, APK Analyzer e Profiler.

Componenti Android chiave:

• Jetpack Compose — un framework UI dichiarativo (Android 5+) con funzioni @Composable e stato reattivo tramite mutableStateOf
• Android Views — un sistema imperativo classico con layout XML, Activity, Fragment, RecyclerView
• Room — una libreria ORM per SQLite con verifica query in fase di compilazione e supporto Flow
• Retrofit + OkHttp — uno stack standard per richieste HTTP con intercettori, caching e supporto coroutine
• Hilt / Dagger — framework di dependency injection basati su JSR-330
• WorkManager — un'API per attività differite e in background con garanzia di esecuzione anche dopo il riavvio

Pattern architetturali Android: Google raccomanda MVVM con un livello Repository. ViewModel memorizza lo stato (StateFlow), Repository astrae le fonti dati, Use Cases incapsula la logica di business. Navigation Component gestisce le transizioni tra schermate tramite un grafo di navigazione. Per i test si utilizzano JUnit, MockK, Compose UI Test ed Espresso.

Esempio di codice: Swift per iOS

Consideriamo la creazione di un'app iOS semplice in SwiftUI — un elenco di attività con salvataggio dati tramite SwiftData. L'app dimostra i pattern chiave dello sviluppo nativo iOS: UI dichiarativa, aggiornamenti reattivi, gestione dati.

import SwiftUI
import SwiftData

// 1. Modello dati con SwiftData
@Model
final class TaskItem {
    var title: String
    var isCompleted: Bool
    var createdAt: Date

    init(title: String) {
        self.title = title
        self.isCompleted = false
        self.createdAt = Date()
    }
}

// 2. ViewModel con logica di business
@Observable
final class TaskViewModel {
    var tasks: [TaskItem] = []

    func addTask(title: String, context: ModelContext) {
        let task = TaskItem(title: title)
        context.insert(task)
        tasks.append(task)
    }

    func toggleTask(task: TaskItem) {
        task.isCompleted.toggle()
    }
}

// 3. Schermata principale dell'app
struct ContentView: View {
    @Environment(\.modelContext) private var context
    @State private var viewModel = TaskViewModel()
    @State private var newTaskTitle = ""
    @Query private var tasks: [TaskItem]

    var body: some View {
        NavigationStack {
            List {
                Section(header: Text("Nuova attività")) {
                    HStack {
                        TextField("Inserisci un nome", text: $newTaskTitle)
                        Button("Aggiungi") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Elenco attività")) {
                    ForEach(tasks) { task in
                        HStack {
                            Image(systemName: task.isCompleted ? "checkmark.circle.fill" : "circle")
                                .onTapGesture { viewModel.toggleTask(task: task) }
                            Text(task.title)
                                .strikethrough(task.isCompleted)
                            Spacer()
                            Text(task.createdAt, style: .date)
                                .font(.caption)
                                .foregroundColor(.secondary)
                        }
                    }
                    .onDelete { indexSet in
                        for index in indexSet {
                            context.delete(tasks[index])
                        }
                    }
                }
            }
            .navigationTitle("Le mie attività")
        }
    }

    private func addTask() {
        guard !newTaskTitle.isEmpty else { return }
        viewModel.addTask(title: newTaskTitle, context: context)
        newTaskTitle = ""
    }
}

Pattern chiave nel codice: @Model — un macro SwiftData per generazione automatica di archiviazione persistente; @Observable — un macro Observable per aggiornamenti reattivi dell'UI; @Query — un property wrapper per caricamento automatico dei dati da SwiftData. L'app utilizza l'architettura MVVM con un ViewModel che gestisce la logica di business e una View SwiftUI per la visualizzazione. SwiftData salva automaticamente i dati quando il modello cambia — lo sviluppatore non deve scrivere query SQL.

Esempio di codice: Kotlin per Android

Un'app Android simile in Kotlin con Jetpack Compose e Room. Mostra le differenze nell'architettura e negli approcci tra piattaforme.

// 1. Entity Room — modello dati
@Entity(tableName = "tasks")
data class TaskEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val title: String,
    val isCompleted: Boolean = false,
    val createdAt: Long = System.currentTimeMillis()
)

// 2. DAO — query al database
@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks ORDER BY createdAt DESC")
    fun getAllTasks(): Flow<List<TaskEntity>>

    @Insert
    suspend fun insertTask(task: TaskEntity)

    @Delete
    suspend fun deleteTask(task: TaskEntity)
}

// 3. ViewModel con logica di business
class TaskViewModel(private val dao: TaskDao) : ViewModel() {
    val tasks: StateFlow<List<TaskEntity>> = dao
        .getAllTasks()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun addTask(title: String) {
        viewModelScope.launch {
            dao.insertTask(TaskEntity(title = title))
        }
    }

    fun toggleTask(task: TaskEntity) {
        viewModelScope.launch {
            dao.insertTask(task.copy(isCompleted = !task.isCompleted))
        }
    }
}

// 4. Compose UI
@Composable
fun TaskScreen(viewModel: TaskViewModel = viewModel()) {
    val tasks by viewModel.tasks.collectAsState()
    var newTitle by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        Text("Le mie attività", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("Nuova attività") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("Aggiungi")
            }
        }

        LazyColumn {
            items(tasks, key = { it.id }) { task ->
                Row(
                    modifier = Modifier
                        .fillMaxWidth()
                        .clickable { viewModel.toggleTask(task) }
                        .padding(vertical = 4.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Checkbox(checked = task.isCompleted, onCheckedChange = { viewModel.toggleTask(task) })
                    Text(
                        text = task.title,
                        textDecoration = if (task.isCompleted) TextDecoration.LineThrough else TextDecoration.None
                    )
                }
            }
        }
    }
}

Differenze chiave da iOS: Room utilizza annotazioni @Entity, @Dao e @Query per lavorare con SQLite; ViewModel gestisce il ciclo di vita tramite viewModelScope con coroutine; StateFlow fornisce aggiornamenti reattivi di Compose UI tramite collectAsState. Su Android, i dati vengono trasmessi tramite Flow — simile a Combine Publisher, ma con annullamento al cambio di schermata tramite viewModelScope.

Vantaggi e svantaggi di Native App

Vantaggi di native app rispetto alle soluzioni multipiattaforma includono diversi aspetti chiave. Prestazioni: accesso diretto alla GPU tramite Metal (iOS) e Vulkan (Android) offre 60 fps in animazioni complesse. Accesso alle API: le nuove funzionalità di iOS e Android sono disponibili il giorno dell'uscita, senza attendere il supporto nel framework. Esperienza utente: i componenti UI nativi (NavigationStack, TabView, Sheet su iOS; Scaffold, NavigationBar, BottomSheet su Android) offrono un comportamento familiare. Efficienza energetica: il codice nativo consuma il 15–25% in meno di batteria nelle attività in background.

Svantaggi di native app: il costo di sviluppo è 1,5–2 volte superiore a causa della necessità di due team separati. Il time-to-market aumenta: due sviluppi paralleli richiedono coordinazione e raddoppiano il volume di test. Manutenzione: gli aggiornamenti devono essere rilasciati per entrambe le piattaforme simultaneamente, complicando il CI/CD. Per app semplici (cataloghi, feed, moduli), le soluzioni multipiattaforma possono essere più economiche e rapide.

Quando scegliere native app: giochi e applicazioni con grafica intensiva (Metal, Vulkan, ARKit, ARCore); applicazioni con integrazione profonda nell'OS (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit); applicazioni finanziarie, mediche e aziendali con requisiti di sicurezza e certificazione; progetti dove ogni millisecondo di latenza è critico (trading, streaming, videochiamate). Per MVP, startup e applicazioni semplici, lo sviluppo multipiattaforma può essere una scelta più razionale.