Flutter⇄SwiftUI

struct ContentView: View {
    // Always mark it 'private' — it's screen-owned
    @State private var count = 0
    @State private var isPremiumUser = false

    var body: some View {
        VStack(spacing: 20) {
            Text("Score: \(count)")
                .font(.largeTitle)

            Text(isPremiumUser ? "Premium Account" : "Standard Account")
                .foregroundColor(isPremiumUser ? .green : .gray)

            Button("Score point") {
                count += 1              // mutate directly, no setState()
            }
            .buttonStyle(.borderedProminent)

            Button("Toggle Membership") {
                isPremiumUser.toggle()
            }
            .buttonStyle(.bordered)
        }
        .padding()
    }
}

// PARENT — owns the source of truth
struct ParentView: View {
    @State private var isLightOn = false

    var body: some View {
        VStack {
            Circle()
                .fill(isLightOn ? .yellow : .gray)
                .frame(width: 50, height: 50)

            // '$' passes a live reference down, not a copy
            LightSwitchComponent(isOn: $isLightOn)
        }
    }
}

// CHILD — doesn't own the data, just edits it for the parent
struct LightSwitchComponent: View {
    @Binding var isOn: Bool

    var body: some View {
        Button(isOn ? "Turn Off" : "Turn On") {
            isOn.toggle()   // this updates the PARENT's circle color
        }
    }
}

// @MainActor forces every mutation back onto the UI thread,
// even after an 'await' hops onto a background worker thread.
@MainActor
@Observable class TodoViewModel {
    var tasks: [TodoItem] = []

    func loadRemoteTasks() async {
        let fetchedData = await NetworkService.fetchData()  // background thread

        // Swift jumps back to Main automatically before this write —
        // no manual emit() or notifyListeners() needed.
        self.tasks = fetchedData
    }
}

struct ParentDashboardView: View {
    // 1. @State CREATES the object here — this view owns it
    @State private var globalCubit = ProfileViewModel()

    var body: some View {
        VStack {
            Text("Logged in as: \(globalCubit.username)")

            // 2. Pass the created instance down into the
            //    child view's constructor parameter
            SettingsScreen(viewModel: globalCubit)
        }
    }
}

struct SettingsScreen: View {
    // 3. @Bindable ACCEPTS the passed object here so you
    //    can write back to its properties from this screen
    @Bindable var viewModel: ProfileViewModel

    var body: some View {
        // 4. This directly mutates the string back in the
        //    PARENT view's memory — true two-way binding
        TextField("Change username", text: $viewModel.username)
    }
}

@Observable class ProfileViewModel {
    var username: String = "John"
    var notificationsEnabled: Bool = true
}

struct SettingsScreen: View {
    // Allows this screen to create direct '$' binding
    // properties to the model's fields
    @Bindable var viewModel: ProfileViewModel

    var body: some View {
        Form {
            // Without @Bindable above, writing $viewModel
            // here would fail to compile
            TextField("Edit Name", text: $viewModel.username)
            Toggle("Alerts", isOn: $viewModel.notificationsEnabled)
        }
    }
}

NavigationStack {
    List(products) { product in
        NavigationLink(destination: ProductDetailView(product: product)) {
            Text(product.name)
        }
    }
    .navigationTitle("Catalog")
}

NavigationStack {
    List(products) { product in
        // pass the VALUE, not a built view
        NavigationLink(product.name, value: product)
    }
    // resolves ANY Product value pushed anywhere in this stack
    .navigationDestination(for: Product.self) { product in
        ProductDetailView(product: product)
    }
    .navigationTitle("Catalog")
}

struct RootView: View {
    // owns the whole back-stack, like a GlobalKey<NavigatorState>
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            HomeView(onCheckoutSuccess: {
                path = NavigationPath()   // pop to root, like Navigator.popUntil
            })
            .navigationDestination(for: Product.self) { p in ProductDetailView(product: p) }
            .navigationDestination(for: CartStep.self) { s in CheckoutStepView(step: s) }
        }
    }
}

// pushing from anywhere that holds a Binding<NavigationPath>
Button("Go to checkout") { path.append(CartStep.shipping) }

// popping one screen from within a pushed view
@Environment(\.dismiss) private var dismiss
Button("Back") { dismiss() }

struct HomeView: View {
    @State private var showingFilters = false

    var body: some View {
        Button("Filters") { showingFilters = true }
            .sheet(isPresented: $showingFilters) {
                FilterSheetView()
                    .presentationDetents([.medium, .large])  // like a draggable bottom sheet
            }
    }
}

// Codable = Decodable + Encodable, synthesized automatically
// as long as every property type is itself Codable.
struct User: Codable, Identifiable {
    let id: Int
    let name: String
    let email: String
}

enum NetworkError: Error { case badResponse, decodingFailed }

struct NetworkService {
    static func fetchUser(id: Int) async throws -> User {
        let url = URL(string: "https://api.example.com/users/\(id)")!
        let (data, response) = try await URLSession.shared.data(from: url)

        guard let http = response as? HTTPURLResponse,
              (200...299).contains(http.statusCode) else {
            throw NetworkError.badResponse
        }

        do {
            return try JSONDecoder().decode(User.self, from: data)
        } catch {
            throw NetworkError.decodingFailed
        }
    }
}

@MainActor
@Observable class UserViewModel {
    var user: User?
    var loadingState: FetchState = .idle

    func loadUser(id: Int) async {
        loadingState = .loading
        do {
            user = try await NetworkService.fetchUser(id: id)
            loadingState = .success
        } catch {
            loadingState = .error(message: "Couldn't load user profile.")
        }
    }
}

import SwiftData

@Model
class Note {
    var title: String
    var body: String
    var createdAt: Date

    init(title: String, body: String) {
        self.title = title
        self.body = body
        self.createdAt = .now
    }
}

struct NotesListView: View {
    // Like a Hive box listener, but the view redraws itself —
    // no manual ValueListenableBuilder wiring
    @Query(sort: \Note.createdAt, order: .reverse) private var notes: [Note]
    @Environment(\.modelContext) private var context

    var body: some View {
        List(notes) { note in Text(note.title) }
            .toolbar {
                Button("Add") {
                    context.insert(Note(title: "Untitled", body: ""))
                }
            }
    }
}

struct BadgeView: View {
    @State private var isActive = false

    var body: some View {
        Circle()
            .fill(isActive ? .green : .gray)
            .frame(width: isActive ? 60 : 40, height: isActive ? 60 : 40)
            // ANY change to a value this modifier watches gets animated
            .animation(.easeInOut(duration: 0.3), value: isActive)
            .onTapGesture { isActive.toggle() }
    }
}

Button("Add to cart") {
    // only the mutation inside this closure animates —
    // nothing else on screen is affected
    withAnimation(.spring(response: 0.4, dampingFraction: 0.7)) {
        cart.items.append(product)
    }
}

struct DraggableCard: View {
    @State private var offset = CGSize.zero

    var body: some View {
        RoundedRectangle(cornerRadius: 16)
            .fill(.blue.opacity(0.2))
            .frame(width: 160, height: 100)
            .offset(offset)
            .gesture(
                DragGesture()
                    .onChanged { value in offset = value.translation }
                    .onEnded { _ in withAnimation(.spring) { offset = .zero } }
            )
            .onTapGesture { print("tapped") }
            .onLongPressGesture { print("long pressed") }
    }
}

struct LoginView: View {
    @State private var email = ""
    @State private var password = ""
    @State private var errorMessage: String?

    // like tracking which FocusNode currently has focus
    enum Field { case email, password }
    @FocusState private var focusedField: Field?

    var body: some View {
        Form {
            Section {
                TextField("Email", text: $email)
                    .keyboardType(.emailAddress)
                    .textInputAutocapitalization(.never)
                    .focused($focusedField, equals: .email)
                    .onSubmit { focusedField = .password }   // return key -> next field

                SecureField("Password", text: $password)
                    .focused($focusedField, equals: .password)
                    .onSubmit { submit() }
            }

            if let errorMessage {
                Text(errorMessage).foregroundStyle(.red).font(.caption)
            }

            Button("Sign In", action: submit)
        }
        .onAppear { focusedField = .email }   // auto-focus first field, like autofocus: true
    }

    private func submit() {
        guard email.contains("@") else {
            errorMessage = "Enter a valid email address"
            return
        }
        guard password.count >= 8 else {
            errorMessage = "Password must be at least 8 characters"
            return
        }
        errorMessage = nil
        // proceed with sign-in
    }
}

struct CardView: View {
    @Environment(\.colorScheme) private var scheme

    var body: some View {
        Text("Weekly summary")
            .padding()
            // "BrandSurface" is defined once in Assets.xcassets
            // with separate Any Appearance / Dark values —
            // this line never needs an if/else for dark mode
            .background(Color("BrandSurface"))
            .foregroundStyle(scheme == .dark ? .white : .black)
            .cornerRadius(14)
    }
}

struct CardStyle: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding(16)
            .background(Color("BrandSurface"))
            .clipShape(RoundedRectangle(cornerRadius: 14))
            .shadow(radius: 4, y: 2)
    }
}

extension View {
    func cardStyle() -> some View { modifier(CardStyle()) }
}

// usage anywhere:
Text("Total balance").cardStyle()

struct OrderRow: View {
    let order: Order

    var body: some View {
        HStack {
            Text(order.title)
            Spacer()
            Text(order.status).foregroundStyle(.secondary)
        }
        // without this, VoiceOver reads the title and status
        // as two separate stops — merge them into one
        .accessibilityElement(children: .combine)
        .accessibilityLabel("\(order.title), \(order.status)")
        .accessibilityHint("Double tap to view order details")
    }
}

import AVFoundation

enum CameraPermission {
    static func request() async -> Bool {
        switch AVCaptureDevice.authorizationStatus(for: .video) {
        case .authorized:
            return true
        case .notDetermined:
            return await AVCaptureDevice.requestAccess(for: .video)
        case .denied, .restricted:
            return false
        @unknown default:
            return false
        }
    }
}

import UIKit
import UserNotifications

@MainActor
final class PushNotificationManager: NSObject, UNUserNotificationCenterDelegate {
    static let shared = PushNotificationManager()

    func requestAuthorization() async -> Bool {
        let center = UNUserNotificationCenter.current()
        center.delegate = self

        do {
            let granted = try await center.requestAuthorization(options: [.alert, .sound, .badge])
            if granted {
                // must happen on the main thread — like firebase_messaging does internally
                UIApplication.shared.registerForRemoteNotifications()
            }
            return granted
        } catch {
            return false
        }
    }

    // called by AppDelegate once APNs hands back a token
    func didReceiveDeviceToken(_ deviceToken: Data) {
        let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
        // send `token` to your backend, same as FirebaseMessaging.instance.getToken()
        print("APNs device token: \(token)")
    }

    // notification arrives while the app is in the FOREGROUND
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification
    ) async -> UNNotificationPresentationOptions {
        [.banner, .sound, .badge]   // explicit — Flutter's plugin does this for you
    }

    // user TAPPED the notification (foreground, background, or terminated launch)
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse
    ) async {
        let userInfo = response.notification.request.content.userInfo
        // route to the relevant screen, e.g. push.append(...) on your NavigationPath
        print("Notification tapped with payload: \(userInfo)")
    }
}

import SwiftUI

final class AppDelegate: NSObject, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        PushNotificationManager.shared.didReceiveDeviceToken(deviceToken)
    }
}

@main
struct YourAppNameApp: App {
    // SwiftUI's App protocol has no native push-token delegate,
    // so it bridges to UIKit's AppDelegate for this one thing
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            ProfileView()
                .task { _ = await PushNotificationManager.shared.requestAuthorization() }
        }
    }
}

struct RootView: View {
    @Environment(\.scenePhase) private var scenePhase
    @State private var viewModel = SyncViewModel()

    var body: some View {
        ProfileView()
            .onChange(of: scenePhase) { oldPhase, newPhase in
                switch newPhase {
                case .active:
                    Task { await viewModel.resumeSync() }
                case .background:
                    viewModel.pauseSync()
                    viewModel.persistDraftState()
                case .inactive:
                    break   // brief transition state — e.g. control center pulled down
                @unknown default:
                    break
                }
            }
    }
}

protocol UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User
}

struct LiveUserService: UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User {
        try await NetworkService.fetchUser(id: id)
    }
}

struct MockUserService: UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User {
        User(id: id, name: "Test User", email: "test@example.com")
    }
}

@MainActor
@Observable class UserViewModel {
    private let userService: UserServiceProtocol
    var user: User?

    // constructor injection — same idea as passing a repository
    // into a Cubit's constructor in Flutter
    init(userService: UserServiceProtocol = LiveUserService()) {
        self.userService = userService
    }

    func load(id: Int) async {
        user = try? await userService.fetchUser(id: id)
    }
}

// production
let vm = UserViewModel()

// test — swap the dependency, no container needed
let testVM = UserViewModel(userService: MockUserService())

lane :beta do
  match(type: "appstore")                 # pulls signing certs from your shared repo
  build_app(scheme: "YourAppName")        # archives with the project's current Xcode
  upload_to_testflight(skip_waiting_for_build_processing: true)
end

lane :release do
  match(type: "appstore")
  build_app(scheme: "YourAppName")
  upload_to_app_store(
    submit_for_review: true,
    automatic_release: false              # you flip the switch manually after review
  )
end

struct TodoItem: Identifiable {
    let id = UUID()          // auto-managed row-tracking id
    let title: String
    var isCompleted: Bool
}

/// Maps directly to a Bloc/Cubit state enum.
enum FetchState {
    case idle
    case loading
    case success
    case error(message: String)   // associated value, like a Dart sealed class field
}

@MainActor
@Observable class TodoViewModel {
    var tasks: [TodoItem] = []
    var loadingState: FetchState = .idle
    var taskInputBuffer: String = ""

    func loadRemoteTasks() async {
        loadingState = .loading

        do {
            try await Task.sleep(nanoseconds: 1_200_000_000) // simulated network delay

            tasks = [
                TodoItem(title: "Learn SwiftUI Basics", isCompleted: true),
                TodoItem(title: "Master State & ViewModels", isCompleted: true),
                TodoItem(title: "Build Scrollable Lists & Feeds", isCompleted: false),
                TodoItem(title: "Implement Navigation Architecture", isCompleted: false)
            ]
            loadingState = .success
        } catch {
            loadingState = .error(message: "Failed to download cloud records.")
        }
    }

    func addNewTask() {
        guard !taskInputBuffer.trimmingCharacters(in: .whitespaces).isEmpty else { return }
        tasks.append(TodoItem(title: taskInputBuffer, isCompleted: false))
        taskInputBuffer = ""
    }

    func deleteItems(at offsets: IndexSet) {
        tasks.remove(atOffsets: offsets)
    }

    deinit {
        print("ViewModel cleared from memory — zero manual close() calls.")
    }
}

struct ProfileView: View {
    @State private var viewModel = TodoViewModel()

    var body: some View {
        NavigationStack {
            VStack {
                // --- input row ---
                VStack(spacing: 8) {
                    @Bindable var bindableModel = viewModel
                    HStack {
                        TextField("Create a new task...", text: $bindableModel.taskInputBuffer)
                            .textFieldStyle(.roundedBorder)
                        Button(action: { viewModel.addNewTask() }) {
                            Image(systemName: "plus.circle.fill").font(.title2)
                        }
                    }
                }
                .padding()

                // --- state machine (BlocBuilder equivalent) ---
                Group {
                    switch viewModel.loadingState {
                    case .idle:
                        ContentUnavailableView("No Sync Active",
                            systemImage: "tray.and.arrow.down",
                            description: Text("Trigger sync below."))

                    case .loading:
                        ProgressView("Loading...").padding()

                    case .error(let message):
                        ContentUnavailableView("Connection Failed",
                            systemImage: "wifi.exclamationmark",
                            description: Text(message))
                            .foregroundColor(.red)

                    case .success:
                        List {
                            ForEach(viewModel.tasks.indices, id: \.self) { index in
                                HStack {
                                    Button {
                                        withAnimation(.spring(response: 0.35, dampingFraction: 0.6)) {
                                            viewModel.tasks[index].isCompleted.toggle()
                                        }
                                    } label: {
                                        Image(systemName: viewModel.tasks[index].isCompleted
                                              ? "checkmark.circle.fill" : "circle")
                                            .foregroundColor(viewModel.tasks[index].isCompleted ? .green : .gray)
                                    }
                                    .buttonStyle(.plain)

                                    NavigationLink(destination: TodoItemDetailView(todoItem: viewModel.tasks[index])) {
                                        Text(viewModel.tasks[index].title)
                                            .strikethrough(viewModel.tasks[index].isCompleted)
                                    }
                                }
                            }
                            .onDelete { viewModel.deleteItems(at: $0) }
                        }
                    }
                }
                .animation(.easeInOut(duration: 0.25), value: viewModel.tasks.count)

                Button(action: { Task { await viewModel.loadRemoteTasks() } }) {
                    Label("Sync Core Database", systemImage: "arrow.clockwise")
                        .frame(maxWidth: .infinity)
                }
                .buttonStyle(.borderedProminent)
                .padding()
            }
            .navigationTitle("Dashboard")
        }
    }
}

struct TodoItemDetailView: View {
    let todoItem: TodoItem
    var body: some View {
        VStack(spacing: 20) {
            Image(systemName: todoItem.isCompleted ? "doc.plaintext.fill" : "doc.plaintext")
                .font(.system(size: 60))
                .foregroundColor(todoItem.isCompleted ? .green : .orange)
            Text(todoItem.title).font(.title).bold()
            Spacer()
        }
        .padding(.top, 50)
        .navigationTitle("Verification Tracker")
        .navigationBarTitleDisplayMode(.inline)
    }
}

#Preview {
    ProfileView()
}