21.11.2024

Aula 97: Integração do Core Data no SwiftUI

Nesta aula, vamos explorar como integrar o Core Data com o SwiftUI. O Core Data é um poderoso framework que pode ser usado para persistência de dados em suas aplicações iOS. Vamos começar configurando um modelo de Core Data e, em seguida, utilizá-lo dentro de uma aplicação SwiftUI.

Configurando o Core Data

Primeiro, crie um novo projeto SwiftUI no Xcode. Certifique-se de habilitar "Usar Core Data" nas opções do projeto. Isso configurará automaticamente uma pilha básica de Core Data para você.

1. Criando o Modelo do Core Data

No seu navegador de projetos, clique em SeuNomeDeProjeto.xcdatamodeld. Isso abrirá o editor de Modelo do Core Data. Você pode definir suas entidades e atributos aqui. Para este exemplo, vamos criar uma entidade simples chamada Item com os seguintes atributos:

• nome: String
• dataCriacao: Date

2. Gerando Subclasse NSManagedObject

Após criar suas entidades, clique no menu Editor no topo e selecione Criar Subclasse NSManagedObject.... Escolha a entidade Item para gerar a classe Swift correspondente, que nos permitirá manipular objetos Item com facilidade.

3. Configurando o Controlador de Persistência

Em seguida, vamos criar um PersistenceController para gerenciar nossa pilha de Core Data. Você pode criar um novo arquivo Swift chamado Persistence.swift e adicionar o seguinte código:

import CoreData

struct PersistenceController {
    static let shared = PersistenceController()

    let container: NSPersistentContainer

    init(inMemory: Bool = false) {
        container = NSPersistentContainer(name: "SeuNomeDeProjeto")
        if inMemory {
            container.persistentStoreDescriptions.first!.url = URL(fileURLWithPath: "/dev/null")
        }
        container.loadPersistentStores { description, error in
            if let error = error as NSError? {
                fatalError("Erro não resolvido \(error), \(error.userInfo)")
            }
        }
    }
}

4. Usando Core Data no SwiftUI

Agora vamos integrar o Core Data em nossas views SwiftUI. Vamos criar uma interface de usuário simples que permite ao usuário adicionar itens ao armazenamento do Core Data.

Lista de Itens

Crie uma nova view SwiftUI chamada ItemsListView.swift:

import SwiftUI
import CoreData

struct ItemsListView: View {
    @FetchRequest(
        entity: Item.entity(),
        sortDescriptors: [NSSortDescriptor(keyPath: \Item.dataCriacao, ascending: false)]
    ) var items: FetchedResults<Item>

    @Environment(\.managedObjectContext) private var viewContext

    @State private var novoNomeItem: String = ""

    var body: some View {
        NavigationView {
            VStack {
                List {
                    ForEach(items, id: \.self) { item in
                        Text(item.nome ?? "Item sem nome")
                    }
                    .onDelete(perform: excluirItems)
                }
                .navigationTitle("Itens")
                .navigationBarItems(trailing: Button(action: adicionarItem) {
                    Label("Adicionar Item", systemImage: "plus")
                })

                TextField("Nome do novo item", text: $novoNomeItem)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .padding()
            }
        }
    }

    private func adicionarItem() {
        let novoItem = Item(context: viewContext)
        novoItem.dataCriacao = Date()
        novoItem.nome = novoNomeItem

        do {
            try viewContext.save()
            novoNomeItem = "" // Limpa o campo de texto após adicionar
        } catch {
            // Trata o erro
            let nsError = error as NSError
            fatalError("Erro não resolvido \(nsError), \(nsError.userInfo)")
        }
    }

    private func excluirItems(offsets: IndexSet) {
        withAnimation {
            offsets.map { items[$0] }.forEach(viewContext.delete)
            do {
                try viewContext.save()
            } catch {
                let nsError = error as NSError
                fatalError("Erro não resolvido \(nsError), \(nsError.userInfo)")
            }
        }
    }
}

5. Conectando o Controlador de Persistência

No seu arquivo SeuNomeDeProjetoApp.swift, defina o PersistenceController como um objeto de ambiente:

import SwiftUI

@main
struct SeuNomeDeProjetoApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            ItemsListView()
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

Conclusão

Nesta aula, cobrimos a integração básica do Core Data com o SwiftUI. Configuramos um modelo de Core Data, criamos um controlador de persistência e construímos uma interface de usuário simples para adicionar e listar itens. Com essa base, você pode construir aplicações mais complexas usando SwiftUI e Core Data juntos. Boa programação!

Video

Navigation