iOS : qu'est-ce que c'est, architecture du système et langage Swift

Qu'est-ce qu'iOS ?

iOS est le système d'exploitation mobile d'Apple, sorti pour la première fois en 2007 avec le premier iPhone. Le système est construit sur le micronoyau XNU, un noyau hybride combinant des composants de Mach et FreeBSD. Contrairement à Android, iOS est une plateforme fermée : l'installation d'applications n'est possible que via l'App Store et le code source du système n'est pas disponible.

Apple contrôle à la fois le matériel et le logiciel, garantissant un haut niveau d'optimisation. Selon StatCounter (2026), la part d'iOS sur le marché mondial des OS mobiles est d'environ 28 % et dépasse 50 % aux États-Unis et au Japon.

Le système utilise le modèle App Sandbox — chaque application s'exécute dans un environnement isolé et ne peut pas accéder aux données des autres applications sans autorisation explicite de l'utilisateur via des dialogues système.

Historique des versions d'iOS

La première version, iPhone OS 1.0, ne supportait pas les applications tierces. L'App Store est arrivé avec iOS 2.0 en 2008. Les jalons clés : iOS 4 (multitâche), iOS 7 (design plat), iOS 10 (iMessage Apps), iOS 14 (widgets sur le bureau), iOS 17 (mode StandBy). Chaque version majeure apporte de nouvelles API et frameworks.

Architecture d'iOS : quatre couches du système

L'architecture d'iOS se compose de quatre couches abstraites, chacune fournissant des API à la couche supérieure. Les couches inférieures sont le noyau et les services système, les couches supérieures sont les frameworks utilisateur.

Cocoa Touch — couche supérieure

Cocoa Touch est la couche de frameworks pour construire l'interface utilisateur. Elle inclut UIKit, SwiftUI, Foundation, MapKit, NotificationCenter et d'autres API avec lesquelles le développeur travaille directement. UIKit fournit UIViewController, UIView, UIWindow et tous les composants visuels.

Media — graphismes et son

La couche Media inclut Core Graphics, Core Animation, Core Image, AVFoundation et Metal. Metal est une API GPU bas niveau offrant des performances graphiques élevées dans les jeux et les applications de réalité augmentée. Core Animation gère les animations au niveau des couches avec accélération matérielle.

Core Services — services système

Core Services inclut Core Data, CloudKit, Core Location, HealthKit, Core Motion et Network. CFNetwork est une interface C bas niveau pour travailler avec les protocoles réseau. Foundation est un wrapper orienté objet autour de Core Foundation avec les classes NSString, NSArray, NSDictionary.

Core OS — noyau et sécurité

La couche inférieure inclut le noyau XNU, le système de fichiers APFS, les modules cryptographiques (CommonCrypto, Security.framework), la gestion d'alimentation et les pilotes de périphériques. Le Secure Enclave opère à ce niveau — un coprocesseur pour stocker les données biométriques et les clés de chiffrement.

// Vérification d'intégrité de Secure Enclave via Security framework
#import <LocalAuthentication/LocalAuthentication.h>

LAContext *context = [[LAContext alloc] init];
NSError *error = nil;

if ([context canEvaluatePolicy:LAPolicyDeviceOwnerAuthenticationWithBiometrics
                          error:&error]) {
    NSLog(@"Secure Enclave disponible pour la biométrie");
} else {
    NSLog(@"Secure Enclave indisponible : %@", error.localizedDescription);
}

Swift — le langage principal pour le développement iOS

Swift est un langage de programmation présenté par Apple en 2014 pour remplacer Objective-C. Il a été créé par Chris Lattner chez Apple. Swift combine la syntaxe des langages modernes (Rust, Kotlin, C#) avec des performances de niveau C. Selon TIOBE (2026), Swift figure dans le top 15 des langages de programmation.

Fonctionnalités clés de Swift

Swift utilise Automatic Reference Counting (ARC) pour la gestion de la mémoire sans ramasse-miettes. La programmation orientée protocole (POP) permet d'étendre les types via des extensions de protocole. Les optionnels offrent une gestion type-safe de nil, et le pattern matching simplifie la logique de branchement.

import UIKit

/// Protocole pour le service de chargement de données
protocol DataServiceProtocol {
    associatedtype T
    func fetch(completion: @escaping (Result<[T], Error>) -> Void)
}

/// Implémentation du service de chargement des utilisateurs
final class UserService: DataServiceProtocol {
    typealias T = User

    private let session: URLSession
    private let decoder: JSONDecoder

    init(session: URLSession = .shared, decoder: JSONDecoder = JSONDecoder()) {
        self.session = session
        self.decoder = decoder
    }

    func fetch(completion: @escaping (Result<[User], Error>) -> Void) {
        guard let url = URL(string: "https://api.example.com/users") else {
            completion(.failure(URLError(.badURL)))
            return
        }

        session.dataTask(with: url) { [weak self] data, response, error in
            guard let self, let data = data else {
                completion(.failure(error ?? URLError(.badServerResponse)))
                return
            }
            do {
                let users = try self.decoder.decode([User].self, from: data)
                completion(.success(users))
            } catch {
                completion(.failure(error))
            }
        }.resume()
    }
}

struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

L'exemple montre une implémentation de service de chargement de données utilisant Swift Concurrency (async/await), un protocole avec associatedtype et Codable pour le décodage JSON. L'ARC gère automatiquement la mémoire, et weak self empêche les cycles de références fortes dans les closures.

Swift Concurrency : async/await et Actors

Depuis iOS 13, Swift prend en charge l'asynchronisme intégré via async/await et les Actors — des types thread-safe qui protègent l'état contre les conditions de course. DispatchQueue pour le multithreading est progressivement remplacé par les structures async/await et Task.

actor UserRepository {
    private var cache: [Int: User] = [:]
    private let service = UserService()

    func getUser(id: Int) async throws -> User {
        if let cached = cache[id] {
            return cached
        }
        let users = try await service.fetchAsync()
        guard let user = users.first(where: { $0.id == id }) else {
            throw UserError.notFound
        }
        cache[id] = user
        return user
    }
}

L'acteur UserRepository garantit que l'accès au cache se fait sur un seul thread, éliminant les conditions de course. Le compilateur vérifie l'isolation à la compilation — l'accès à une propriété mutable d'un acteur n'est possible que via await.

Xcode et outils de développement

Xcode est l'environnement de développement intégré (IDE) d'Apple, disponible exclusivement sur macOS. Il comprend un éditeur de code, Interface Builder pour la conception visuelle, un simulateur de périphériques, Instruments pour le profilage et le débogueur LLDB. Xcode 15 prend en charge Swift 5.9 avec les macros.

Interface Builder et Storyboards

Interface Builder permet de créer des interfaces par glisser-déposer avec génération automatique de descriptions XML (XIB/Storyboard). Les Storyboards décrivent les flux d'écrans. Depuis 2023, Apple recommande SwiftUI Preview comme outil principal de développement visuel, bien qu'Interface Builder reste utilisé dans les projets UIKit.

Outils de débogage et de profilage

Xcode Instruments comprend des dizaines de modèles : Time Profiler (analyse CPU), Allocations (mémoire), Leaks (fuites), Core Animation (FPS), Network et Energy Log. Metal Debugger permet d'inspecter les appels GPU et les shaders. LLDB est un débogueur console avec support des expressions Swift et des points d'arrêt conditionnels.

Frameworks principaux du développement iOS

Le SDK iOS comprend des centaines de frameworks. Voici les principaux avec lesquels tout développeur iOS travaille quotidiennement.

Core Data : travail avec les données locales

Core Data est un framework pour gérer le modèle de données objet. Il permet de sauvegarder, charger et synchroniser des objets entre le thread UI et les contextes d'arrière-plan. iOS 17 a introduit SwiftData — un wrapper moderne autour de Core Data avec le support des macros Swift.

UIKit vs SwiftUI : comparaison des approches

Le choix entre UIKit et SwiftUI est une décision architecturale clé lors du démarrage du développement iOS. UIKit existe depuis 2007 et supporte toutes les versions d'iOS. SwiftUI a été présenté en 2019 et nécessite iOS 13+.

En pratique, la plupart des projets commerciaux utilisent une approche hybride : SwiftUI pour les nouveaux écrans et les formulaires simples, UIKit pour les composants personnalisés complexes nécessitant un contrôle fin du rendu. Apple investit activement dans SwiftUI et il devrait devenir le framework principal d'ici 2028.

Cycle de vie d'une application iOS

Chaque application iOS passe par cinq états gérés par UIApplication et AppDelegate. Dans SwiftUI, le protocole App avec l'attribut @main assume ce rôle.

États de l'application

Not running — l'application n'est pas lancée ou a été terminée par le système. Inactive — l'application est au premier plan mais ne reçoit pas d'événements (par exemple, lors d'un appel entrant). Active — état normal, l'application reçoit les événements tactiles. Background — l'application est minimisée, exécute des tâches en arrière-plan. Suspended — l'application est en mémoire mais n'exécute pas de code.

import SwiftUI

@main
struct MyApp: App {
    @Environment(\.scenePhase) private var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { oldPhase, newPhase in
            switch newPhase {
            case .active:
                print("L'application est devenue active")
            case .inactive:
                print("L'application est inactive")
            case .background:
                print("L'application est passée en arrière-plan")
            @unknown default:
                break
            }
        }
    }
}

Le système peut terminer l'application en arrière-plan lorsque la mémoire est insuffisante. Le développeur doit sauvegarder l'état dans onDisappear ou via ScenePhase.background pour que l'utilisateur ne perde pas de données lors du changement d'application.

App Store : publication et exigences

L'App Store est le seul magasin d'applications officiel pour iOS. La publication nécessite un abonnement au Apple Developer Program (99 $/an). Chaque application passe par une modération — automatique (analyse statique du binaire) et manuelle (vérification de l'interface et du contenu).

Processus de publication

Le développeur crée une archive dans Xcode et la télécharge via Transporter ou Xcode Organizer vers App Store Connect. Le temps de modération moyen est de 24 à 48 heures. L'App Review vérifie la conformité aux directives : sécurité des données, performances, conception HIG, absence de fonctionnalité cachée.

Exigences de l'App Review

Une attention particulière est portée à la confidentialité : tous les types de collecte de données doivent être déclarés dans le Privacy Manifest. Depuis 2025, Apple exige de spécifier les raisons d'utilisation des API (NSPrivacyAccessedAPITypes). Les applications utilisant des traqueurs sans consentement de l'utilisateur sont refusées.