ios-architecture

iOS Architecture - SwiftUI & MVVM

Purpose: Design scalable iOS applications with clean architecture patterns

Agent: Apple iOS Lead Use When: Building iOS apps with SwiftUI, architecting app structure, or managing state

---

MVVM Pattern

Model

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

struct Post: Identifiable, Codable {
    let id: Int
    let title: String
    let body: String
    let userId: Int
}

ViewModel

@MainActor
class UserViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    private let repository: UserRepository

    init(repository: UserRepository = UserRepository()) {
        self.repository = repository
    }

    func loadUsers() async {
        isLoading = true
        errorMessage = nil

        do {
            users = try await repository.fetchUsers()
        } catch {
            errorMessage = error.localizedDescription
        }

        isLoading = false
    }
}

View

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

    var body: some View {
        NavigationView {
            Group {
                if viewModel.isLoading {
                    ProgressView()
                } else if let error = viewModel.errorMessage {
                    Text("Error: \(error)")
                        .foregroundColor(.red)
                } else {
                    List(viewModel.users) { user in
                        NavigationLink(destination: UserDetailView(user: user)) {
                            UserRow(user: user)
                        }
                    }
                }
            }
            .navigationTitle("Users")
            .task {
                await viewModel.loadUsers()
            }
        }
    }
}

struct UserRow: View {
    let user: User

    var body: some View {
        VStack(alignment: .leading) {
            Text(user.name)
                .font(.headline)
            Text(user.email)
                .font(.subheadline)
                .foregroundColor(.secondary)
        }
    }
}

---

Networking Layer

protocol APIService {
    func fetchUsers() async throws -> [User]
    func fetchUser(id: Int) async throws -> User
    func createUser(_ user: User) async throws -> User
}

class NetworkService: APIService {
    private let baseURL = "https://api.example.com"

    func fetchUsers() async throws -> [User] {
        let url = URL(string: "\(baseURL)/users")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode([User].self, from: data)
    }

    func fetchUser(id: Int) async throws -> User {
        let url = URL(string: "\(baseURL)/users/\(id)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(User.self, from: data)
    }

    func createUser(_ user: User) async throws -> User {
        let url = URL(string: "\(baseURL)/users")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(user)

        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode(User.self, from: data)
    }
}

---

Repository Pattern

class UserRepository {
    private let networkService: APIService
    private let cacheService: CacheService

    init(
        networkService: APIService = NetworkService(),
        cacheService: CacheService = CacheService()
    ) {
        self.networkService = networkService
        self.cacheService = cacheService
    }

    func fetchUsers() async throws -> [User] {
        // Try cache first
        if let cached = cacheService.getUsers() {
            return cached
        }

        // Fetch from network
        let users = try await networkService.fetchUsers()

        // Update cache
        cacheService.saveUsers(users)

        return users
    }
}

---

Dependency Injection

// Protocol-based dependency injection
protocol UserRepositoryProtocol {
    func fetchUsers() async throws -> [User]
}

class UserViewModel: ObservableObject {
    private let repository: UserRepositoryProtocol

    init(repository: UserRepositoryProtocol) {
        self.repository = repository
    }
}

// In preview/tests, inject mock
class MockUserRepository: UserRepositoryProtocol {
    func fetchUsers() async throws -> [User] {
        return [
            User(id: 1, name: "Test User", email: "test@example.com")
        ]
    }
}

struct UserListView_Previews: PreviewProvider {
    static var previews: some View {
        UserListView(viewModel: UserViewModel(repository: MockUserRepository()))
    }
}

---

State Management

// @State for local view state
struct Counter: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")
            Button("Increment") { count += 1 }
        }
    }
}

// @StateObject for view model
struct UserListView: View {
    @StateObject private var viewModel = UserViewModel()
}

// @ObservedObject for passed-in view model
struct DetailView: View {
    @ObservedObject var viewModel: UserViewModel
}

// @EnvironmentObject for app-wide state
class AppState: ObservableObject {
    @Published var isLoggedIn = false
    @Published var currentUser: User?
}

@main
struct MyApp: App {
    @StateObject private var appState = AppState()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(appState)
        }
    }
}

struct ProfileView: View {
    @EnvironmentObject var appState: AppState

    var body: some View {
        if let user = appState.currentUser {
            Text("Welcome, \(user.name)")
        }
    }
}

---

Best Practices

• Use MVVM for separation of concerns
• ViewModels should not import SwiftUI
• Repository pattern for data layer
• Protocol-based dependency injection
• Async/await for networking
• @Published for observable properties
• Environment objects for global state
• Preview providers for UI development

---

Remember: SwiftUI is declarative. Think in terms of state and views that react to changes.

Created: 2026-02-04 Maintained By: Apple iOS Lead