SwiftUI în dezvoltarea mobilă: ce este, concepte cheie și cum funcționează

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

View Protocol este protocolul central al SwiftUI. Necesită o singură proprietate: var body: some View. body este o proprietate calculată care returnează descrierea UI. SwiftUI apelează body la fiecare schimbare de stare și randează rezultatul pe GPU.

@ViewBuilder

@ViewBuilder este un Result Builder pentru Views. Permite scrierea mai multor Views într-un closure fără return și fără TupleView. Suportă if/else, switch, ForEach. Toate containerele (VStack, HStack, ZStack, Group) folosesc @ViewBuilder. O alternativă este Group { … } pentru grupare fără layout. some View este un Opaque Type. Compilatorul știe tipul concret de View (Text, Button, VStack, etc.), dar îl returnează extern ca some View. Acest lucru permite schimbarea tipului body fără modificarea semnăturii. ViewModifier — modificator de View: .font(), .padding(), .background(). Modificator personalizat prin ViewModifier protocol și .modifier().

// Exemplu View cu @ViewBuilder și 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 cu @StateObject
struct DetailView: View {
    let item: String
    @StateObject private var viewModel = DetailViewModel()

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

Modificatori și containere (ViewModifier, NavigationStack, List, Form)

NavigationStack (iOS 16+) — navigare bazată pe date. Primește un drum (matrice de valori hashable) și afișează destinația prin navigationDestination. Înlocuiește NavigationLink cu vederi de destinație. NavigationLink — buton pentru navigarea în stivă. List — listă verticală cu secțiuni, glisări, ștergere și drag-and-drop. Form — un List specializat pentru setări: secțiuni, selectoare, comutatoare, câmpuri text. Section — grupare în List/Form cu antet și subsol. ViewModifier — modificatori personalizați pentru reutilizarea stilurilor. .modifier(CustomModifier()) — aplicare.

List și Form în detaliu

List în SwiftUI este echivalentul UITableView. Suportă .onDelete, .onMove, .refreshable. SwipeActions — .swipeActions { Button("Șterge", role: .destructive) { } }. Form — optimizat pentru setări: DatePicker, Toggle, Stepper, Picker. Section cu header/footer — pentru grupare. OutlineGroup — liste ierarhice (echivalent UITableView cu secțiuni). DisclosureGroup — secțiune pliabilă cu conținut. IT Sectr recomandă List pentru date și Form pentru setări.

PreviewProvider — protocol pentru previzualizări în Xcode Canvas. Canvas — previzualizare interactivă SwiftUI (necesită @main și Swift 5.9+). @ScaledMetric — dimensiune adaptivă care scalează cu Dynamic Type.

Gestionarea stării (@StateObject, @ObservedObject, @EnvironmentObject, @FocusState)

Property Wrappers sunt baza gestionării stării în SwiftUI. @State — stare locală (tip valoare). @Binding — conexiune la starea părintelui. @StateObject — creează un ObservableObject. SwiftUI gestionează ciclul de viață al obiectului. @ObservedObject — observă un ObservableObject extern. @EnvironmentObject — obiect din mediu (injecție de dependențe prin .environmentObject()). @Environment — valori sistem (.colorScheme, .locale). @AppStorage — UserDefaults. @FetchRequest — interogare Core Data. @FocusState — focus de intrare.

@StateObject vs @ObservedObject: @StateObject creează un obiect, @ObservedObject îl observă. Utilizați @StateObject pentru crearea inițială a modelului în ierarhie, @ObservedObject pentru transmiterea către vederi copil. @FocusState — gestionarea focusului: .focused($field, equals: .email). Suportă enum pentru mai multe câmpuri.

Valori de mediu și DI

@Environment — valori sistem: colorScheme, locale, sizeCategory, layoutDirection, managedObjectContext. Valori de mediu personalizate — valoare personalizată prin EnvironmentKey. Folosit pentru injecția de dependențe: transmiterea serviciilor fără parametri explicite. Modificatorul .environment() — setează o valoare în ierarhie. @EnvironmentObject — ObservableObject din .environmentObject(). Diferă de @Environment prin faptul că transmite un tip referință. IT Sectr recomandă @Environment pentru valori sistem și @EnvironmentObject pentru servicii.

Ciclu de viață (.task, .onAppear, .onDisappear)

.task{} — operație asincronă la apariția vederii. Anulare automată la dispariție. Înlocuiește .onAppear pentru async/await. .onAppear{} — operație sincronă la apariție. .onDisappear{} — operație la dispariție. .onChange(of:) — reacție la schimbări de valoare. .onReceive(Publisher) — reacție la publisher-ul Combine. Ciclul de viață al View în SwiftUI: init → onAppear → body (randare) → onDisappear. La schimbarea stării: body → diff → re-randare. IT Sectr recomandă .task pentru încărcare asincronă și .onAppear pentru analytics.

Animație în SwiftUI

.animation() — modificator de animație. .transition() — animație apariție/dispariție. withAnimation — animație explicită a schimbărilor de stare. matchedGeometryEffect — animație între diferite vederi (hero animation). PhaseAnimator (iOS 17+) — animație multifazică bazată pe enum. KeyframeAnimator (iOS 17+) — animație cadru cu cadru cu keyframes. Animațiile SwiftUI rulează pe GPU prin Core Animation. IT Sectr recomandă .spring() pentru animații naturale și .interpolatingSpring pentru efecte fizice.

Flux de date (Bindings, @Published, ObservableObject)

ObservableObject — protocol pentru obiecte cu proprietăți @Published. SwiftUI se abonează la publisher-ul objectWillChange. @Published — publică schimbări de proprietate. @StateObject — creează ObservableObject, gestionează ciclul de viață. @ObservedObject — observă extern. Combine — framework pentru programare reactivă. @EnvironmentObject — DI prin mediu. .environmentObject() setează, @EnvironmentObject citește. MVVM — arhitectură standard: View (SwiftUI) — ViewModel (ObservableObject) — Model. IT Sectr recomandă MVVM + @StateObject pentru ViewModele principale.

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("Eroare: \(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() }
        }
    }
}

Accesibilitate și localizare

Accesibilitate în SwiftUI: .accessibilityLabel(), .accessibilityHint(), .accessibilityValue(), .accessibilityAddTraits(). VoiceOver citește etichetele de accesibilitate. Dynamic Type — @ScaledMetric, @DynamicProperty. Localizare: String(localized:) (SwiftUI + String Catalog). LocalizedStringKey — traducere automată. Reguli plural — prin String Catalog (one, few, many, other). Dreapta-la-stânga (arabă, ebraică) — suportat automat. .environment(.layoutDirection, .rightToLeft). IT Sectr recomandă etichete de accesibilitate pentru toate elementele interactive.

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

// Suport Dynamic Type
struct ScalableText: View {
    @ScaledMetric private var fontSize: CGFloat = 17

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

Grafice și vizualizare (Swift Charts)

Swift Charts (iOS 16+) — framework pentru construirea graficelor. Chart { } — container de bază. BarMark, LineMark, PointMark, AreaMark, RuleMark — marcaje. ForEach pentru date. ChartAxis — personalizarea axelor. .chartXAxis, .chartYAxis. ChartLegend — legendă. Interpolare — catmullRom, linear, step. Animație — .animation() pentru Chart. IT Sectr recomandă Swift Charts pentru grafice încorporate și Charts (DGCharts) pentru cele complexe.

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) — managerul de dependențe Apple. Integrat în Xcode. Suportă: pachete binare, resurse, teste, swift-6 concurență strictă. Publicarea pachetelor prin GitHub cu tag semver. SPM este standardul de facto pentru dependențele Swift, înlocuind CocoaPods și Carthage. IT Sectr recomandă SPM pentru toate proiectele noi.

Swift Concurrency (async/await, TaskGroup, AsyncSequence) — async/await încorporat în Swift 5.5+. Task — unitate de asincronie. TaskGroup — sarcini paralele. AsyncSequence — secvență asincronă (AsyncStream, AsyncAlgorithms). Task Local Values — date contextuale pentru Task. Swift Concurrency înlocuiește complet Combine pentru operații asincrone.