SwiftUI dans le développement mobile : ce que c'est, concepts clés et fonctionnement

Bases (View Protocol, body, some View, @ViewBuilder)

View Protocol est le protocole central de SwiftUI. Il nécessite une seule propriété : var body: some View. body est une propriété calculée qui renvoie la description de l'UI. SwiftUI appelle body à chaque changement d'état et rend le résultat sur le GPU.

@ViewBuilder

@ViewBuilder est un Result Builder pour les Views. Permet d'écrire plusieurs Views dans une closure sans return et sans TupleView. Prend en charge if/else, switch, ForEach. Tous les conteneurs (VStack, HStack, ZStack, Group) utilisent @ViewBuilder. Une alternative est Group { … } pour regrouper sans mise en page. some View est un Opaque Type. Le compilateur connaît le type concret de la View (Text, Button, VStack, etc.), mais le renvoie extérieurement comme some View. Cela permet de changer le type de body sans modifier la signature. ViewModifier — modificateur de View : .font(), .padding(), .background(). Modificateur personnalisé via le protocole ViewModifier et .modifier().

// Exemple de View avec @ViewBuilder et NavigationStack
struct ContentView: View {
    @State private var items = ["Item 1", "Item 2"]

    var body: some View {
        NavigationStack {
            List(items, id: .self) { item in
                NavigationLink(item) {
                    DetailView(item: item)
                }
            }
            .navigationTitle("Items")
            .toolbar {
                ToolbarItem(placement: .navigationBarTrailing) {
                    Button("Add") {
                        items.append("New Item")
                    }
                }
            }
        }
    }
}

// DetailView avec @StateObject
struct DetailView: View {
    let item: String
    @StateObject private var viewModel = DetailViewModel()

    var body: some View {
        Text(item)
            .task {
                await viewModel.loadDetails(for: item)
            }
    }
}

Modificateurs et conteneurs (ViewModifier, NavigationStack, List, Form)

NavigationStack (iOS 16+) — navigation pilotée par les données. Prend un chemin (tableau de valeurs hashables) et affiche la destination via navigationDestination. Remplace NavigationLink avec des vues de destination. NavigationLink — bouton pour naviguer dans la pile. List — liste verticale avec sections, balayages, suppression et glisser-déposer. Form — une List spécialisée pour les paramètres : sections, sélecteurs, interrupteurs, champs de texte. Section — regroupement dans List/Form avec en-tête et pied de page. ViewModifier — modificateurs personnalisés pour réutiliser les styles. .modifier(CustomModifier()) — application.

List et Form en détail

List dans SwiftUI est l'équivalent de UITableView. Prend en charge .onDelete, .onMove, .refreshable. SwipeActions — .swipeActions { Button("Supprimer", role: .destructive) { } }. Form — optimisé pour les paramètres : DatePicker, Toggle, Stepper, Picker. Section avec en-tête/pied de page — pour regrouper. OutlineGroup — listes hiérarchiques (équivalent de UITableView avec sections). DisclosureGroup — section pliable avec contenu. IT Sectr recommande List pour les données et Form pour les paramètres.

PreviewProvider — protocole pour les aperçus dans Xcode Canvas. Canvas — aperçu interactif SwiftUI (nécessite @main et Swift 5.9+). @ScaledMetric — taille adaptative qui évolue avec Dynamic Type.

Gestion d'état (@StateObject, @ObservedObject, @EnvironmentObject, @FocusState)

Property Wrappers sont la base de la gestion d'état dans SwiftUI. @State — état local (type valeur). @Binding — connexion à l'état parent. @StateObject — crée un ObservableObject. SwiftUI gère le cycle de vie de l'objet. @ObservedObject — observe un ObservableObject externe. @EnvironmentObject — objet de l'environnement (injection de dépendances via .environmentObject()). @Environment — valeurs système (.colorScheme, .locale). @AppStorage — UserDefaults. @FetchRequest — requête Core Data. @FocusState — focus de saisie.

@StateObject vs @ObservedObject : @StateObject crée un objet, @ObservedObject l'observe. Utilisez @StateObject pour la création initiale du modèle dans la hiérarchie, @ObservedObject pour passer aux vues enfants. @FocusState — gestion du focus : .focused($field, equals: .email). Prend en charge enum pour plusieurs champs.

Valeurs d'environnement et DI

@Environment — valeurs système : colorScheme, locale, sizeCategory, layoutDirection, managedObjectContext. Valeurs d'environnement personnalisées — valeur personnalisée via EnvironmentKey. Utilisé pour l'injection de dépendances : passer des services sans paramètres explicites. Modificateur .environment() — définit une valeur dans la hiérarchie. @EnvironmentObject — ObservableObject depuis .environmentObject(). Diffère de @Environment car il transmet un type par référence. IT Sectr recommande @Environment pour les valeurs système et @EnvironmentObject pour les services.

Cycle de vie (.task, .onAppear, .onDisappear)

.task{} — opération asynchrone à l'apparition de la vue. Annulation automatique à la disparition. Remplace .onAppear pour async/await. .onAppear{} — opération synchrone à l'apparition. .onDisappear{} — opération à la disparition. .onChange(of:) — réaction aux changements de valeur. .onReceive(Publisher) — réaction au publisher Combine. Cycle de vie de la View dans SwiftUI : init → onAppear → body (rendu) → onDisappear. Lors du changement d'état : body → diff → nouveau rendu. IT Sectr recommande .task pour le chargement asynchrone et .onAppear pour les analytics.

Animation dans SwiftUI

.animation() — modificateur d'animation. .transition() — animation d'apparition/disparition. withAnimation — animation explicite des changements d'état. matchedGeometryEffect — animation entre différentes vues (hero animation). PhaseAnimator (iOS 17+) — animation multiphase basée sur enum. KeyframeAnimator (iOS 17+) — animation image par image avec keyframes. Les animations SwiftUI s'exécutent sur le GPU via Core Animation. IT Sectr recommande .spring() pour les animations naturelles et .interpolatingSpring pour les effets physiques.

Flux de données (Bindings, @Published, ObservableObject)

ObservableObject — protocole pour les objets avec propriétés @Published. SwiftUI s'abonne au publisher objectWillChange. @Published — publie les changements de propriété. @StateObject — crée ObservableObject, gère le cycle de vie. @ObservedObject — observe externe. Combine — framework pour la programmation réactive. @EnvironmentObject — DI via l'environnement. .environmentObject() définit, @EnvironmentObject lit. MVVM — architecture standard : View (SwiftUI) — ViewModel (ObservableObject) — Model. IT Sectr recommande MVVM + @StateObject pour les ViewModels principaux.

class UserViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false

    func loadUsers() async {
        isLoading = true
        defer { isLoading = false }
        do {
            users = try await api.fetchUsers()
        } catch {
            print("Erreur : \(error)")
        }
    }
}

struct UsersView: View {
    @StateObject private var viewModel = UserViewModel()

    var body: some View {
        List(viewModel.users, id: \.id) { user in
            Text(user.name)
        }
        .task { await viewModel.loadUsers() }
        .overlay {
            if viewModel.isLoading { ProgressView() }
        }
    }
}

Accessibilité et localisation

Accessibilité dans SwiftUI : .accessibilityLabel(), .accessibilityHint(), .accessibilityValue(), .accessibilityAddTraits(). VoiceOver lit les étiquettes d'accessibilité. Dynamic Type — @ScaledMetric, @DynamicProperty. Localisation : String(localized:) (SwiftUI + String Catalog). LocalizedStringKey — traduction automatique. Règles de pluriel — via String Catalog (one, few, many, other). Droite à gauche (arabe, hébreu) — pris en charge automatiquement. .environment(.layoutDirection, .rightToLeft). IT Sectr recommande des étiquettes d'accessibilité pour tous les éléments interactifs.

struct AccessibleButton: View {
    let action: () -> Void

    var body: some View {
        Button(action: action) {
            Label("Settings", systemImage: "gear")
        }
        .accessibilityLabel("Open Settings")
        .accessibilityHint("Double tap to navigate to settings screen")
        .accessibilityAddTraits(.isButton)
    }
}

// Prise en charge de Dynamic Type
struct ScalableText: View {
    @ScaledMetric private var fontSize: CGFloat = 17

    var body: some View {
        Text("Hello, World!")
            .font(.system(size: fontSize))
    }
}

Graphiques et visualisation (Swift Charts)

Swift Charts (iOS 16+) — framework pour construire des graphiques. Chart { } — conteneur de base. BarMark, LineMark, PointMark, AreaMark, RuleMark — marques. ForEach pour les données. ChartAxis — personnalisation des axes. .chartXAxis, .chartYAxis. ChartLegend — légende. Interpolation — catmullRom, linear, step. Animation — .animation() pour Chart. IT Sectr recommande Swift Charts pour les graphiques intégrés et Charts (DGCharts) pour les complexes.

import Charts

struct MonthlySales: Identifiable {
    let id = UUID()
    let month: String
    let sales: Double
}

struct SalesChart: View {
    let data: [MonthlySales]

    var body: some View {
        Chart(data) { item in
            BarMark(
                x: .value("Month", item.month),
                y: .value("Sales", item.sales)
            )
            .foregroundStyle(.blue.gradient)
        }
        .chartXAxisLabel("Month")
        .chartYAxisLabel("Sales")
        .frame(height: 200)
        .padding()
    }
}

Swift Package Manager (SPM) — le gestionnaire de dépendances d'Apple. Intégré à Xcode. Prend en charge : paquets binaires, ressources, tests, swift-6 concurrence stricte. Publication de paquets via GitHub avec tag semver. SPM est la norme de facto pour les dépendances Swift, remplaçant CocoaPods et Carthage. IT Sectr recommande SPM pour tous les nouveaux projets.

Swift Concurrency (async/await, TaskGroup, AsyncSequence) — async/await intégré à Swift 5.5+. Task — unité d'asynchronisme. TaskGroup — tâches parallèles. AsyncSequence — séquence asynchrone (AsyncStream, AsyncAlgorithms). Task Local Values — données contextuelles pour Task. Swift Concurrency remplace complètement Combine pour les opérations asynchrones.