iOS e Swift: Instalação e uso do gerenciador de dependências Cocoapods

iOS e Swift: Instalação e uso do gerenciador de dependências Cocoapods
Giovanna Moeller
Giovanna Moeller

Compartilhe

Resumindo

Neste artigo, vamos entender como instalar e utilizar um gerenciador de dependências muito utilizado no Swift, chamado "Cocoapods". Veremos também:

  • O que são dependências;
  • Por que utilizar dependências externas.

Saber utilizar dependências nos projetos é muito importante no mundo do desenvolvimento, pois facilita a nossa vida e poupa o nosso tempo, dispensando a necessidade de criar uma nova funcionalidade do zero (se ela já existir!). Você busca otimizar o seu tempo? Então, esse artigo é para você.

Depois de ler esse artigo, você vai conseguir compreender e utilizar esse gerenciador de dependências tão utilizado nas aplicações. Vamos lá?

Entendendo o que é uma dependência

Em um contexto de gerenciadores de dependências, como o Cocoapods (que veremos mais a seguir), uma dependência nada mais é do que uma biblioteca externa que o seu projeto utiliza.

“Ok, mas o que é uma biblioteca?”

Imagine que você precise desenvolver uma funcionalidade no seu projeto, mas essa mesma funcionalidade já foi desenvolvida por uma outra pessoa (ou um grupo de pessoas) e disponibilizada na internet para que qualquer um também possa utilizar. Logo, em vez de desenvolver essa funcionalidade do zero, você pode utilizar essa solução proposta, “importando” essa funcionalidade para a sua aplicação/código.

Assim, uma biblioteca (ou em inglês, chamada de library, ou até mesmo no modo abreviado, "lib") é um conjunto de funcionalidades (funções pré-escritas) que foram desenvolvidas por outras pessoas que já resolveram determinado problema, para poupar você de "reinventar a roda" e otimizar o seu tempo. Vamos para os exemplos?

No mundo do desenvolvimento iOS, uma biblioteca muito utilizada se chama "Alamofire" (você pode acessa-lá aqui). A partir dela, podemos simplificar a forma como escrevemos requisições HTTP. Sem essa biblioteca, temos acesso à API do URLSession, que também realiza requisições HTTP, porém, exige muito mais código para obter o mesmo resultado.

Portanto, utilizar uma dependência externa, quando necessário, é muito importante para o desenvolvimento do seu projeto, já que simplifica muito a utilização de determinada funcionalidade. Assim, conseguimos reutilizar um código já desenvolvido por terceiros, otimizando o tempo na criação de uma nova funcionalidade.

E agora, vamos aprender como colocar uma dependência no nosso projeto?

E o que seria um gerenciador de dependências?

Vamos pensar um pouco: não faz muito sentido fazer a integração de uma biblioteca de terceiros de forma manual, não é mesmo? Imagine arrastar manualmente um código externo, isso não seria muito viável, correto? Por isso, nós usamos um gerenciador de dependências, que cuida de toda essa parte!

Portanto, para pouparmos o trabalho manual, usamos algo como um "intermediador", que, no caso, é um gerenciador de pacotes/dependência. É exatamente esse gerenciador que vai fazer duas ações principais: procurar a biblioteca que desejamos e, então, instalar ela na nossa aplicação. Também, é com o gerenciador de pacotes que nós atualizamos ou desinstalamos alguma dependência. Resumindo, o gerenciador de dependências é quem cuida da busca, instalação e atualização das dependências/bibliotecas para a gente. Muito incrível, não é mesmo?

Vamos dar exemplos: No caso do NodeJS, que é um ambiente de execução em Javascript, para instalar alguma dependência externa, podemos utilizar o NPM (Node Package Manager). Mas, e no Swift? Qual é utilizado?

Gerenciador de Dependências iOS

No iOS, temos alguns gerenciadores de dependências que são bem utilizados, como:

Cada um possui as suas vantagens e desvantagens. O mais famoso e utilizado é o Cocoapods, já que possui mais de 87 mil bibliotecas (no momento em que este artigo foi escrito) e é utilizado em mais de 3 milhões de aplicativos, sendo muito fácil de configurar. É importante mencionar que o Cocoapods é bem centralizado, as dependências são armazenadas em um repositório central e fica muito mais fácil para o desenvolvedor descobrir as bibliotecas que estão disponíveis para uso, e então integrá-las ao seu projeto.

Portanto, nesse artigo, vamos explorar mais o uso do Cocoapods, já que é o mais utilizado.

Instalando o Cocoapods

Como primeiro passo, precisamos ter acesso ao Cocoapods. Se você não tiver ele instalado, abra o terminal do seu macOS e então digite o seguinte comando:

sudo gem install cocoapods

Com isso, o Cocoapods será instalado. Ele foi desenvolvido utilizando a linguagem Ruby e este comando irá instalá-lo utilizando a biblioteca Ruby que vem no MacOS.

Para instalar, é necessário que o usuário esteja com acesso de administrador, por isso, utilizamos o comando sudo no início.

Após a instalação, haverá muitas mensagens diferentes, não se preocupe, se nenhum erro for encontrado, significa que a instalação do foi concluída com sucesso!

Em seguida, você precisa configurar o repositório principal dos Cocoapods. Digite no terminal o comando pod setup, que fará toda a configuração necessária para conseguirmos instalar e utilizar as dependências no nosso projeto. Pronto! Agora com o Cocoapods já instalado na sua máquina, vamos aprender como instalar uma dependência com ele. Vamos lá?

Instalando uma dependência com o Cocoapods

Lembra do início do artigo, em que eu comentei sobre uma biblioteca muito utilizada no iOS para requisições HTTP, o Alamofire? Então, vamos instalá-la no nosso projeto utilizando o Cocoapods!

Com o seu projeto criado no XCode, caminhe até ele no terminal, utilizando o comando cd. Você precisa caminhar até o diretório raíz desse projeto, ou seja, onde o arquivo .xcodeproj se encontra. Vamos supor que nosso projeto se chama "ToDoList" e está localizado dentro da pasta "Documentos". No terminal, você precisa digitar os comandos:

Imagem mostrando o terminal do XCode com os comandos `cd`, para percorrer todo o caminho necessário até chegar ao diretório raíz do projeto: cd Documents, cd ToDoList.

E pronto! O comando tree lista tudo que estiver dentro dessa pasta em formato de árvore, e veja que nosso arquivo .xcodeproj está realmente lá.

Agora, ainda no terminal, dentro da pasta do projeto, digite o comando pod init. Esse comando irá criar um arquivo chamado Podfile dentro da pasta que conterá todas as dependências do projeto.

Você precisa abrir esse arquivo Podfile, e para fazer isso, entre na pasta e dê um duplo clique. Outra forma de abrir o arquivo pode ser feita no próprio terminal, utilizando o comando open -a Xcode Podfile.

Esse arquivo Podfile será aberto como um arquivo de texto.

É dentro desse arquivo que iremos adicionar a dependência a ser utilizada, embaixo do # Pods for ToDoList (lembrando que ToDoList é o nome do nosso projeto aqui), vamos escrever: pod 'Alamofire', já que é a dependência que queremos instalar.

Você também pode especificar qual versão da dependência você deseja: vamos supor que a versão que queremos instalar é a 5.0.0, portanto, escreveremos: pod 'Alamofire', '5.0.0'. Caso não seja colocada a versão, ele instalará a última disponível. Veja uma imagem abaixo de como fica o nosso arquivo Podfile com a dependência:

Imagem mostrando o arquivo Podfile com a dependência escrita, pronta para ser instalada.

Feito isso, salve o arquivo e volte para o terminal. No terminal, execute o comando pod install, para que ele possa instalar, de fato, a dependência que colocamos. Dependendo de quantas bibliotecas você adicionou ao Podfile para o seu projeto, o tempo de instalação pode variar. Depois de concluído, haverá uma mensagem de sucesso na tela.

Uma observação sobre o Cocoapods é que ele obriga você a abrir o projeto no formato .xcworkspace em vez de .xcodeproj. Portanto, feche o seu XCode e abra o projeto novamente nesse formato de arquivo, que estará dentro da pasta raíz do seu projeto, no mesmo lugar onde o arquivo .xcodeproj se encontra.

E pronto! A sua dependência foi instalada com sucesso e você já pode utilizá-la. Lembramos que, nos arquivos onde você utilizará dessa dependência de fato, é necessário importá-la ao seu código, dessa maneira:

import UIKit
import Alamofire
// Código aqui…

Para saber mais: Bibliotecas comuns em projetos iOS

Vamos ver, a seguir, algumas bibliotecas que são utilizadas em aplicações iOS. Além do Alamofire, como vimos acima, temos:

  • RxSwift: permite o uso de programação reativa e de forma assíncrona;
  • Kingfisher: uma biblioteca para baixar e armazenar, em cache, imagens da web;
  • Lottie: permite trabalhar com arquivos "lottie", que é um formato de arquivo de animação baseado em JSON;
  • SnapKit: É uma biblioteca de Auto Layout que simplifica a escrita de layout automático no código com uma quantidade mínima de código necessária, sem perder a legibilidade.
  • Você também pode ver mais bibliotecas incríveis aqui.

Conclusão

Nesse artigo, entendemos mais sobre dependências externas, o porquê e como utilizá-las no iOS, através do gerenciador de dependências chamado Cocoapods.

Você também pode complementar seus estudos lendo mais sobre na documentação.

Se você tem interesse em outros artigos ou quer conhecer mais sobre o desenvolvimento iOS, basta me procurar aqui: Linkedin.

Quer saber mais sobre iOS? Confira nosso curso para iniciantes aqui na Alura: Swift parte 1 - Desenvolvendo para iOS no Xcode.

Até a próxima!

Giovanna Moeller
Giovanna Moeller

Oie, eu sou a Gi! Apaixonada por programação e design. Criadora de conteúdo no youtube e instagram @girl.coding.

Veja outros artigos sobre Mobile