Executando operações de rede com o Combine Framework no Swift

Neste tutorial, exploraremos como usar o framework Combine no Swift para realizar operações de rede. As operações de rede são uma parte essencial do desenvolvimento de aplicativos móveis e o Combine fornece uma maneira poderosa de lidar com eventos assíncronos.

Primeiro, precisamos de uma URL que retorne os dados JSON. Para este exemplo, usaremos a API JSON Placeholder, que é uma API REST on-line falsa para teste e prototipagem. O código a seguir cria um objeto de URL para a API:

let url = URL(string: "https://jsonplaceholder.typicode.com/posts")!

func getPosts() -> AnyPublisher<Data, Error> {
    return URLSession.shared.dataTaskPublisher(for: url)
        .map(\.data)
        .eraseToAnyPublisher()
}

Agora que temos nossa getPosts()função, vamos usá-la para recuperar os dados JSON. O código a seguir mostra como usar a sinkfunção para receber os dados:

var cancellable: AnyCancellable?
cancellable = getPosts()
    .sink(receiveCompletion: { completion in
        switch completion {
        case .failure(let error):
            print(error.localizedDescription)
        case .finished:
            break
        }
    }, receiveValue: { data in
        let decoder = JSONDecoder()
        if let posts = try? decoder.decode([Post].self, from: data) {
            // Do something with the posts
        }
    })

Para exibir as postagens em uma exibição de lista, criamos uma nova estrutura chamada PostList. O código a seguir mostra como definir a PostListestrutura:

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

struct PostList: View {
    @State var posts: [Post] = []
    var body: some View {
        List(posts, id: \.id) { post in
            VStack(alignment: .leading) {
                Text(post.title)
                    .font(.headline)
                Text(post.body)
                    .font(.subheadline)
            }
        }
        .onAppear(perform: fetchData)
    }

    func fetchData() {
        cancellable = getPosts()
            .sink(receiveCompletion: { completion in
                switch completion {
                case .failure(let error):
                    print(error.localizedDescription)
                case .finished:
                    break
                }
            }, receiveValue: { data in
                let decoder = JSONDecoder()
               if let posts = try? decoder.decode([Post].self, from: data) {
                    self.posts = posts
                }
          })
            
    }
}

É isso! Usamos com sucesso a estrutura Combine para executar operações de rede e exibir os dados em uma exibição de lista.

Em conclusão, usar o framework Combine para executar operações de rede no Swift é uma maneira poderosa de lidar com eventos assíncronos. A estrutura fornece muitos operadores que facilitam a manipulação de dados e o tratamento de erros. Com a getPosts()função, conseguimos recuperar os dados JSON e, com a PostListstruct, conseguimos exibir os dados em uma exibição de lista. Esta é apenas a ponta do iceberg, e há muito mais para explorar com o framework Combine.