Combine Framework : Programmation réactive en Swift

import Combine

// Just : émet une seule valeur puis termine
// Utile pour convertir une valeur simple en Publisher
let singleValue = Just("Bonjour Combine")

// CurrentValueSubject : stocke et émet la valeur courante
// Parfait pour représenter un état qui change
let counter = CurrentValueSubject<Int, Never>(0)

// PassthroughSubject : émet des valeurs sans les stocker
// Idéal pour les événements ponctuels (clics, notifications)
let buttonTaps = PassthroughSubject<Void, Never>()

// Future : émet une seule valeur de façon asynchrone
// Encapsule une opération async qui retourne un résultat
let asyncOperation = Future<String, Error> { promise in
    // Simule un appel réseau
    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
        promise(.success("Données chargées"))
    }
}

import Combine

// Variable pour stocker les abonnements
// Sans cette référence, l'abonnement serait immédiatement annulé
var cancellables = Set<AnyCancellable>()

let publisher = ["Swift", "Combine", "iOS"].publisher

// sink() crée un Subscriber qui reçoit les valeurs
publisher
    .sink(
        // Appelée quand le Publisher termine ou échoue
        receiveCompletion: { completion in
            switch completion {
            case .finished:
                print("✅ Terminé avec succès")
            case .failure(let error):
                print("❌ Erreur: \(error)")
            }
        },
        // Appelée pour chaque valeur émise
        receiveValue: { value in
            print("Reçu: \(value)")
        }
    )
    // store() garde une référence à l'abonnement
    .store(in: &cancellables)

// Output:
// Reçu: Swift
// Reçu: Combine
// Reçu: iOS
// ✅ Terminé avec succès

import Combine

var cancellables = Set<AnyCancellable>()

// map : transforme chaque valeur
// Équivalent du map sur les tableaux
[1, 2, 3, 4, 5].publisher
    .map { $0 * 2 }  // Multiplie chaque nombre par 2
    .sink { print("Double: \($0)") }
    .store(in: &cancellables)
// Output: 2, 4, 6, 8, 10

// compactMap : transforme ET filtre les nil
// Utile pour les conversions optionnelles
["1", "deux", "3", "quatre", "5"].publisher
    .compactMap { Int($0) }  // Convertit en Int, ignore les échecs
    .sink { print("Nombre valide: \($0)") }
    .store(in: &cancellables)
// Output: 1, 3, 5

// flatMap : aplatit les Publishers imbriqués
// Essentiel pour les opérations async en chaîne
struct User { let id: Int; let name: String }

func fetchUser(id: Int) -> AnyPublisher<User, Never> {
    // Simule un appel API
    Just(User(id: id, name: "User \(id)"))
        .delay(for: .milliseconds(100), scheduler: RunLoop.main)
        .eraseToAnyPublisher()
}

[1, 2, 3].publisher
    .flatMap { id in fetchUser(id: id) }  // Chaque ID devient un appel API
    .sink { user in print("User: \(user.name)") }
    .store(in: &cancellables)

import Combine

var cancellables = Set<AnyCancellable>()

let numbers = [1, 2, 2, 3, 3, 3, 4, 5, 5].publisher

// filter : garde uniquement les valeurs qui satisfont la condition
numbers
    .filter { $0 > 2 }  // Garde seulement les nombres > 2
    .sink { print("Filtré: \($0)") }
    .store(in: &cancellables)
// Output: 3, 3, 3, 4, 5, 5

// removeDuplicates : supprime les valeurs consécutives identiques
numbers
    .removeDuplicates()  // Élimine les doublons consécutifs
    .sink { print("Sans doublon: \($0)") }
    .store(in: &cancellables)
// Output: 1, 2, 3, 4, 5

// debounce : attend une pause avant d'émettre
// Parfait pour la recherche en temps réel
let searchText = PassthroughSubject<String, Never>()

searchText
    .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
    .removeDuplicates()  // Ignore si le texte n'a pas changé
    .sink { query in
        print("Recherche: \(query)")
        // Lancer l'appel API ici
    }
    .store(in: &cancellables)

// Simule une frappe rapide
searchText.send("S")
searchText.send("Sw")
searchText.send("Swi")
searchText.send("Swift")  // Seul "Swift" est émis après 300ms

import Combine

var cancellables = Set<AnyCancellable>()

// Simulons un formulaire avec validation
let email = CurrentValueSubject<String, Never>("")
let password = CurrentValueSubject<String, Never>("")

// combineLatest : combine les dernières valeurs de chaque Publisher
// Émet à chaque changement de l'un ou l'autre
Publishers.CombineLatest(email, password)
    .map { email, password in
        // Valide que l'email contient @ et le mot de passe > 6 chars
        let isEmailValid = email.contains("@")
        let isPasswordValid = password.count >= 6
        return isEmailValid && isPasswordValid
    }
    .sink { isFormValid in
        print("Formulaire valide: \(isFormValid)")
    }
    .store(in: &cancellables)

email.send("user@example.com")  // false (password vide)
password.send("123456")          // true (les deux sont valides)

// zip : attend une valeur de chaque Publisher avant d'émettre
// Utile pour synchroniser des opérations parallèles
let firstAPI = PassthroughSubject<String, Never>()
let secondAPI = PassthroughSubject<Int, Never>()

Publishers.Zip(firstAPI, secondAPI)
    .sink { stringValue, intValue in
        print("Reçu paire: \(stringValue), \(intValue)")
    }
    .store(in: &cancellables)

firstAPI.send("Hello")   // Pas d'émission, attend secondAPI
secondAPI.send(42)       // Émet: ("Hello", 42)
firstAPI.send("World")   // Pas d'émission, attend secondAPI
secondAPI.send(100)      // Émet: ("World", 100)

import Combine

var cancellables = Set<AnyCancellable>()

// Plusieurs sources de notifications utilisateur
let pushNotifications = PassthroughSubject<String, Never>()
let localNotifications = PassthroughSubject<String, Never>()
let inAppMessages = PassthroughSubject<String, Never>()

// Merge unifie tous les flux en un seul
Publishers.Merge3(pushNotifications, localNotifications, inAppMessages)
    .sink { message in
        // Traite toutes les notifications de la même façon
        print("📬 Notification: \(message)")
    }
    .store(in: &cancellables)

pushNotifications.send("Nouveau message")     // 📬 Notification: Nouveau message
localNotifications.send("Rappel: réunion")    // 📬 Notification: Rappel: réunion
inAppMessages.send("Bienvenue !")             // 📬 Notification: Bienvenue !

import Combine

var cancellables = Set<AnyCancellable>()

enum APIError: Error {
    case networkError
    case invalidResponse
    case serverError(Int)
}

// Simule un appel API qui peut échouer
func fetchData() -> AnyPublisher<String, APIError> {
    Fail(error: APIError.networkError)
        .eraseToAnyPublisher()
}

// retry : réessaie N fois avant de propager l'erreur
fetchData()
    .retry(3)  // Essaie jusqu'à 3 fois
    .catch { error -> Just<String> in
        // catch : remplace l'erreur par un Publisher de secours
        print("Erreur après 3 tentatives: \(error)")
        return Just("Données en cache")  // Valeur de fallback
    }
    .sink(
        receiveCompletion: { _ in },
        receiveValue: { print("Résultat: \($0)") }
    )
    .store(in: &cancellables)

// replaceError : remplace toute erreur par une valeur fixe
// Plus simple que catch quand on veut juste une valeur par défaut
fetchData()
    .replaceError(with: "Erreur - valeur par défaut")
    .sink { print("Avec fallback: \($0)") }
    .store(in: &cancellables)

import Combine
import Foundation

// Modèle de données
struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

// ViewModel avec état réactif
final class UserListViewModel: ObservableObject {
    // MARK: - Published Properties (observés par SwiftUI)

    @Published var users: [User] = []           // Liste des utilisateurs
    @Published var searchQuery: String = ""     // Texte de recherche
    @Published var isLoading: Bool = false      // État de chargement
    @Published var errorMessage: String?        // Message d'erreur éventuel

    // MARK: - Private Properties

    private var cancellables = Set<AnyCancellable>()
    private let userService: UserServiceProtocol

    // MARK: - Computed Properties

    // Filtre les utilisateurs selon la recherche
    var filteredUsers: [User] {
        guard !searchQuery.isEmpty else { return users }
        return users.filter {
            $0.name.localizedCaseInsensitiveContains(searchQuery)
        }
    }

    // MARK: - Initialization

    init(userService: UserServiceProtocol = UserService()) {
        self.userService = userService
        setupBindings()
    }

    // MARK: - Private Methods

    private func setupBindings() {
        // Observe les changements de searchQuery
        // debounce évite les appels trop fréquents
        $searchQuery
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .sink { [weak self] query in
                // Logique de recherche côté serveur si nécessaire
                print("Recherche mise à jour: \(query)")
            }
            .store(in: &cancellables)
    }

    // MARK: - Public Methods

    func loadUsers() {
        isLoading = true
        errorMessage = nil

        userService.fetchUsers()
            .receive(on: DispatchQueue.main)  // Assure l'update UI sur main thread
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = error.localizedDescription
                    }
                },
                receiveValue: { [weak self] users in
                    self?.users = users
                }
            )
            .store(in: &cancellables)
    }
}

import Combine
import Foundation

protocol UserServiceProtocol {
    func fetchUsers() -> AnyPublisher<[User], Error>
}

final class UserService: UserServiceProtocol {
    private let baseURL = URL(string: "https://api.example.com")!
    private let session: URLSession
    private let decoder: JSONDecoder

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

    func fetchUsers() -> AnyPublisher<[User], Error> {
        let url = baseURL.appendingPathComponent("users")

        return session.dataTaskPublisher(for: url)
            // Vérifie le code de statut HTTP
            .tryMap { data, response in
                guard let httpResponse = response as? HTTPURLResponse else {
                    throw URLError(.badServerResponse)
                }
                guard 200..<300 ~= httpResponse.statusCode else {
                    throw URLError(.badServerResponse)
                }
                return data
            }
            // Décode le JSON en modèle Swift
            .decode(type: [User].self, decoder: decoder)
            // Efface le type concret pour retourner AnyPublisher
            .eraseToAnyPublisher()
    }
}

import SwiftUI

struct UserListView: View {
    // StateObject : crée et possède le ViewModel
    @StateObject private var viewModel = UserListViewModel()

    var body: some View {
        NavigationStack {
            Group {
                if viewModel.isLoading {
                    // Indicateur de chargement centré
                    ProgressView("Chargement...")
                } else if let error = viewModel.errorMessage {
                    // Vue d'erreur avec bouton retry
                    VStack(spacing: 16) {
                        Text("Erreur: \(error)")
                            .foregroundStyle(.red)
                        Button("Réessayer") {
                            viewModel.loadUsers()
                        }
                    }
                } else {
                    // Liste des utilisateurs
                    List(viewModel.filteredUsers) { user in
                        UserRowView(user: user)
                    }
                }
            }
            .navigationTitle("Utilisateurs")
            .searchable(text: $viewModel.searchQuery)  // Binding direct
            .onAppear {
                viewModel.loadUsers()  // Charge au premier affichage
            }
        }
    }
}

struct UserRowView: View {
    let user: User

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(user.name)
                .font(.headline)
            Text(user.email)
                .font(.subheadline)
                .foregroundStyle(.secondary)
        }
        .padding(.vertical, 4)
    }
}

import Combine

final class DataManager {
    // Set de cancellables : automatiquement annulés à la destruction
    private var cancellables = Set<AnyCancellable>()

    // Cancellable individuel pour contrôle fin
    private var currentRequest: AnyCancellable?

    func startPolling() {
        // Timer qui émet toutes les 5 secondes
        Timer.publish(every: 5, on: .main, in: .common)
            .autoconnect()  // Démarre automatiquement
            .sink { [weak self] _ in
                self?.fetchLatestData()
            }
            .store(in: &cancellables)
    }

    func fetchLatestData() {
        // Annule la requête précédente si elle existe
        currentRequest?.cancel()

        currentRequest = URLSession.shared
            .dataTaskPublisher(for: URL(string: "https://api.example.com/data")!)
            .map(\.data)
            .decode(type: [String].self, decoder: JSONDecoder())
            .replaceError(with: [])
            .receive(on: DispatchQueue.main)
            .sink { data in
                print("Données reçues: \(data)")
            }
    }

    deinit {
        // Tous les cancellables sont automatiquement annulés
        print("DataManager détruit, abonnements annulés")
    }
}

import Combine
import Foundation

var cancellables = Set<AnyCancellable>()

func loadAndProcessData() -> AnyPublisher<ProcessedData, Error> {
    URLSession.shared.dataTaskPublisher(for: apiURL)
        // Effectue le parsing sur un thread background
        .subscribe(on: DispatchQueue.global(qos: .userInitiated))
        .map(\.data)
        .decode(type: RawData.self, decoder: JSONDecoder())
        // Traitement lourd sur background thread
        .map { rawData in
            // Cette opération coûteuse s'exécute en arrière-plan
            processData(rawData)
        }
        // Retourne sur le main thread pour l'UI
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher()
}