Native App : concepts clés, développement natif iOS et Android

Qu'est-ce qu'une Native App

Native App — une application mobile développée spécifiquement pour une plateforme en utilisant son langage de programmation et ses outils natifs. Pour iOS, c'est Swift ou Objective-C avec Xcode, pour Android, Kotlin ou Java avec Android Studio. Le code est compilé directement en code machine de la plateforme (via LLVM pour iOS, ART pour Android), garantissant une vitesse d'exécution maximale.

Architecture d'une application native comprend trois couches. Couche de Présentation — composants UI (UIKit/SwiftUI sur iOS, Jetpack Compose/Android Views sur Android). Couche Domaine — logique métier avec cas d'utilisation et interfaces de dépôt. Couche Données — sources de données : réseau (URLSession/Alamofire sur iOS, Retrofit/OkHttp sur Android), base de données (CoreData/SwiftData, Room), système de fichiers. Chaque couche utilise des SDK natifs — par exemple, une app iOS peut appeler CoreLocation pour la géolocalisation, CoreBluetooth pour BLE, AVFoundation pour la caméra, Metal pour les graphiques 3D. Android offre des alternatives similaires : FusedLocationProvider pour la géo, BluetoothAdapter pour BLE, CameraX pour la caméra, OpenGL ES/Vulkan pour les graphiques.

Cycle de vie d'une native app diffère selon les plateformes. iOS utilise un modèle strict avec AppDelegate et SceneDelegate : l'application passe par les états notRunning → foregroundInactive → foregroundActive → background → suspended. Android utilise un modèle plus flexible avec Activity et Fragment : onCreate → onStart → onResume → onPause → onStop → onDestroy, et les processus peuvent être tués par le système en cas de pression mémoire. Le développeur doit gérer correctement la sauvegarde d'état (iOS : restauration d'état, Android : onSaveInstanceState) pour une expérience utilisateur fluide.

Développement iOS : Swift et Xcode

Développement iOS se fait exclusivement sur macOS dans l'environnement Xcode — l'environnement de développement intégré d'Apple comprenant un éditeur de code, Interface Builder, simulateur iOS et outils de profilage (Instruments). Le langage principal est Swift, présenté par Apple en 2014. Swift combine la sécurité des types avec des performances proches du C, et prend en charge les paradigmes POO, fonctionnel et orienté protocole.

Frameworks iOS clés :

• UIKit — le framework principal pour construire des interfaces avec une approche impérative (UIViewController, UIView, Auto Layout)
• SwiftUI — un framework déclaratif (iOS 13+) avec @State, @Binding, @ObservedObject pour des mises à jour réactives de l'UI
• Combine — un framework de programmation réactive avec Publisher/Subscriber pour gérer les événements asynchrones
• CoreData / SwiftData — frameworks pour le stockage persistant des données avec graphe d'objets et SQLite en arrière-plan
• URLSession — un client HTTP natif avec support HTTP/2, mise en cache et téléchargements en arrière-plan
• ARKit, CoreML, Vision — frameworks pour la RA, l'apprentissage automatique et la vision par ordinateur sur l'appareil

Outils Xcode incluent : Interface Builder pour la conception visuelle de l'UI, Asset Catalog pour la gestion des ressources, Swift Package Manager pour les dépendances, Test Navigator pour les tests unitaires et UI (XCTest), Organizer pour la publication sur l'App Store. Instruments permet le profilage du CPU, de la mémoire, du réseau, des graphiques et de la consommation d'énergie. Pour le CI/CD, Xcode Cloud ou des services tiers (GitHub Actions, Bitrise, Fastlane) sont utilisés.

Développement Android : Kotlin et Android Studio

Développement Android se fait dans Android Studio — un IDE basé sur IntelliJ IDEA de Google. Le langage principal est Kotlin, devenu le choix préféré en 2017. Kotlin est entièrement compatible avec Java mais offre une syntaxe plus concise, la null-safety via l'opérateur Elvis, les coroutines pour l'asynchrone et les fonctions d'extension. Android Studio inclut un Layout Editor pour la conception visuelle, un émulateur Android avec Google Play Services, APK Analyzer et Profiler.

Composants Android clés :

• Jetpack Compose — un framework UI déclaratif (Android 5+) avec des fonctions @Composable et un état réactif via mutableStateOf
• Android Views — un système impératif classique avec des layouts XML, Activity, Fragment, RecyclerView
• Room — une bibliothèque ORM pour SQLite avec vérification des requêtes à la compilation et support Flow
• Retrofit + OkHttp — une stack standard pour les requêtes HTTP avec intercepteurs, mise en cache et support des coroutines
• Hilt / Dagger — frameworks d'injection de dépendances basés sur JSR-330
• WorkManager — une API pour les tâches différées et d'arrière-plan avec garantie d'exécution même après redémarrage

Patrons architecturaux Android : Google recommande MVVM avec une couche Repository. ViewModel stocke l'état (StateFlow), Repository abstrait les sources de données, Use Cases encapsule la logique métier. Navigation Component gère les transitions entre écrans via un graphe de navigation. Pour les tests, JUnit, MockK, Compose UI Test et Espresso sont utilisés.

Exemple de code : Swift pour iOS

Créons une application iOS simple en SwiftUI — une liste de tâches avec persistance des données via SwiftData. L'application démontre les patrons clés du développement natif iOS : UI déclarative, mises à jour réactives, gestion des données.

import SwiftUI
import SwiftData

// 1. Modèle de données avec 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 avec logique métier
@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. Écran principal de l'application
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("Nouvelle tâche")) {
                    HStack {
                        TextField("Entrez un nom", text: $newTaskTitle)
                        Button("Ajouter") {
                            addTask()
                        }
                        .disabled(newTaskTitle.isEmpty)
                    }
                }
                Section(header: Text("Liste des tâches")) {
                    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("Mes tâches")
        }
    }

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

Patrons clés dans le code : @Model — une macro SwiftData pour la génération automatique de stockage persistant ; @Observable — une macro Observable pour les mises à jour réactives de l'UI ; @Query — un property wrapper pour le chargement automatique des données depuis SwiftData. L'application utilise l'architecture MVVM avec un ViewModel qui gère la logique métier et une View SwiftUI pour l'affichage. SwiftData sauvegarde automatiquement les données lors des changements de modèle — le développeur n'a pas besoin d'écrire de requêtes SQL.

Exemple de code : Kotlin pour Android

Une application Android similaire en Kotlin avec Jetpack Compose et Room. Montre les différences d'architecture et d'approches entre les plateformes.

// 1. Entity Room — modèle de données
@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 — requêtes à la base
@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 avec logique métier
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("Mes tâches", style = MaterialTheme.typography.headlineMedium)

        Row(
            modifier = Modifier.fillMaxWidth().padding(vertical = 8.dp)
        ) {
            OutlinedTextField(
                value = newTitle,
                onValueChange = { newTitle = it },
                label = { Text("Nouvelle tâche") },
                modifier = Modifier.weight(1f)
            )
            Button(
                onClick = { viewModel.addTask(newTitle); newTitle = "" },
                enabled = newTitle.isNotBlank()
            ) {
                Text("Ajouter")
            }
        }

        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
                    )
                }
            }
        }
    }
}

Différences clés avec iOS : Room utilise les annotations @Entity, @Dao et @Query pour travailler avec SQLite ; ViewModel gère le cycle de vie via viewModelScope avec des coroutines ; StateFlow fournit des mises à jour réactives de Compose UI via collectAsState. Sur Android, les données sont transmises via Flow — similaire à Combine Publisher, mais avec annulation lors du changement d'écran via viewModelScope.

Avantages et inconvénients de Native App

Avantages de native app par rapport aux solutions multiplateformes incluent plusieurs aspects clés. Performances : l'accès direct au GPU via Metal (iOS) et Vulkan (Android) offre 60 fps dans les animations complexes. Accès aux API : les nouvelles fonctionnalités iOS et Android sont disponibles le jour de leur sortie, sans attendre le support dans le framework. Expérience utilisateur : les composants UI natifs (NavigationStack, TabView, Sheet sur iOS ; Scaffold, NavigationBar, BottomSheet sur Android) offrent un comportement familier. Efficacité énergétique : le code natif consomme 15 à 25 % moins de batterie dans les tâches d'arrière-plan.

Inconvénients de native app : le coût de développement est 1,5 à 2 fois plus élevé en raison de la nécessité de deux équipes distinctes. Le délai de mise sur le marché augmente : deux développements parallèles nécessitent une coordination et doublent le volume de tests. Maintenance : les mises à jour doivent être publiées pour les deux plateformes simultanément, ce qui complique le CI/CD. Pour les applications simples (catalogues, flux, formulaires), les solutions multiplateformes peuvent être plus économiques et rapides.

Quand choisir native app : jeux et applications avec graphismes intensifs (Metal, Vulkan, ARKit, ARCore) ; applications avec intégration profonde dans l'OS (Bluetooth LE, NFC, CoreBluetooth, HealthKit, Google Fit) ; applications financières, médicales et d'entreprise avec des exigences de sécurité et de certification ; projets où chaque milliseconde de latence est critique (trading, streaming, appels vidéo). Pour les MVP, startups et applications simples, le développement multiplateforme peut être un choix plus rationnel.