DEV Community: Lys

Construindo um App com uma API do Github, uma Collection View e um sonho

Lys — Mon, 18 Aug 2025 16:19:56 +0000

Depois de ler sobre a flexibilidade da Collection View, achei interessante usá-la lado a lado de uma Table View e comentar um pouco das diferenças que podemos encontrar.
O projeto lista usuários com table view e collection view, e os busca usando a API do Github.

Diferente da table view, projetada para exibir dados em uma única coluna vertical, como uma lista, UICollectionView é um componente muito mais flexível, projetado para exibir dados em layouts personalizáveis e multidimensionais, podemos fazer carrosséis e também layouts em grade.

Esses usuários são exibidos a partir desse objeto:

import Foundation

struct GithubUserViewModel {
    let avatarURL: URL?
    let name: String
    let login: String
    let description: String?
    let language: String?
    let publicRepos: Int?
    let following: Int?
    let followers: Int?
}

Que é populado a partir de uma request em um interactor, e depois apresentado via presenter

override func viewDidLoad() {
        super.viewDidLoad()
        showLoading()
        setupUI()
        interactor.loadInitialUsers()
}

private func setupUI() {
        title = "GitHub Users"
        navigationController?.navigationBar.titleTextAttributes = [
            .foregroundColor: UIColor.label
        ]
        view.backgroundColor = .systemBackground

        view.addSubview(searchBar)
        view.addSubview(switchContainer)
        view.addSubview(tableView)

        view.addSubview(scrollView)

        scrollView.addSubview(collectionView)

        switchContainer.addSubview(switchLabel)
        switchContainer.addSubview(switchButton)

        NSLayoutConstraint.activate([
            searchBar.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 8),
            searchBar.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 8),
            searchBar.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -8),

            switchContainer.topAnchor.constraint(equalTo: searchBar.bottomAnchor, constant: 8),
            switchContainer.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            switchContainer.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
            switchContainer.heightAnchor.constraint(equalToConstant: 40),

            switchLabel.leadingAnchor.constraint(equalTo: switchContainer.leadingAnchor),
            switchLabel.centerYAnchor.constraint(equalTo: switchContainer.centerYAnchor),

            switchButton.trailingAnchor.constraint(equalTo: switchContainer.trailingAnchor),
            switchButton.centerYAnchor.constraint(equalTo: switchContainer.centerYAnchor),

            tableView.topAnchor.constraint(equalTo: switchContainer.bottomAnchor, constant: 8),
            tableView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            tableView.trailingAnchor.constraint(equalTo: view.trailingAnchor),

            scrollView.topAnchor.constraint(equalTo: switchContainer.bottomAnchor, constant: 8),
            scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            scrollView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),

            collectionView.topAnchor.constraint(equalTo: scrollView.topAnchor),
            collectionView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor, constant: 8),
            collectionView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
            collectionView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),

            collectionView.widthAnchor.constraint(equalTo: scrollView.widthAnchor),
            collectionView.heightAnchor.constraint(equalToConstant: 480),

        ])
    }

Ja escrevi sobre VIP por aqui, então não passarei por essa parte

O UICollectionViewLayout é quem define como os itens são organizados, permitindo grades, carrosséis, layouts circulares, etc.

private lazy var collectionView: UICollectionView = {
        let layout = UICollectionViewFlowLayout()
        layout.scrollDirection = .horizontal
        layout.minimumLineSpacing = 10
        layout.minimumInteritemSpacing = 10
        let collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
        collectionView.delegate = self
        collectionView.dataSource = self
        collectionView.register(UserProfileCollectionViewCell.self, forCellWithReuseIdentifier: UserProfileCollectionViewCell.reuseIdentifier)
        collectionView.register(ErrorCollectionViewCell.self, forCellWithReuseIdentifier: ErrorCollectionViewCell.reuseIdentifier)
        collectionView.register(LongCardUserProfileCollectionViewCell.self, forCellWithReuseIdentifier: LongCardUserProfileCollectionViewCell.reuseIdentifier)
        collectionView.translatesAutoresizingMaskIntoConstraints = false
        collectionView.isHidden = true
        return collectionView
    }()

Abaixo vamos ver um pouco mais sobre o que iremos encontrar desenvolvendo uma Collection View, e mais abaixo veremos o código de exemplo para elas

A UICollectionViewCell representa cada elemento exibido na Collection View, no exemplo, a célula está representando os dados de cada usuário, mas também pode exibir uma ErrorCollectionViewCell, por exemplo.

A classe UICollectionReusableView representa visualizações reutilizáveis na Collection View. Ela é usada para criar componentes reutilizáveis, como cabeçalho, rodapé ou componentes intermediários personalizados.

O protocolo UICollectionViewDataSource é responsável por fornecer os dados para a sua UICollectionView. Ele responde a perguntas como quantas seções a coleção tem, quantos itens existem em cada seção e
qual célula deve ser exibida para cada item no índice específico?

O protocolo UICollectionViewDelegate lida com eventos como o que acontece quando o usuário toca em uma célula, qual deve ser o tamanho de cada célula ou cabeçalho e como a coleção deve reagir ao ser rolada.

Implementando os protocolos de data source, delegate e flow layout, eu costumo criar uma extension para implementá-los e ficar mais organizado, algo assim

// MARK: - UICollectionViewDataSource, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout

extension UserListViewController: UICollectionViewDataSource, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout {
    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        if showErrorCell && users.isEmpty {
            return 1
        }
        return users.count
    }

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        if showErrorCell && users.isEmpty {
            guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: ErrorCollectionViewCell.reuseIdentifier, for: indexPath) as? ErrorCollectionViewCell else {
                return UICollectionViewCell()
            }
            return cell
        }

        if !isGridMode {
            guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: LongCardUserProfileCollectionViewCell.reuseIdentifier, for: indexPath) as? LongCardUserProfileCollectionViewCell else {
                return UICollectionViewCell()
            }
            cell.configure(with: users[indexPath.item])
            return cell
        }

        guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: UserProfileCollectionViewCell.reuseIdentifier, for: indexPath) as? UserProfileCollectionViewCell else {
            return UICollectionViewCell()
        }
        cell.configure(with: users[indexPath.item])
        return cell
    }

    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
        return CGSize(width: 250, height: 250)
    }

    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        if !showErrorCell {
            let selectedUser = users[indexPath.item]
            let detailVC = UserDetailViewController(user: selectedUser)
            navigationController?.pushViewController(detailVC, animated: true)
        }
    }

    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        if scrollView == collectionView {
            let offsetX = scrollView.contentOffset.x
            let contentWidth = scrollView.contentSize.width
            let width = scrollView.frame.size.width

            if offsetX > contentWidth - width - 100, !isLoading, hasMoreData, isCollectionViewMode {
                isLoading = true
                interactor.loadMoreUsers()
            }
        } else {
            let offsetY = scrollView.contentOffset.y
            let contentHeight = scrollView.contentSize.height
            let height = scrollView.frame.size.height

            if offsetY > contentHeight - height - 100, !isLoading, hasMoreData, !isCollectionViewMode {
                isLoading = true
                interactor.loadMoreUsers()
            }
        }
    }
}

Essa apresentação faz parte da Collection View em carrossel, perceba que ela tem uma altura fixa e não divide a largura da view, por exemplo, para fazer um layout em grid, como veremos no código abaixo.

UICollectionViewDelegateFlowLayout

O sizeForItemAt define o tamanho (CGSize) de cada célula em um indexPath específico.

Os tamanhos são diferentes para vermos as possibilidades de exibir como carrossel e grid.

// MARK: - UICollectionViewDataSource, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout

extension UserListGridViewController: UICollectionViewDataSource, UICollectionViewDelegate, UICollectionViewDelegateFlowLayout {
    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        if showErrorCell && users.isEmpty {
            guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: ErrorCollectionViewCell.reuseIdentifier, for: indexPath) as? ErrorCollectionViewCell else {
                return UICollectionViewCell()
            }
            return cell
        }

        guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: UserProfileCollectionViewCell.reuseIdentifier, for: indexPath) as? UserProfileCollectionViewCell else {
            return UICollectionViewCell()
        }
        cell.configure(with: users[indexPath.item])
        return cell
    }

    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
        let padding: CGFloat = 10
        let itemsPerRow: CGFloat = 2
        let rowsPerColumn: CGFloat = 4

        let availableWidth = collectionView.bounds.width - padding * (itemsPerRow + 1)
        let cellWidth = availableWidth / itemsPerRow

        let availableHeight = collectionView.bounds.height - padding * (rowsPerColumn + 1)
        let cellHeight = availableHeight / rowsPerColumn

        return CGSize(width: cellWidth, height: cellHeight)

    }
}

Percebem a diferença entre o sizeForItemAt anterior e o atual, isso significa que vamos exibir o layout em grade e precisamos desses valores diferentes para mapear como essa grade será exibida, abaixo explico um pouco de cada valor:

padding

Cria uma constante chamada padding (preenchimento ou margem) com o valor 10. Esse valor representa o espaçamento entre as células e também as margens da coleção.

itemsPerRow

Define uma constante itemsPerRow (itens por linha) com o valor 2. Isso significa que a intenção é ter duas células por linha.

rowsPerColumn

Define uma constante rowsPerColumn (linhas por coluna) com o valor 4. Isso indica que o objetivo é ter quatro linhas na tela.

availableWidth

Calcula a largura disponível para as células.

collectionView.bounds.width é a largura total da UICollectionView.

padding * (itemsPerRow + 1) calcula o espaço total ocupado pelas margens. Se você tem 2 itens por linha, há uma margem no início, uma entre os dois itens, e uma no final, totalizando 3 margens (2 + 1). Então, o cálculo subtrai esse espaço total da largura da tela.

cellWidth

Divide a largura disponível (availableWidth) pelo número de itens por linha (itemsPerRow). O resultado é a largura que cada célula deve ter para caber na linha.

availableHeight

De forma análoga ao cálculo da largura, essa linha calcula a altura disponível para as células.

collectionView.bounds.height é a altura total da UICollectionView.

padding * (rowsPerColumn + 1) calcula o espaço total das margens verticais. Se você tem 4 linhas, haverá 5 margens (4 + 1).

cellHeight

Divide a altura disponível (availableHeight) pelo número de linhas (rowsPerColumn). O resultado é a altura que cada célula deve ter.

return CGSize(width: cellWidth, height: cellHeight)

Finalmente, a função retorna um objeto CGSize, que é uma estrutura que contém a largura e a altura calculadas. Esse valor é usado pelo UICollectionView para desenhar cada célula na tela com o tamanho correto.

UICollectionViewDataSource

O numberOfItemsInSection informa à collection view quantos itens ela deve exibir em uma determinada seção, se houver um erro, apenas 1 é exibido, ou se houver sucesso, exibirá users.count, o total de usuários.

O cellForItemAt configura e retorna a célula que será exibida em um indexPath específico

UICollectionViewDelegate

O didSelectItemAt é chamado sempre que o usuário toca em uma célula.

O scrollViewDidScroll, parte do ScrollViewDelegate (que a UICollectionView herda), é acionado toda vez que o usuário rola a tela. Usamos geralmente para trabalhar com paginação.

Agora criando a célula de sucesso que exibimos no cellForItemAt:

import UIKit

final class UserProfileCollectionViewCell: UICollectionViewCell {

    static let reuseIdentifier = "UserProfileCollectionViewCell"

    private lazy var avatarImageView: UIImageView = {
        let image = UIImageView()
        image.translatesAutoresizingMaskIntoConstraints = false
        image.contentMode = .scaleAspectFill
        image.clipsToBounds = true
        return image
    }()

    private lazy var titleLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.font = .systemFont(ofSize: 18, weight: .bold)
        label.textAlignment = .center
        return label
    }()

    private lazy var descriptionComponent: IconTextComponent = {
        let component = IconTextComponent()
        return component
    }()

    private lazy var reposComponent: IconTextComponent = {
        let component = IconTextComponent()
        return component
    }()

    private lazy var followersComponent: IconTextComponent = {
        let component = IconTextComponent()
        return component
    }()

    private lazy var stackView: UIStackView = {
        let stackView = UIStackView(arrangedSubviews: [titleLabel, descriptionComponent, reposComponent, followersComponent])
        stackView.translatesAutoresizingMaskIntoConstraints = false
        stackView.axis = .vertical
        stackView.spacing = 4
        stackView.alignment = .leading
        return stackView
    }()

    override init(frame: CGRect) {
        super.init(frame: frame)
        setupLayout()
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func layoutSubviews() {
        super.layoutSubviews()
        avatarImageView.layer.cornerRadius = avatarImageView.bounds.width / 2
    }

    func configure(with viewModel: GithubUserViewModel) {
        titleLabel.text = viewModel.name

        let descriptionText = (viewModel.description == nil || viewModel.description == "") ? "No description" : viewModel.description!
        descriptionComponent.configure(imageName: "pencil", text: descriptionText)

        let reposText = "\(viewModel.publicRepos ?? 0) public repos"
        reposComponent.configure(imageName: "folder", text: reposText)

        let followersText = "\(viewModel.followers ?? 0) followers"
        followersComponent.configure(imageName: "person", text: followersText)

        avatarImageView.load(url: viewModel.avatarURL)
    }

    private func setupLayout() {
        contentView.addSubview(avatarImageView)
        contentView.addSubview(stackView)

        contentView.layer.cornerRadius = 12
        contentView.layer.borderWidth = 1
        contentView.layer.borderColor = UIColor.lightGray.cgColor
        contentView.clipsToBounds = true

        NSLayoutConstraint.activate([
            avatarImageView.topAnchor.constraint(equalTo: contentView.topAnchor, constant: 16),
            avatarImageView.centerXAnchor.constraint(equalTo: contentView.centerXAnchor),
            avatarImageView.widthAnchor.constraint(equalToConstant: 80),
            avatarImageView.heightAnchor.constraint(equalToConstant: 80),

            stackView.topAnchor.constraint(equalTo: avatarImageView.bottomAnchor, constant: 12),
            stackView.leadingAnchor.constraint(equalTo: contentView.leadingAnchor, constant: 8),
            stackView.trailingAnchor.constraint(equalTo: contentView.trailingAnchor, constant: -8),
            stackView.bottomAnchor.constraint(lessThanOrEqualTo: contentView.bottomAnchor, constant: -16)
        ])
    }
}

E ela, ao ser clicada, abre o fluxo UserDetailViewController (como descrito na função didSelectItemAt)

Você pode encontrar o código completo da UserListViewController no link do github

Value Types vs Reference Types em Swift: Quando Usar Struct ou Class?

Lys — Mon, 23 Jun 2025 19:25:31 +0000

O questionamento sobre a diferença entre Struct e Class é muito importante, te ajuda a responder uma pergunta recorrente em entrevistas técnicas, e também te ajuda a entender um pouco mais do que tanto usamos no dia a dia.

Pra você ter uma ideia, tipos que usamos no dia a dia são Struct's, como String, Int, Array, Date, etc.

Com o SwiftUI, vem um aumento do uso de Struct's, ja que para criamos View Controller's, criamos usando Class, e para criar View's em SwiftUI, usamos Struct.

Há uma lista de coisas que ambas tem em comum:

Definem propriedades
Definem métodos
Podem usar subscripts
Possuem inicializadores
Podem ser estendidas
Podem adotar protocolos

Mesmo muito semelhantes, há diferenças cruciais entre elas que podem ser muito importantes na hora de tomar uma decisão criando algo com Struct ou Class

Struct é Value Type e Class é Reference Type

Sendo um tipo de valor, ao atribuí-la a uma nova variável, uma cópia independente é criada. Alterações em uma não afetam a outra.

Classes são tipos de referência, então atribuições compartilham a mesma instância. Alterar uma afeta todas as referências.

Ao criar um objeto Store, sendo uma struct, e um objeto Bank, sendo uma class.

import UIKit

struct Store {
    var salesQuantity: Int
}

class Bank {
    var accountNumber: Int

    init(accountNumber: Int) {
        self.accountNumber = accountNumber
    }
}

Vamos instanciar cada um deles e atribuir um valor inicial para salesQuantity e accountNumber.

Ao criar foodStore, por ser uma struct, uma cópia de clothesStore é criada e ao atribuirmos um novo valor, apenas a cópia é modificada.

// Criando instâncias
let clothesStore = Store(salesQuantity: 100)
var foodStore = clothesStore  // Isso cria uma CÓPIA
foodStore.salesQuantity = 50  // Modifica apenas a cópia

Ao criar grayBank, por ser uma class, uma referência de pinkBank é criada e ao atribuirmos um novo valor, modificamos o objeto original.

// Criando instâncias
let pinkBank = Bank(accountNumber: 123456789)
var grayBank = pinkBank  // Isso cria uma REFERÊNCIA (mesmo objeto)
grayBank.accountNumber = 987654321  // Modifica o objeto original

Conseguimos visualizar isso ao printar os valores de cada um.

// Imprimindo valores
print("\nValores das classes:")
print("pinkBank:", pinkBank.accountNumber)
print("grayBank:", grayBank.accountNumber)

print("\nValores das structs:")
print("clothesStore:", clothesStore.salesQuantity)
print("foodStore:", foodStore.salesQuantity)

Herança

Classes podem herdar de uma única superclasse, ou de uma classe, que herda de outra, formando uma cadeia de herança (não há herança múltipla direta de várias superclasses) e protocolos.
Struct's não herdam de classes, de struct's, não fazem cadeia de herança, apenas herdam de protocolos.

Memória

Classes usam o ARC para contagem automática de referência.
A classe também tem desinicializadores que permitem que uma instância de classe libere quaisquer recursos que tenha alocado.
Struct's não usam ARC para gerenciamento de memória, pequenas structs geralmente são armazenadas na stack (pilha) e struct's maiores ou contendo referências podem acabar sendo armazenadas no heap.

🏃‍♀️ Diferenciais na performance 🏃‍♀️

Classes

Alocadas no heap, que tem maior custo de gerenciamento
Requerem contagem de referência (ARC overhead)
Acesso indireto via ponteiro (pode causar cache misses)
Mesmo para objetos pequenos, há overhead de metadados

Struct's

Alocadas na stack (pilha), que é mais rápida para alocação/desalocação
Acesso direto à memória (menos indireção)
Cópias são baratas para tipos pequenos (até alguns campos)
Melhor localidade de cache (dados contíguos na memória)

Também falando de thread safety

Como são copiadas ao serem passadas no código, as structs podem ser usadas com segurança em ambientes multi-thread. As classes, por trabalharem com referências, demandam sincronizações cuidadosas quando acessadas por múltiplas threads, para prevenir condições de corrida.

📖 O que a documentação diz? 📖

Usar Class quando

Você precisa de herança
É necessário compartilhar um estado mutável entre várias partes do código, ou seja, múltiplas referências devem apontar para a mesma instância.
O tipo precisa de recursos como contagem de referência (ARC) para gerenciamento de memória.
O tipo precisa de recursos como desinicializadores .
O tipo precisa interoperar com APIs baseadas em classes (como muitos frameworks da Apple: UIKit, AppKit etc.).

Usar Struct quando

Você não precisa de herança nem de desinicializadores.
O tipo será copiado em vez de compartilhado
As propriedades armazenadas são todas também valores (ou seja, tipos que não têm semântica de referência).
O desempenho importa, e o tipo é pequeno e leve o suficiente para ser manipulado eficientemente com cópia.
Você quer imutabilidade por padrão (ao usar let, as structs inteiras são imutáveis, ao contrário de classes).

Aplicando testes unitários com XCTest em um projeto iOS numa arquitetura VIP

Lys — Wed, 30 Apr 2025 22:13:18 +0000

Testes unitários são essenciais para garantir que nosso código funcione conforme o esperado. Eles vão além de validar funcionalidades durante o desenvolvimento - previnem regressões futuras, pois alterações no código podem impactar comportamentos existentes. Os testes ajudam a identificar esses problemas antes que cheguem ao usuário final.

Além disso, são uma forma de documentar o comportamento esperado do sistema, facilitar refatorações e reduzir tempo de debug.

Dando continuidade ao projeto desenvolvido com a arquitetura VIP, foram implementadas classes que conformam com protocolos específicos para cada componente (Interactor, Presenter e View). Essa abordagem traz duas vantagens principais:

Facilidade de Testes: A utilização de protocolos permite a criação de mocks ou spies, simplificando a escrita de testes unitários.

Desacoplamento: Cada componente pode ser testado isoladamente, garantindo maior modularidade e manutenibilidade.

Serão desenvolvidos testes unitários para os três principais componentes da arquitetura:

Interactor (Lógica de negócios)
Presenter (Transformação de dados para exibição)
View (Exibição e interação do usuário)

Uso de XCTest

O XCTest é a solução oficial da Apple, mas há outras opções no mercado como Quick/Nimble, Cuckoo e OHHTTPStubs.

Possibilidades de uso de XCTest e outras tecnologias

Framework	Vantagens	Melhor Caso de Uso
XCTest	Integração nativa, performance	Projetos Apple puros
Quick/Nimble	Sintaxe legível, BDD	Times acostumados com Ruby/RSpec
Cuckoo	Geração automática de mocks	Projetos com muitas dependências

A fim de praticidade, simplicidade, e a integração ao Xcode sem dependências externas, usaremos o XCTest

Para adicioná-lo ao seu projeto, crie um novo Target a partir de File

E então selecione a opção Unit Testing Bundle

A estrutura de arquivos ficará assim, separando Mocks, Responses, e uma pasta para cada parte do VIP

Criando os Mocks

Tipos de Test Doubles

Spy: Registra chamadas para verificação posterior (como usado no artigo)
Mock: Possui expectativas pré-definidas que falham o teste se não forem atendidas
Stub: Retorna respostas pré-programadas sem verificação
Fake: Implementação simplificada para testes (ex: banco de dados em memória)

Nossos *Spy são na verdade combinações de Spy+Stub, pois:

Registram chamadas (Spy)
Permitem configurar respostas (Stub)

Como temos protocolos no nosso projeto, podemos criar objetos do tipo Spy para conformar com esses protocolos, e então, ao inicializar um Interactor, Presenter, ou View, passaremos nosso objeto mockado à ele.

Um Spy é um tipo de test double (objeto de teste) que:

Registra informações sobre como foi chamado (métodos, argumentos, frequência).

Permite verificação posterior no teste (ex: "esse método foi chamado 1 vez?").

Interactor

Usado para instanciar a view controller, rastreará a quantidade de chamadas a fetchArticles e didSelectArticle, e também os parâmetros recebidos em cada requisição

@testable import CareerAppUIKit

final class ArticlesInteractorSpy: ArticlesBusinessLogic {

    // MARK: - Call Tracking
    private(set) var fetchArticlesCallCount = 0
    private(set) var didSelectArticleCallCount = 0
    private(set) var lastFetchRequest: Articles.FetchArticles.Request?
    private(set) var lastSelectRequest: Articles.DidSelectArticle.Request?

    // MARK: - ArticlesBusinessLogic
    func fetchArticles(request: Articles.FetchArticles.Request) {
        fetchArticlesCallCount += 1
        lastFetchRequest = request
    }

    func didSelectArticle(request: Articles.DidSelectArticle.Request) {
        didSelectArticleCallCount += 1
        lastSelectRequest = request
    }

    // MARK: - Test Helpers
    func reset() {
        fetchArticlesCallCount = 0
        didSelectArticleCallCount = 0
        lastFetchRequest = nil
        lastSelectRequest = nil
    }
}

Presenter

Usado para instanciar o Interactor, rastreará as chamadas de formatação (presentArticles, presentError, presentLoading) e os dados recebidos e enviados para a View.

@testable import CareerAppUIKit

final class ArticlesPresenterSpy: ArticlesPresentationLogic {

    // MARK: - Call Tracking
    private(set) var presentArticlesCallCount = 0
    private(set) var presentErrorCallCount = 0
    private(set) var presentLoadingCallCount = 0
    private(set) var lastArticlesResponse: Articles.FetchArticles.Response?
    private(set) var lastErrorResponse: Articles.PresentError.Response?
    private(set) var lastLoadingResponse: Articles.PresentLoading.Response?

    // MARK: - ArticlesPresentationLogic
    func presentArticles(response: Articles.FetchArticles.Response) {
        presentArticlesCallCount += 1
        lastArticlesResponse = response
    }

    func presentError(response: Articles.PresentError.Response) {
        presentErrorCallCount += 1
        lastErrorResponse = response
    }

    func presentLoading(response: Articles.PresentLoading.Response) {
        presentLoadingCallCount += 1
        lastLoadingResponse = response
    }

    // MARK: - Test Helpers
    func reset() {
        presentArticlesCallCount = 0
        presentErrorCallCount = 0
        presentLoadingCallCount = 0
        lastArticlesResponse = nil
        lastErrorResponse = nil
        lastLoadingResponse = nil
    }
}

Router

Usado para instanciar o Interactor, rastreará as chamadas a routeToArticleDetail e os IDs de artigos passados durante a navegação.

@testable import CareerAppUIKit

final class ArticlesRouterSpy: ArticlesRoutingLogic {

    // MARK: - Call Tracking
    private(set) var routeToArticleDetailCallCount = 0
    private(set) var routedArticleIds: [Int] = []

    // MARK: - ArticlesRoutingLogic
    func routeToArticleDetail(id: Int) {
        routeToArticleDetailCallCount += 1
        routedArticleIds.append(id)
    }

    // MARK: - Test Helpers
    func reset() {
        routeToArticleDetailCallCount = 0
        routedArticleIds = []
    }
}

View

Usada para instanciar o Presenter, rastreará as chamadas de atualização de UI (displayArticles, displayLoading, displayError) e os estados de loading e mensagens de erro.

@testable import CareerAppUIKit

final class ArticlesViewSpy: ArticlesDisplayLogic {

    // MARK: - Call Tracking
    private(set) var displayArticlesCallCount = 0
    private(set) var displayLoadingCallCount = 0
    private(set) var displayErrorCallCount = 0
    private(set) var lastDisplayedArticles: [DisplayedArticle]?
    private(set) var lastLoadingState: Bool?
    private(set) var lastErrorMessage: String?

    // MARK: - ArticlesDisplayLogic
    func displayArticles(viewModel: Articles.FetchArticles.ViewModel) {
        displayArticlesCallCount += 1
        lastDisplayedArticles = viewModel.displayedArticles
    }

    func displayLoading(viewModel: Articles.PresentLoading.Response) {
        displayLoadingCallCount += 1
        lastLoadingState = viewModel.isLoading
    }

    func displayError(viewModel: Articles.PresentError.Response) {
        displayErrorCallCount += 1
        lastErrorMessage = viewModel.errorMessage
    }

    func displayArticleDetail(_ articleDetail: ArticleDetail) {
        // Implementação se necessário
    }

    // MARK: - Test Helpers
    func reset() {
        displayArticlesCallCount = 0
        displayLoadingCallCount = 0
        displayErrorCallCount = 0
        lastDisplayedArticles = nil
        lastLoadingState = nil
        lastErrorMessage = nil
    }
}

Worker

Usado para instanciar o Interactor, permite simular respostas de sucesso/erro da API e define dados fixos para testes.

@testable import CareerAppUIKit

final class ArticlesWorkerSpy: ArticlesWorkerProtocol {

    // MARK: - Properties
    private var stubbedArticles: [Article] = []
    private var stubbedError: Error?

    // MARK: - Public Methods
    func fetchArticles(completion: @escaping (Result<[Article], Error>) -> Void) {
        if let error = stubbedError {
            completion(.failure(error))
        } else {
            completion(.success(stubbedArticles))
        }
    }

    // MARK: - Stub Methods
    func stubSuccessResponse(with articles: [Article]) {
        stubbedArticles = articles
        stubbedError = nil
    }

    func stubFailureResponse(with error: Error) {
        stubbedError = error
        stubbedArticles = []
    }

    func reset() {
        stubbedArticles = []
        stubbedError = nil
    }
}

Estrutura dos testes

Setup e Teardown:
- setUp(): Inicializa os componentes necessários antes de cada teste
- tearDown(): Limpa o estado após cada teste

Importantes para garantir isolamento entre testes e evita vazamento de estado

Organização com MARK:

Facilita navegação e manutenção do código

Separação clara em seções (Properties, Lifecycle, Test Cases, Helpers)

Padrão de Nomenclatura:

Nomearemos "contando uma história" do que o teste faz, para deixá-lo melhor documentado e autoexplicativo.

test_Condição_Ação_ResultadoEsperado
(ex: test_givenSuccessfulResponse_whenFetchingArticles_shouldPresentArticles)

Estrutura Given-When-Then:
- Given: Prepara o estado inicial
- When: Executa a ação sendo testada
- Then: Verifica os resultados

Para clareza em cada fluxo do teste, usaremos esse padrão de construção.

XCTUnwrap para tratamento de opcionais

Solução para um tratamento seguro de desembrulhar opcionais, além de falhar imediatamente o teste se os valores essenciais forem nulos, sua integração mostra a linha exata da falha, com uma mensagem clara e elimina aninhamento de guard/else

func test_userProfile_shouldDisplayCorrectName() throws {
    // Arrange
    let user: User? = User(name: "Ana", age: 28)

    // Act & Assert
    let unwrappedUser = try XCTUnwrap(user, "O objeto user não deveria ser nil")
    XCTAssertEqual(unwrappedUser.name, "Ana", "O nome deveria ser Ana")
}

Escrevendo os testes do Interactor

Os testes do Interactor serão para validar as regras de negócio, validar os casos de sucesso e erro vindos do Worker e se os encaminhamentos idos para o Presenter estão adequados.

import XCTest
@testable import CareerAppUIKit

final class ArticlesInteractorTests: XCTestCase {

    // MARK: - Properties
    private var interactor: ArticlesInteractor?
    private var presenter: ArticlesPresenterSpy?
    private var worker: ArticlesWorkerSpy?
    private var router: ArticlesRouterSpy?

    // MARK: - Test Lifecycle
    override func setUp() {
        super.setUp()
        setupTestComponents()
    }

    override func tearDown() {
        cleanUpTestComponents()
        super.tearDown()
    }

    // MARK: - Test Cases

    func test_fetchArticles_whenWorkerSucceeds_shouldCallPresentArticles() throws {
        // Given
        let worker = try XCTUnwrap(worker, "Worker should not be nil")
        let presenter = try XCTUnwrap(presenter, "Presenter should not be nil")
        let interactor = try XCTUnwrap(interactor, "Interactor should not be nil")

        worker.stubSuccessResponse(with: [])

        // When
        interactor.fetchArticles(request: Articles.FetchArticles.Request())

        // Then
        XCTAssertEqual(presenter.presentArticlesCallCount, 1, "Should call present articles exactly once")
        XCTAssertEqual(presenter.presentErrorCallCount, 0, "Should not call present error")
        XCTAssertNotNil(presenter.lastArticlesResponse, "Should receive articles response")
    }

    func test_fetchArticles_whenWorkerFails_shouldCallPresentError() throws {
        // Given
        let worker = try XCTUnwrap(worker, "Worker should not be nil")
        let presenter = try XCTUnwrap(presenter, "Presenter should not be nil")
        let interactor = try XCTUnwrap(interactor, "Interactor should not be nil")

        let expectedError = NetworkError.decodingError
        worker.stubFailureResponse(with: expectedError)

        // When
        interactor.fetchArticles(request: Articles.FetchArticles.Request())

        // Then
        XCTAssertEqual(presenter.presentErrorCallCount, 1, "Should call present error exactly once")
        XCTAssertEqual(presenter.presentArticlesCallCount, 0, "Should not call present articles")
        XCTAssertEqual(presenter.lastErrorResponse?.errorMessage, expectedError.localizedDescription)
    }

    func test_didSelectArticle_shouldRouteWithCorrectID() throws {
        // Given
        let router = try XCTUnwrap(router, "Router should not be nil")
        let interactor = try XCTUnwrap(interactor, "Interactor should not be nil")

        let testId = 123
        let request = Articles.DidSelectArticle.Request(id: testId)

        // When
        interactor.didSelectArticle(request: request)

        // Then
        XCTAssertEqual(router.routeToArticleDetailCallCount, 1, "Should call route to detail exactly once")
        XCTAssertEqual(router.routedArticleIds.first, testId, "Should route with correct article ID")
    }

    // MARK: - Helper Methods
    private func setupTestComponents() {
        let newPresenter = ArticlesPresenterSpy()
        let newWorker = ArticlesWorkerSpy()
        let newRouter = ArticlesRouterSpy()

        presenter = newPresenter
        worker = newWorker
        router = newRouter

        interactor = ArticlesInteractor(
            presenter: newPresenter,
            worker: newWorker,
            router: newRouter
        )
    }

    private func cleanUpTestComponents() {
        interactor = nil
        presenter?.reset()
        presenter = nil
        worker?.reset()
        worker = nil
        router?.reset()
        router = nil
    }
}

Escrevendo os testes do Presenter

Os testes do Presenter serão para validar os estados de loading/error e a formatação correta dos modelos, vindos do Interactor.

import XCTest
@testable import CareerAppUIKit

final class ArticlesPresenterTests: XCTestCase {

    // MARK: - Properties
    private var sut: ArticlesPresenter?
    private var viewSpy: ArticlesViewSpy?

    // MARK: - Test Lifecycle
    override func setUp() {
        super.setUp()
        sut = ArticlesPresenter()
        viewSpy = ArticlesViewSpy()
        sut?.viewController = viewSpy
    }

    override func tearDown() {
        sut = nil
        viewSpy?.reset()
        viewSpy = nil
        super.tearDown()
    }

    // MARK: - Test Cases

    func test_presentArticles_shouldFormatAndDisplayData() throws {
        // Given
        let articles = try loadArticlesFromJSON()
        let response = Articles.FetchArticles.Response(articles: articles)
        let presenter = try XCTUnwrap(sut, "Presenter não deveria ser nil")
        let view = try XCTUnwrap(viewSpy, "ViewSpy não deveria ser nil")

        // When
        presenter.presentArticles(response: response)

        // Then
        XCTAssertEqual(view.displayArticlesCallCount, 1, "Deveria chamar displayArticles uma vez")
        XCTAssertEqual(view.lastDisplayedArticles?.count, articles.count, "Deveria exibir todos os artigos")
        XCTAssertEqual(view.lastDisplayedArticles?.first?.title, articles.first?.title, "Títulos deveriam corresponder")
    }

    func test_presentLoading_shouldUpdateViewState() throws {
        // Given
        let isLoading = true
        let presenter = try XCTUnwrap(sut, "Presenter não deveria ser nil")
        let view = try XCTUnwrap(viewSpy, "ViewSpy não deveria ser nil")

        // When
        presenter.presentLoading(response: Articles.PresentLoading.Response(isLoading: isLoading))

        // Then
        XCTAssertEqual(view.displayLoadingCallCount, 1, "Deveria chamar displayLoading uma vez")
        XCTAssertEqual(view.lastLoadingState, isLoading, "Estado de loading deveria ser true")
    }

    func test_presentError_shouldDisplayErrorMessage() throws {
        // Given
        let testError = NetworkError.noData
        let presenter = try XCTUnwrap(sut, "Presenter não deveria ser nil")
        let view = try XCTUnwrap(viewSpy, "ViewSpy não deveria ser nil")

        // When
        presenter.presentError(response: Articles.PresentError.Response(errorMessage: testError.localizedDescription))

        // Then
        XCTAssertEqual(view.displayErrorCallCount, 1, "Deveria chamar displayError uma vez")
        XCTAssertEqual(view.lastErrorMessage, testError.localizedDescription, "Mensagem de erro deveria corresponder")
    }

    // MARK: - Helper Methods

    private func loadArticlesFromJSON() throws -> [Article] {
        let bundle = Bundle(for: type(of: self))
        guard let url = bundle.url(forResource: "articles", withExtension: "json") else {
            throw NSError(domain: "Tests", code: 1, userInfo: [NSLocalizedDescriptionKey: "Arquivo JSON não encontrado"])
        }

        let data = try Data(contentsOf: url)
        let decoder = JSONDecoder()
        return try decoder.decode([Article].self, from: data)
    }
}

Escrevendo os testes da View

Os testes da View serão para validar os comportamentos da UI, as interações do usuário e sua comunicação com o Interactor.

import XCTest
@testable import CareerAppUIKit

class ArticlesDataStoreSpy: ArticlesDataStoreProtocol {
    var displayedArticles: [DisplayedArticle] = []
}

final class ArticlesViewControllerTests: XCTestCase {

    // MARK: - Test Components
    private var sut: ArticlesViewController?
    private var interactorSpy: ArticlesInteractorSpy?
    private var dataStoreSpy: ArticlesDataStoreSpy?
    private let testCollectionView = UICollectionView(
        frame: .zero,
        collectionViewLayout: UICollectionViewFlowLayout()
    )

    // MARK: - Test Lifecycle
    override func setUp() {
        super.setUp()
        do {
            try setupTestComponents()
        } catch {
            XCTFail("Falha no setup: \(error.localizedDescription)")
        }
    }

    override func tearDown() {
        cleanUpTestComponents()
        super.tearDown()
    }

    // MARK: - Test Cases

    func test_viewDidLoad_shouldFetchArticles() throws {
        // When
        _ = try XCTUnwrap(sut).view

        // Then
        XCTAssertEqual(interactorSpy?.fetchArticlesCallCount, 1)
    }

    func test_didSelectArticle_shouldNotifyInteractor() throws {
        // Given
        let testArticle = DisplayedArticle(
            id: 1, title: "Test", description: "Desc",
            publishDate: "Jan 1", imageUrl: nil,
            authorName: "Author", tags: "tag1,tag2"
        )
        dataStoreSpy?.displayedArticles = [testArticle]
        let indexPath = IndexPath(item: 0, section: 0)

        // When
        try XCTUnwrap(sut).collectionView(
            testCollectionView,
            didSelectItemAt: indexPath
        )

        // Then
        XCTAssertEqual(interactorSpy?.didSelectArticleCallCount, 1)
        XCTAssertEqual(try XCTUnwrap(interactorSpy?.lastSelectRequest?.id), 1)
    }

    func test_emptyState_shouldShowEmptyCell() throws {
        // Given
        dataStoreSpy?.displayedArticles = []
        let indexPath = IndexPath(item: 0, section: 0)

        // When
        let cell = try XCTUnwrap(sut).collectionView(
            testCollectionView,
            cellForItemAt: indexPath
        )

        // Then
        XCTAssertTrue(cell is EmptyArticlesCell)
    }

    func test_collectionView_shouldReturnCorrectNumberOfItems() throws {
        // Given
        let testArticles = [
            DisplayedArticle(id: 1, title: "Test 1", description: "Desc 1",
                             publishDate: "Jan 1", imageUrl: nil,
                             authorName: "Author 1", tags: "tag1"),
            DisplayedArticle(id: 2, title: "Test 2", description: "Desc 2",
                             publishDate: "Jan 2", imageUrl: nil,
                             authorName: "Author 2", tags: "tag2")
        ]
        dataStoreSpy?.displayedArticles = testArticles

        // When
        let numberOfItems = try XCTUnwrap(sut).collectionView(
            testCollectionView,
            numberOfItemsInSection: 0
        )

        // Then
        XCTAssertEqual(numberOfItems, testArticles.count)
    }

    // MARK: - Test Setup
    private func setupTestComponents() throws {
        interactorSpy = ArticlesInteractorSpy()
        dataStoreSpy = ArticlesDataStoreSpy()
        sut = ArticlesViewController(interactor: try XCTUnwrap(interactorSpy))
        sut?.dataStore = try XCTUnwrap(dataStoreSpy)
        sut?.loadViewIfNeeded()
    }

    private func cleanUpTestComponents() {
        sut = nil
        interactorSpy?.reset()
        interactorSpy = nil
        dataStoreSpy = nil
    }
}

A implementação de testes unitários em arquitetura VIP mostra toda sua potência quando:

Cada componente tem responsabilidades bem definidas
As dependências são invertidas via protocolos
Os testes focam em comportamentos, não implementações

Implementando Arquitetura VIP em um App iOS com Swift

Lys — Wed, 16 Apr 2025 00:59:30 +0000

Dentro da área de desenvolvimento iOS, é possível trabalhar com diferentes arquiteturas de projeto, mesmo algumas sendo mais utilizadas que outras, entender minimamente as diferenças pode te ajudar a entender melhor a arquitetura que você trabalha hoje.

Por que VIP, mesmo sendo mais verbosa que MVVM, por exemplo?

Separação clara de responsabilidades
Código mais testável
Ideal para lógicas de negócio complexas e projetos robustos
Mesmo que você não a use no dia a dia, entender VIP melhora seu MVVM

Vamos implementar um app que exibe uma tela de Artigos (fazendo uma chamada à API)

Nesse projeto, usarei view code, caso você seja novo nisso, aqui está um link de como remover o storyboard do projeto

Talvez pela versão do Xcode dele, mas o campo do passo 4 não apareceu pra mim, ao invés disso, tive que remover um outro campo no Info.plist que estava nomeando o storyboard, pode ser que aconteça com você também.

Modelando a resposta da API

Considerando o JSON retornado:

Nosso model em Swift será assim:

struct Article: Codable {
    let id: Int
    let title: String
    let description: String
    let readablePublishDate: String
    let url: String
    let coverImage: String?
    let tags: String
    let user: User

    enum CodingKeys: String, CodingKey {
        case id, title, description, url, tags, user
        case readablePublishDate = "readable_publish_date"
        case coverImage = "cover_image"
    }
}

struct User: Codable {
    let name: String
    let username: String
    let profileImage: String

    enum CodingKeys: String, CodingKey {
        case name, username
        case profileImage = "profile_image"
    }
}

Criando o Worker (Service)

É responsável por:

Fazer requests
Decodificar respostas
Comunicação com o Interactor

protocol ArticlesWorkerProtocol {
    func fetchArticles(completion: @escaping (Result<[Article], Error>) -> Void)
}

class ArticlesWorker: ArticlesWorkerProtocol {
    func fetchArticles(completion: @escaping (Result<[Article], Error>) -> Void) {
        guard let url = URL(string: "https://dev.to/api/articles") else {
            completion(.failure(NetworkError.invalidURL))
            return
        }

        URLSession.shared.dataTask(with: url) { data, response, error in

            if let error = error {
                completion(.failure(error))
                return
            }
            guard let data = data else {
                completion(.failure(NetworkError.noData))
                return
            }

            do {
                let articles = try JSONDecoder().decode([Article].self, from: data)
                completion(.success(articles))
            } catch {
                completion(.failure(error))
            }

        }.resume()
    }
}

enum NetworkError: Error {
    case invalidURL
    case noData
    case decodingError
}

Implementando o Interactor

Usado para gerenciar as regras de negócio e também pode ter um ou mais worker's.
Criaremos métodos que serão expostos à View Controller, aqui um será para carregar os dados dos artigos e o outro será fazer a navegação quando um artigo for selecionado.

protocol ArticlesBusinessLogic {
    func fetchArticles(request: Articles.FetchArticles.Request)
    func didSelectArticle(request: Articles.DidSelectArticle.Request)
}

Além do Worker, o Presenter também é uma dependência do Interactor, ele recebe os dados vindo do Worker e passa para o Presenter fazer a formatação, costumo injetar essas dependências via inicializador.

class ArticlesInteractor: ArticlesBusinessLogic {
    let presenter: ArticlesPresentationLogic
    let worker: ArticlesWorkerProtocol
    let router: ArticlesRoutingLogic

    init(presenter: ArticlesPresentationLogic, worker: ArticlesWorkerProtocol, router: ArticlesRoutingLogic) {
        self.presenter = presenter
        self.worker = worker
        self.router = router
    }

Ao implementar o método, chamamos o worker para fazer a request, e quando feita, é uma boa prática ter pelo menos dois métodos na presenter, um para tratar tanto o caso de sucesso e o outro para o caso de erro. Além disso, também implementei um caso de loading para uma experiência mais orgânica.

    func fetchArticles(request: Articles.FetchArticles.Request) {
        presenter.presentLoading(response: .init(isLoading: true))
        worker.fetchArticles { [weak self] result in
            switch result {
            case .success(let articles):
                self?.presenter.presentArticles(response: .init(articles: articles))
            case .failure(let error):
                self?.presenter.presentError(response: .init(errorMessage: error.localizedDescription))
            }
            self?.presenter.presentLoading(response: .init(isLoading: false))
        }
    }

Para a função de selecionar o artigo, chamamos o Router que será responsável por controlar a navegação desse fluxo. Não é incomum ver uma implementação de Router sendo feita na View Controller, mas na minha experiência, pensando que esses comportamentos também podem ser vistos como regra de negócio, faz sentido que o Interactor também seja responsável por isso.

func didSelectArticle(request: Articles.DidSelectArticle.Request) {
        router.routeToArticleDetail(id: request.id)
    }
}

Recebendo e formatando dados com Presenter

Para auxiliar na formatação, criaremos o arquivo Article.swift e então criamos um enum Articles, dentro dele teremos um FetchArticles que será responsável por manter os valores de Request, Response e ViewModel dentro. A ViewModel a Presenter usará para criar um objeto de acordo com os dados recebidos do Interactor.

Na primeira versão desse código, não havia tanto encapsulamento, os parâmetros estavam soltos, e então entendi que no VIP isso é importante para relembrar a separação de responsabilidade, ja que reforça os pontos:

Request: Dados brutos que vêm da View → Interactor.

Response: Dados processados pelo Interactor → Presenter.

ViewModel: Dados formatados pelo Presenter → View. Além disso, deixa uma organização mais clara e facilita na hora de escrever testes unitários.

enum Articles {
    struct FetchArticles {
        struct Request {}

        struct Response {
            let articles: [Article]
        }

        struct ViewModel {
            let displayedArticles: [DisplayedArticle]
        }
    }

    struct PresentError {
        struct Request {}

        struct Response {
            let errorMessage: String
        }
    }

    struct PresentLoading {
        struct Request {}

        struct Response {
            let isLoading: Bool
        }
    }

    struct DidSelectArticle {
        struct Request {
            let id: Int
        }

        struct Response {
            let articles: [Article]
        }
    }

    struct ArticleDetail {
        struct Request {
            let articleId: Int
        }
    }
}

struct DisplayedArticle {
    let id: Int
    let title: String
    let description: String
    let publishDate: String
    let imageUrl: String?
    let authorName: String
    let tags: String
}

Em ArticlesPresenter.swift, teremos o protocolo que foi utilizado pelo Interactor

protocol ArticlesPresentationLogic {
    func presentArticles(response: Articles.FetchArticles.Response)
    func presentError(response: Articles.PresentError.Response)
    func presentLoading(response: Articles.PresentLoading.Response)
}

Implementando a classe ArticlesPresenter, temos um atributo da View Controller, onde passaremos os dados ja formatados e prontos para serem exibidos

As referências do Presenter para a View são sempre fracas, para evitar ciclos de retenção.
Por ser unidirecional, a arquitetura VIP exige que a View (ViewController) mantenha uma referência forte ao Interactor, o Interactor mantenha uma referência forte ao Presenter, e se o Presenter mantiver uma referência forte de volta à View, cria-se um ciclo de retenção de memória que impede o ARC de desalocar os objetos corretamente.

ViewController (forte) → Interactor (forte) → Presenter (fraca) → ViewController

class ArticlesPresenter: ArticlesPresentationLogic {
    weak var viewController: ArticlesDisplayLogic?

    func presentLoading(response: Articles.PresentLoading.Response) {
        viewController?.displayLoading(viewModel: .init(isLoading: response.isLoading))
    }

    func presentArticles(response: Articles.FetchArticles.Response) {
        let displayedArticles = response.articles.map { article in
            DisplayedArticle(
                id: article.id,
                title: article.title,
                description: article.description,
                publishDate: article.readablePublishDate,
                imageUrl: article.coverImage,
                authorName: article.user.name,
                tags: article.tags
            )
        }
        let viewModel = Articles.FetchArticles.ViewModel(displayedArticles: displayedArticles)
        viewController?.displayArticles(viewModel: viewModel)
    }

    func presentError(response: Articles.PresentError.Response) {
        viewController?.displayError(viewModel: .init(errorMessage: response.errorMessage))
    }
}

View Controller

Na View Controller, teremos o interactor como dependência, e chamaremos na viewDidLoad o método que faz a request e retorna os dados para serem exibidos nas células.

import UIKit

protocol ArticlesDisplayLogic: AnyObject {
    func displayArticles(viewModel: Articles.FetchArticles.ViewModel)
    func displayError(viewModel: Articles.PresentError.Response)
    func displayLoading(viewModel: Articles.PresentLoading.Response)
    func displayArticleDetail(_ articleDetail: ArticleDetail)
}

class ArticlesViewController: UIViewController, ArticlesDisplayLogic {
    var interactor: ArticlesBusinessLogic?

    private lazy var collectionView: UICollectionView = {
        let layout = UICollectionViewFlowLayout()
        layout.scrollDirection = .horizontal
        layout.minimumLineSpacing = 0
        let collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
        collectionView.backgroundColor = .clear
        collectionView.isPagingEnabled = true
        collectionView.showsHorizontalScrollIndicator = false
        collectionView.translatesAutoresizingMaskIntoConstraints = false
        collectionView.delegate = self
        collectionView.dataSource = self
        collectionView.register(ArticleCell.self, forCellWithReuseIdentifier: ArticleCell.identifier)
        collectionView.register(EmptyArticlesCell.self, forCellWithReuseIdentifier: EmptyArticlesCell.identifier)
        return collectionView
    }()

    private lazy var activityIndicator: UIActivityIndicatorView = {
        let indicator = UIActivityIndicatorView(style: .large)
        indicator.center = view.center
        indicator.hidesWhenStopped = true
        indicator.translatesAutoresizingMaskIntoConstraints = false
        return indicator
    }()

    private lazy var pageControl: UIPageControl = {
        let pageControl = UIPageControl()
        pageControl.currentPageIndicatorTintColor = .persianBlue
        pageControl.pageIndicatorTintColor = .lightGray
        pageControl.translatesAutoresizingMaskIntoConstraints = false
        return pageControl
    }()

    private var displayedArticles: [DisplayedArticle] = []

    init(interactor: ArticlesBusinessLogic) {
        self.interactor = interactor
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        setupNavigationBar()
        setupViews()
        setupConstraints()
        loadArticles()
    }

    private func setupViews() {
        view.backgroundColor = .systemBackground
        view.addSubview(collectionView)
        view.addSubview(pageControl)
        view.addSubview(activityIndicator)
    }

    private func setupConstraints() {
        NSLayoutConstraint.activate([
            collectionView.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            collectionView.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
            collectionView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 16),
            collectionView.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -240),

            pageControl.bottomAnchor.constraint(equalTo: collectionView.bottomAnchor, constant: 16),
            pageControl.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            pageControl.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),

            activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            activityIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }

    private func setupNavigationBar() {
        title = HomeStrings.articlesTitle
        navigationController?.navigationBar.prefersLargeTitles = false

        let appearance = UINavigationBarAppearance()
        appearance.configureWithOpaqueBackground()
        appearance.backgroundColor = .systemBackground
        appearance.titleTextAttributes = [.foregroundColor: UIColor.persianBlue]

        let backButton = UIBarButtonItem(image: UIImage(systemName: "xmark"),
                                         style: .plain,
                                         target: self,
                                         action: #selector(backButtonTapped))
        backButton.tintColor = .persianBlue
        navigationItem.leftBarButtonItem = backButton
        navigationItem.backBarButtonItem = UIBarButtonItem(title: "", style: .plain, target: nil, action: nil)

        navigationController?.navigationBar.standardAppearance = appearance
        navigationController?.navigationBar.scrollEdgeAppearance = appearance
        navigationController?.navigationBar.compactAppearance = appearance
    }

    private func loadArticles() {
        let request = Articles.FetchArticles.Request()
        interactor?.fetchArticles(request: request)
    }

    func displayLoading(_ isLoading: Bool) {
        DispatchQueue.main.async { [weak self] in
            if isLoading {
                self?.activityIndicator.startAnimating()
                self?.collectionView.isHidden = true
                self?.pageControl.isHidden = true
                self?.collectionView.isHidden = true
            } else {
                self?.activityIndicator.stopAnimating()
                self?.collectionView.isHidden = false
                self?.pageControl.isHidden = false
            }
        }
    }

    func displayArticles(viewModel: Articles.FetchArticles.ViewModel) {
        DispatchQueue.main.async { [weak self] in
            self?.activityIndicator.stopAnimating()
            self?.displayedArticles = viewModel.displayedArticles
            self?.collectionView.reloadData()

            if viewModel.displayedArticles.isEmpty {
                self?.pageControl.isHidden = true
            } else {
                self?.pageControl.numberOfPages = viewModel.displayedArticles.count
                self?.pageControl.isHidden = false
                self?.collectionView.isHidden = false
            }
        }
    }

    func displayError(viewModel: Articles.PresentError.Response) {
        DispatchQueue.main.async { [weak self] in
            self?.activityIndicator.stopAnimating()
            let alert = UIAlertController(title: HomeStrings.errorMessage,
                                          message: viewModel.errorMessage,
                                          preferredStyle: .alert)
            alert.addAction(UIAlertAction(title: HomeStrings.errorButton, style: .default))
            self?.present(alert, animated: true)
        }
    }

    func displayLoading(viewModel: Articles.PresentLoading.Response) {
        DispatchQueue.main.async { [weak self] in
            if viewModel.isLoading {
                self?.activityIndicator.startAnimating()
                self?.collectionView.isHidden = true
                self?.pageControl.isHidden = true
            } else {
                self?.activityIndicator.stopAnimating()
                self?.collectionView.isHidden = false
                self?.pageControl.isHidden = false
            }
        }
    }

    func displayArticleDetail(_ articleDetail: ArticleDetail) {
        guard let id = articleDetail.id else { return }
        interactor?.didSelectArticle(request: .init(id: id))
    }

    @objc private func backButtonTapped() {
        navigationController?.popViewController(animated: true)
    }
}

extension ArticlesViewController: UICollectionViewDataSource {
    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return displayedArticles.isEmpty ? 1 : displayedArticles.count
    }

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        if displayedArticles.isEmpty {
                guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: EmptyArticlesCell.identifier, for: indexPath) as? EmptyArticlesCell else {
                    fatalError("Unable to dequeue EmptyArticlesCell")
                }
                cell.configureEmptyView()
                return cell
            }

        guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: ArticleCell.identifier, for: indexPath) as? ArticleCell else {
                fatalError("Unable to dequeue cell")
            }
        cell.configure(with: displayedArticles[indexPath.item])
        return cell
    }
}

extension ArticlesViewController: UICollectionViewDelegateFlowLayout {
    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
        return CGSize(width: collectionView.frame.width, height: collectionView.frame.height)
    }

    func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
        let pageNumber = round(scrollView.contentOffset.x / scrollView.frame.size.width)
        pageControl.currentPage = Int(pageNumber)
    }
}

extension ArticlesViewController: UICollectionViewDelegate {
    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        guard !displayedArticles.isEmpty else { return }
        let request = Articles.DidSelectArticle.Request(id: displayedArticles[indexPath.item].id)
        interactor?.didSelectArticle(request: request)
    }
}

Retornando a view controller com Factory

A Factory é responsável por centralizar a criação de objetos complexos, como ViewControllers no VIP. Neste caso, ela orquestra a construção de todas as camadas da arquitetura (View, Interactor, Presenter e Router), injetando as dependências necessárias e garantindo que todas as referências sejam corretamente configuradas.

enum ArticlesFactory {
    static func build() -> ArticlesViewController {
        let worker = ArticlesWorker()
        let presenter = ArticlesPresenter()
        let router = ArticlesRouter()
        let interactor = ArticlesInteractor(presenter: presenter, worker: worker, router: router)
        let viewController = ArticlesViewController(interactor: interactor)
        router.viewController = viewController
        presenter.viewController = viewController
        return viewController
    }
}

Criando uma navegação com Router

O Router é o componente responsável por toda a lógica de navegação e coordenação de fluxos entre cenas (ViewControllers). Na arquitetura VIP, ele:

Centraliza a navegação: Remove a responsabilidade de transição de telas da ViewController e do Interactor
Gerencia dependências: Pode instanciar e configurar novas cenas com suas próprias factories
Implementa desacoplamento: Permite alterar fluxos de navegação sem impactar outras camadas

Interactor → Router → Nova ViewController
(regra de negócio) (ação de navegação)

import Foundation

protocol ArticlesRoutingLogic {
    func routeToArticleDetail(id: Int)
}

protocol ArticlesDataStore {}


class ArticlesRouter: NSObject, ArticlesRoutingLogic, ArticlesDataStore {
    weak var viewController: ArticlesViewController?

    func routeToArticleDetail(id: Int) {
        let articleDetailViewController = ArticleDetailFactory.build(id: id)
        viewController?.navigationController?.pushViewController(articleDetailViewController, animated: true)
    }
}

O código da celula da Collection View, da tela de detalhe e de login pode ser encontrado no meu github

Introdução ao String Catalog: Melhore a localização de strings no iOS 16 com Xcode 14

Lys — Thu, 17 Oct 2024 21:32:04 +0000

O String Catalog foi introduzido no Xcode 14, que foi lançado junto com o iOS 16. Projetado para simplificar e modernizar a forma como os desenvolvedores lidam com strings localizadas em seus projetos, ele oferece uma interface mais intuitiva e integrada em comparação aos métodos tradicionais.

Ao clicar em criar um novo arquivo, String Catalog é mostrado como opção

Ao selecionar e escolher um nome, no canto esquerdo, é mostrado os idiomas suportados, com um botão para adicionar mais opções, onde é possível adicionar português também.

Para exemplificar com código, o título dos componentes dessa Tab Bar virá do arquivo criado.

Se pensarmos que a tela está sendo criada assim

import SwiftUI

struct ContentView: View {
    var body: some View {
        TabView {
            BlogView()
                .tabItem {
                    Label("Blog",
                          systemImage: "doc.text")
                }

            InterviewGenerateQuestionsView()
                .tabItem {
                    Label("Entrevistas", systemImage: "mic.fill")
                }

            ResumeView()
                .tabItem {
                    Label("Currículo", systemImage: "book.fill")
                }

            MenuView()
                .tabItem {
                    Label("Menu", systemImage: "line.horizontal.3")
                }
        }
    }
}

Será necessária a criação de quatro propriedades que vou nomear com o sufixo title.

Caso o arquivo criado tenha o nome Localizable.strings, a string poderá ser acessada dessa forma

String(localized: "blogTitle")

No caso de outro nome, será necessário acessar uma tabela diferente

private static func localized(_ key: String) -> String {
        return NSLocalizedString(key, 
                                 tableName: "HomeStrings", 
                                 bundle: .main, 
                                 value: "", 
                                 comment: "")
}

Pra não sobrecarregar a função de responsabilidades e repetir código, é interessante criar um arquivo para cuidar desse acesso

import Foundation

class HomeStrings {
    static let blogTitle = localized("blogTitle")
    static let interviewTitle = localized("interviewTitle")
    static let menuTitle = localized("menuTitle")
    static let resumeTitle = localized("resumeTitle")

    private static func localized(_ key: String) -> String {
        return NSLocalizedString(key, 
                                 tableName: "HomeStrings", 
                                 bundle: .main, 
                                 value: "", 
                                 comment: "")
    }
}

Então a ContentView ficará assim

import SwiftUI

struct ContentView: View {
    var body: some View {
        TabView {
            BlogView()
                .tabItem {
                    Label(HomeStrings.blogTitle,
                          systemImage: "doc.text")
                }

            InterviewGenerateQuestionsView()
                .tabItem {
                    Label(HomeStrings.interviewTitle,
                          systemImage: "mic.fill")
                }

            ResumeView()
                .tabItem {
                    Label(HomeStrings.resumeTitle,
                          systemImage: "book.fill")
                }

            MenuView()
                .tabItem {
                    Label(HomeStrings.menuTitle, 
                          systemImage: "line.horizontal.3")
                }
        }
    }
}

Protegendo credenciais em automatização de builds no Fastlane com Variáveis de Ambiente

Lys — Wed, 16 Oct 2024 19:23:15 +0000

Permitindo armazenar informações sensíveis, como API keys, tokens de autenticação e credenciais, de forma segura e fora do código-fonte, usar variáveis de ambiente reduz o risco de exposição desses dados ao fazer o versionamento do código.

Pensando na configuração de uma pipeline em Fastlane, para automatizar versões de teste, nosso arquivo Fastfile pode ser muito parecido com

default_platform(:ios)

platform :ios do
  desc "Builds the app and pushes to TestFlight"
  lane :beta do
    increment_build_number(
      xcodeproj: "FastlaneIOSTest.xcodeproj"
    )

    gym(
      scheme: "FastlaneIOSTest",        
      export_method: "app-store",                  
      clean: true,                                 
      export_options: {
        provisioningProfiles: {
          "br.com.lys.FastlaneIOSTest" => "iOS Distribution Profile -
 Fastlane Test"
        }
      }
    )

    pilot(
      skip_waiting_for_build_processing: true,
      notify_external_testers: true,           
      api_key: app_store_connect_api_key(
        key_id: "<SEU_KEY_ID>",
        issuer_id: "<SEU_ISSUER_ID>",
        key_filepath: "/caminho/para/sua/chave.p8"
      )
    )
  end
end

Há valores que podemos adicioná-los em variáveis de ambiente, alguns para evitar informações hardcoded, facilitar manutenção e configuração para diferentes ambientes, mas também outros para não deixar exposto no código quando publicado.

As propriedades que achei que fariam sentido estar em uma variável de ambiente foram:

Nome do projeto Xcode (xcodeproj).
Nome do scheme do projeto (scheme).
Método de exportação (export_method).
Bundle Identifier do app (primeira parte do provisioningProfiles).
Nome do perfil de provisionamento (segunda parte do provisioningProfiles).
ID da chave da App Store Connect API (key_id).
ID do emissor da App Store Connect API (issuer_id).
Caminho para o arquivo da chave da App Store Connect API (key_filepath).

Há como criar variáveis de ambiente apenas com um comando no terminal

export VARIABLE_NAME="Your Value Here"

Mas desse jeito não é persistido em novas sessões de terminal, você precisa adicioná-la aos arquivos de configuração do shell, como .bashrc, .bash_profile ou .zshrc, para saber o shell que está em uso

echo $SHELL

Independente do que foi retornado, nano será o comando que usaremos para abrir, editar e adicionar nossas variáveis de ambiente, como abaixo

nano ~/.zshrc

Substituia o ~/.zshrc por ~/.bashrc ou ~/.bash_profile, caso seu tipo de shell não seja o zsh

Ao abrir, adicione o texto que terá os export's das suas variáveis de ambiente

export XCODEPROJ_NAME="YourNameApp.xcodeproj"
export SCHEME_NAME="YourSchemeName"
export EXPORT_METHOD="app-store"
export BUNDLE_IDENTIFIER="br.com.YourBundleIdentifier"
export PROVISIONING_PROFILE_NAME="Your Provisioning Profile - NameApp"
export APP_STORE_CONNECT_API_KEY_ID="<YOUR_KEY_ID>"
export APP_STORE_CONNECT_API_ISSUER_ID="<YOUR_ISSUER_ID>"
export APP_STORE_CONNECT_API_KEY_FILE_PATH="/way/for/your/key.p8"

Após adicionado, no Nano, use Ctrl + O para salvar e Ctrl + X para sair.

Para aplicar as mudanças sem precisar reabrir o terminal, rode o comando source com o path correspondente, por exemplo

source ~/.zshrc

Acessaremos os valores adicionados com um ENV['']

ENV['YOUR_VARIABLE_NAME']

Então, atualizando os valores no Fastfile, ficará assim

default_platform(:ios)

platform :ios do
  desc "Builds the app and pushes to TestFlight"
  lane :beta do
    increment_build_number(
      xcodeproj: ENV['XCODEPROJ_NAME']
    )

    gym(
      scheme: ENV['SCHEME_NAME'],        
      export_method: ENV['EXPORT_METHOD'],                  
      clean: true,                                 
      export_options: {
        provisioningProfiles: {
          ENV['BUNDLE_IDENTIFIER'] => ENV['PROVISIONING_PROFILE_NAME']
        }
      }
    )

    pilot(
      skip_waiting_for_build_processing: true,
      notify_external_testers: true,           
      api_key: app_store_connect_api_key(
        key_id: ENV['APP_STORE_CONNECT_API_KEY_ID'],
        issuer_id: ENV['APP_STORE_CONNECT_API_ISSUER_ID'],
        key_filepath: ENV['APP_STORE_CONNECT_API_KEY_FILE_PATH']
      )
    )
  end
end

Automatizando Testes e Distribuição de Apps iOS com Fastlane e GitHub Actions

Lys — Mon, 14 Oct 2024 20:46:27 +0000

Numa rotina de trabalho, é normal que algumas tarefas sejam automatizadas, como executar os testes quando um pull request é aberto, o processo de publicação para a app store, ou até de distribuição interna para beta testers (Test Flight, por exemplo)

Há algumas ferramentas para fazer esse processo, aqui usaremos o Fastlane, que vai automatizar o processo de distribuição com o TestFlight, e o Github Actions, que também usaremos para rodar os testes e um lint quando um pull request é aberto.

Pra dar tudo certo é importante que você tenha

Xcode instalado na sua máquina local.
Um repostório no Github com seu projeto iOS.
Uma conta de desenvolvedor da Apple (Apple Developer account) e seu app preparado para gerar uma versão de teste.

Para instalar o Fastlane, há duas formas, via RubyGems, ou, se quiser evitar o uso do sudo ou o Ruby padrão do sistema, pode usar o Homebrew

Via RubyGems

sudo gem install fastlane -NV

Via Homebrew

brew install fastlane

Depois de instalado, acesse seu diretório no terminal

cd your-ios-repo

E inicialize o fastlane

fastlane init

Esse comando criará dois arquivos importantes, AppFile e Fastfile

Uso o VSCode para abrir e editar os próximos arquivos:

Mas uma dica para ver as pastas ocultas no finder é utilizar o comando Command + Shift + .

Appfile

Simplifica o processo de configurar algumas variáveis essenciais que o Fastlane precisa saber, especialmente em casos de publicação e distribuição.

app_identifier "com.example.myapp" # The bundle identifier of your app
apple_id "example@apple.com" # Your Apple Developer Portal username

Fastfile

É o arquivo que permite automatizar várias tarefas repetitivas em um projeto

Criaremos uma lane beta

Uma lane é uma função no Fastlane que define um conjunto de tarefas ou ações a serem executadas. Você pode pensar em uma lane como um "workflow" ou "pipeline" de ações.
Cada lane tem um nome, e você pode chamar essas lanes pelo nome no terminal (ex: fastlane ios beta).

default_platform(:ios)

platform :ios do
  desc "Builds the app and pushes to TestFlight"
  lane :beta do
    increment_build_number(
      xcodeproj: "ExampleApp.xcodeproj"
    )

A ação increment_build_number incrementa automaticamente o número do build, garantindo que cada nova versão tenha um número de build único.

    gym(
      scheme: "ExampleApp",
      export_method: "app-store",        
      clean: true,                                
      export_options: {
        provisioningProfiles: {
          "com.example.app" => "example_profile"
        }
      }
    )

A ação gym compila o projeto, gera o arquivo .ipa, e prepara o app para distribuição.
Também cuida da configuração do esquema correto, do método de exportação, e da limpeza do projeto.

    pilot(
      skip_waiting_for_build_processing: true,
      notify_external_testers: true,           
      api_key: app_store_connect_api_key(
        key_id: ENV['APP_STORE_CONNECT_API_KEY_ID'],
        issuer_id: ENV['APP_STORE_CONNECT_API_ISSUER_ID'],
        key_filepath: ENV['APP_STORE_CONNECT_API_KEY_FILE_PATH']
      )
    )
  end
end

A ação pilot faz o upload do arquivo .ipa diretamente para o TestFlight, sem precisar interagir com o Xcode. Ele pode pular o tempo de espera do processamento do build e notificar automaticamente os testadores externos.

Da primeira vez que configurei, não tinha adicionado a api_key e consegui normalmente, mas a partir da segunda vez, um erro de autenticação começou a aparecer no terminal, e era isso que estava faltando!

Esse ENV[''] representa uma variável de ambiente, você pode entender como criar aqui ou apenas deixar os valores expostos no código.

Depois de adicionar esses três passos, rode no terminal

fastlane beta

Se der tudo certo, o final do retorno de sucesso deve se parecer com isso:

Para mais informações, e saber quais tarefas mais o fastlane automatiza, você pode consultar a documentação.

Usando o Github Actions

Na raiz do projeto, crie uma pasta com o nome .github e dentro dela, uma outra chamada workflows.

mkdir -p .github/workflows

Como criaremos uma pipeline para quando um pull request for aberto, criaremos um arquivo com o nome on-pull-request.yml

name: Run CI
on:
  pull_request

name

Define o nome do workflow. Ele é exibido no GitHub Actions quando o workflow é executado.

Especifica os eventos que disparam a execução do workflow.

Aqui o workflow será acionado quando um pull request for aberto ou atualizado. Você pode especificar outros eventos, como push, schedule ou release, dependendo da necessidade.

jobs:
  check_code:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v3

      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: 3.0

      - name: Install Dependencies
        run: bundle install

      - name: Run SwiftLint
        uses: norio-nomura/action-swiftlint@3.2.1

  unit_test:
    runs-on: macos-14
    steps:
      - name: Setup xcode version
        uses: maxim-lobanov/setup-xcode@v1
        with:
          xcode-version: "15.0"

      - name: Checkout Repository
        uses: actions/checkout@v3

      - name: Setup Ruby
        uses: ruby/setup-ruby@v1
        with:
          ruby-version: 3.0

      - name: Install Dependencies
        run: bundle install

      - name: Unit Testing
        run: bundle exec fastlane tests

jobs

Cada job dentro do workflow representa um conjunto de tarefas que serão executadas, de forma paralela ou dependendo uma das outras, a depender de como estão configuradas.

Um job é composto de várias steps, que podem incluir ações predefinidas do GitHub, comandos shell (run), ou a execução de scripts personalizados.

runs-on

Especifica o ambiente de execução (o sistema operacional) no qual o job será executado. Além do Ubuntu, também é possível especificar outros sistemas operacionais, como macos-latest ou windows-latest.

steps

Define as etapas que serão executadas dentro de cada job. Cada etapa é uma ação individual ou comando que faz parte do job.

uses

Refere-se a uma ação existente disponível no GitHub Marketplace ou uma ação definida localmente que você deseja executar em um step.

Aqui, está sendo usada uma ação predefinida do GitHub chamada checkout, que faz o checkout do repositório. A versão especificada é v3. Muitas vezes, essas ações são contribuições da comunidade ou do próprio GitHub.

O comando run executa diretamente o que for especificado no terminal do ambiente. No exemplo acima, ele roda o comando gem install fastlane para instalar o Fastlane via RubyGems.

with

Passa argumentos ou opções para uma ação usada em um step.

Ao abrir uma branch, commitar, dar push e abrir um pull request, os check's do seu pull request deve se parecer com isso:

Para mais informações e eventos que disparam a execução do workflow, consulte a documentação de eventos do Github Actions

Integrando SwiftUI em UIKit e implementando View com Coordinator

Lys — Fri, 16 Aug 2024 01:53:33 +0000

É a primeira vez que trabalho em um projeto que está usando SwiftUI para implementar novos fluxos, mas como os fluxos são majoritariamente UIKit, é preciso fazer uma pequena integração com na hora de exibir um fluxo em SwiftUI.

Para simular um fluxo de navegação entre telas, vamos pensar que a tela com as opções é o nosso fluxo inicial feito em UIKit (programaticamente/view code) e a tela de imóveis agendados que será exibida, é a nossa view em SwiftUI.

Para um Coordinator inicial, pensaremos em algo como

import UIKit

protocol PropertyCoordinatorProtocol: AnyObject {
    func navigateToSchedule()
}

class PropertyCoordinator: PropertyCoordinatorProtocol {
    private var navigationController: UINavigationController
    private let viewModel: PropertyViewModel

    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
        self.viewModel = PropertyViewModel()
        viewModel.coordinator = self
    }

    func start() {
        let viewController = PropertyViewController(viewModel: viewModel)
        navigationController.pushViewController(viewController, animated: false)
    }
}

Para exibir a view, criaremos um método navigateToSchedule que fará a apresentação a partir da nossa Navigation Controller.

func navigateToSchedule() {
    let scheduleViewController = ScheduleViewController()
    navigationController.present(scheduleViewController, animated: true)
}

Ao criar ScheduleViewController, a instancia de UIHostingController é o que permite incorporar uma view SwiftUI dentro de um layout UIKit.

private lazy var mainView: UIView = {
    let view = ScheduleView()
    let controller = UIHostingController(rootView: view)
    addChild(controller) 
    controller.view.translatesAutoresizingMaskIntoConstraints = false
    return controller.view
}()

O addChild(controller) adiciona o UIHostingController como filho do controlador atual, o que é necessário para gerenciar corretamente os ciclos de vida das views dentro de um view controller pai.

A view controller exibida será assim

import UIKit
import SwiftUI

final public class ScheduleViewController: UIViewController {
    private lazy var mainView: UIView = {
        let view = ScheduleView()
        let controller = UIHostingController(rootView: view)
        addChild(controller) 
        controller.view.translatesAutoresizingMaskIntoConstraints = false
        return controller.view
    }()

    public override func loadView() {
        self.view = UIView()
        view.backgroundColor = .clear
        setupHierarchy()
        setupConstraints()
    }

    func setupHierarchy() {
        view.addSubview(mainView)
    }

    func setupConstraints() {
        guard let superview = self.mainView.superview else { return }

        NSLayoutConstraint.activate([
            mainView.topAnchor.constraint(equalTo: superview.safeAreaLayoutGuide.topAnchor),
            mainView.bottomAnchor.constraint(equalTo: superview.safeAreaLayoutGuide.bottomAnchor),
            mainView.trailingAnchor.constraint(equalTo: superview.safeAreaLayoutGuide.trailingAnchor),
            mainView.leadingAnchor.constraint(equalTo: superview.safeAreaLayoutGuide.leadingAnchor)
        ])
    }

    public override func viewDidLoad() {
        super.viewDidLoad()
    }

    public override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        mainView.frame = view.bounds 
    }
}

E na View Controller principal, teremos um método que será chamado quando o botão for clicado

@objc func goToScheduleView() {
    viewModel.showScheduleView()
}

E a view model terá um método que chamará o Coordinator

func showScheduleView() {
    coordinator?.navigateToSchedule()
}

Código no github

Modularização no iOS: Estruturando Projetos com Swift Package Manager

Lys — Mon, 12 Aug 2024 22:33:48 +0000

Ajudando em reutilização, escalabilidade e gerenciamento de dependências, é comum que projetos mobile sejam modularizados.
Pense em um app financeiro, como exemplo esse abaixo achado numa plataforma chamada dribbble

Pensando em times trabalhando em diferentes partes do app, modularizar ajudaria cada equipe a cuidar de um módulo específico. Aqui poderíamos ter um módulo para "transfer", "invest" e "budget", e eles seriam instanciados em um projeto principal. Também pensando em reutilização de código, é comum que haja um módulo para a parte de design system e componentes que serão utilizados. Ajudam na testabilidade, padronização do projeto e também evitará a repetição de código, já que cada módulo do projeto poderá ter o módulo de componentes.

Uma possível estrutura:

BankApp seria nosso projeto principal, adicionaremos dependências nele.
Invest, Transfer e Budget serão dependências de BankApp.
Components será uma dependência de Invest, Transfer e Budget.
Firebase* e Alamofire* também serão dependências de BankApp.

*Como são libs mais conhecidas, quis exemplificar em que "nível" ela pode estar quando for usada no app principal.

E também não é uma regra, já que você pode criar módulos que tenham o Alamofire, por exemplo, e, nesse caso, o app principal não precisaria conhecê-lo.

O Cocoapods e o Carthage são outras formas de trabalhar com gerenciamento de dependencias e distribuição de bibliotecas em um projeto iOS, mas pra esse projeto, usaremos o Swift Package Manager

Uma curiosidade é que ele foi anunciado pela primeira vez em 2015, é open source e está disponível no repositório do Swift no GitHub. Trabalhar com ele é bom por essa experiência mais nativa e integrada ao xcode.

Criando um projeto

Abra seu xcode

File > New > Project

Repita esse processo, agora criando um projeto para o que será nosso módulo, o nome do projeto pode ser Components

Quando criado, acessei a pasta onde estava meu projeto

cd Components

Primeiros comandos para instanciar o spm no seu diretório

Pra inicializar um Package.swift e /Sources no diretório atual.

swift package init --type executable

Pra buscar e resolver todas as dependências especificadas no arquivo Package.swift do projeto.

swift package resolve

Pra compilar o código-fonte do pacote e todas as suas dependências.

swift build

Entendendo o package.swift

O nome do pacote, que deve ser único dentro do contexto de onde ele será usado.

import PackageDescription

let package = Package(
    name: "components-views",

Especifica as plataformas e versões mínimas suportadas pelo pacote.

platforms: [
        .macOS(.v10_15),
        .iOS(.v13),
        .tvOS(.v13),
        .watchOS(.v6)
    ],

Produtos são as bibliotecas ou executáveis que o pacote produz e pode compartilhar com outros pacotes. Nesse caso, quando nosso projeto utilizar esse pacote, poderá importar Components pra acessar o que há no target Components, isso é útil porque podemos separar os targets que serão exibidos, e o projeto que utilizar esse módulo, poderá escolher qual library ele irá importar.

products: [
        .library(
            name: "Components",
            targets: ["Components"]),
    ],

Permite especificar dependências externas, como outros pacotes Swift disponíveis em repositórios Git.

dependencies: [
        .package(url: "https://github.com/pointfreeco/swift-snapshot-testing", from: "1.10.0")
    ],

Targets são as unidades de construção do pacote. Podem ser módulos, bibliotecas ou executáveis.

    targets: [
        .target(
            name: "Components",
            dependencies: []),
        .testTarget(
            name: "ComponentsTests",
            dependencies: ["Components"]),
        .testTarget(
            name: "ComponentsUITests",
            dependencies: ["Components"]),
    ]
)

Para conseguirmos visualizar pelo menos um ínicio de tela, crie em Components uma view chamada TransactView

import SwiftUI

public struct TransactView: View {

    public init() { }

    public var body: some View {
        VStack {
            Text("Transact")
                .font(.headline)

            HStack(spacing: 16) {
                createImageView(with: "Buy", imageName: "envelope")
                createImageView(with: "Sell", imageName: "scissors")
                createImageView(with: "Deposit", imageName: "arrow.down")
                createImageView(with: "Withdraw", imageName: "arrow.up")
                createImageView(with: "More", imageName: "plus")
            }
            .padding()
        }
        .padding()
    }

    func createImageView(with text: String, imageName: String) -> some View {
        VStack {
            Image(systemName: imageName)
                .padding()
                .background(Circle().fill(Color.gray.opacity(0.2)))
            Text(text)
                .font(.caption)
                .multilineTextAlignment(.center)
        }
        .frame(width: 60)
    }
}

Agora, crie um repositório público no github e publique seu diretório criado, vamos deixar ele visível para adicionarmos no app principal.

Depois de criado, abra o projeto do app principal e vá até a raiz do projeto.

Clique em package dependencies, e depois, no botão + mais abaixo.

Coloque o link do seu repositório e veja que você não precisa utilizar ele só da main, há outras opções também.

Clique em Add Package, e quando for adicionado com sucesso, a estrutura do Components deve se parecer com essa imagem.

Agora, ja conseguimos importar Components

Deixaremos nossa ContentView assim

import SwiftUI
import Components

struct ContentView: View {
    var body: some View {
        TransactView()
    }
}

#Preview {
    ContentView()
}

E ao clicar em run, quando o simulador for aberto, a tela deve se parecer com esse componente

Adicionando módulos localmente

Sem a necessidade de criar repositórios, no xcode há a possibilidade de adicionar um package localmente.

No projeto, vá até

File > Add Package Dependencies

Clique em Add Local e depois de escolher o diretório do seu módulo, a sua tela deve parecer isso.

Certifique-se de não estar com o projeto do seu módulo aberto numa outra aba do xcode, isso pode interferir no build e seu módulo não será carregado.

5 coisas que deixaram meu estágio mais produtivo

Lys — Thu, 15 Jul 2021 14:23:18 +0000

Estar em um estágio é sempre um mix de emoções. Estou no meu terceiro e posso dizer que foram experiências muito diferentes, mas a síndrome do impostor, a insegurança e o medo de não dar conta sempre estiveram presentes em todos, então nesse artigo eu quero mostrar um pouco das coisas que me ajudaram e continuam me ajudando a lidar com essa jornada.

Baseado no meu primeiro artigo, com dicas para te ajudar a conseguir um estágio, fiz esse aqui para ajudar as pessoas que, como eu, já estão estagiando e querem aproveitar ao máximo essa fase que pode ser maravilhosa e, ao mesmo tempo, angustiante.

1 - Programação pareada

Há quem ame, há quem odeie, mas com certeza a programação pareada está sendo muito boa pra mim nesse estágio em que estou atualmente. Nunca havia tido essa experiência, mas parear com alguém que tem mais experiência que você e poder aprender os conceitos enquanto prática está sendo enriquecedor.

Além de tudo, como estamos trabalhando remotamente, a programação pareada dá uma sensação de suporte maior e, para um começo de carreira, o apoio, estar mais presente para entender a dificuldade da pessoa, pode ser um grande aliado para fazer você evoluir melhor e mais rápido.

Se você não trabalha com programação, substitua essa parte por fazer tarefas da sua área com o apoio de alguém que trabalha com você, compartilhando ideias e conhecimentos durante o processo.

2 - Estudar um pouco por dia e após os estudos comentar sobre o que estudou

Sabemos que estudar vai ser sempre essencial, independentemente da área, mas uma coisa que anda me ajudando muito é pegar uma hora por dia do estágio para estudar. O que você irá aprender depende muito de onde você quer chegar, é legal falar com o seu líder ou com quem te acompanha sobre um possível guia de estudos para te ajudar, eu, por exemplo, como faço os cursos da Alura, tento manter a frequência de fazer de um a dois capítulos do curso por dia.

Se você não puder pegar um horário do estágio, estude um horário antes, ou depois, o legal de ter horários pré definidos é para deixar sua rotina organizada e ser mais difícil de "sabotar" os estudos, já que você deixou o horário fixo na sua agenda.

No dia seguinte, eu comento um pouco com meu líder sobre o que estudei, isso é bem legal, porque nós podemos comentar sobre o que foi trabalhado, consigo tirar algumas dúvidas e ele pode até me mostrar algo que aprendi que é usado no nosso dia a dia no trabalho.

3 - Conversar com meu líder sobre "quem eu quero ser quando crescer"

Uma vez por mês eu tenho uma conversa (chamamos de 1:1) com meu líder sobre meus planos futuros. Pra mim, alinhar suas expectativas com a do lugar que você está trabalhando é essencial, te dá mais motivação sobre quem você quer ser e aonde você quer chegar. Eu sei que são coisas muito complicadas de se saber no início, e tá tudo bem mudar de ideia depois, mas se você já tiver uma ideia, ter conversas sobre isso podem te ajudar muito a se organizar melhor profissionalmente e alcançar seus objetivos com mais facilidade.

Seu(a) líder, também sabendo dos seus objetivos, pode adaptar melhor uma rotina de trabalho, te ajudando a alcançar suas metas no futuro. Eu, por exemplo, quero ser uma colaboradora do blog da Alura no futuro e, como ajuda, meu líder revisa as coisas que eu escrevo para ajudar a me preparar quando isso for acontecer.

4 - A vida não é só trabalho, descanse

No meu primeiro estágio eu me descuidei muito nisso e não recomendo: descansar é essencial para que possamos ter um dia de trabalho melhor e mais produtivo. Eu sei que a síndrome do impostor ataca e a gente parece estar sempre atrasado e que se não estudarmos o tempo todo não vamos evoluir, mas isso não é verdade. Se só ocuparmos nossa mente com trabalho e estudos o tempo todo, a longo prazo isso não vai ser saudável (leia sobre burnout).

Tenha hobbies que te façam bem: cozinhar, tocar algum instrumento, assistir séries/filmes, fazer exercícios físicos ou o que você quiser, mas sempre lembre da sua saúde mental e, se possível, faça terapia: acompanhamento psicológico é sempre bom, principalmente em começo de carreira, em que estamos nos descobrindo e sempre ansiosos com o que vem pela frente.

5 - Ter contato com outros estagiários

Sei que às vezes no início somos muito tímidos, conversar com outras pessoas é um desafio e tanto, mas ter essa experiência me ajudou muito por todos os lugares que passei.

Já passei por duas situações diferentes: em uma, eu trabalhava com outros estagiários de tecnologia e às vezes pegávamos tarefas juntos, em outra, eu era a única estagiária de tecnologia do meu time. Se a sua situação se parecer com a primeira, troque experiências, conhecimentos com seus colegas, discuta sobre suas tarefas, ter alguém na mesma posição que você pode ser muito confortante e te motivar a crescer junto com a pessoa que você trabalha. Se a sua situação se parecer com a segunda, veja se tem algum grupo de estagiários onde você trabalha. Em um lugar que trabalhei tínhamos um grupo no slack só de estagiários, às vezes tinha algum happy hour online para podermos conversar, e essa proximidade com as pessoas do seu trabalho pode ser um grande motivador, já que estar em um ambiente colaborativo e acolhedor faz o trabalho ficar mais leve e produtivo (leia um pouco sobre "Ambiente de trabalho e produtividade").

Dito isso, não se cobre para evoluir extremamente rápido no seu estágio, vá no seu tempo, dê o seu melhor que a evolução vem aos poucos, aproveite essa fase e vai dar tudo certo!

Obrigada por ler até aqui, qualquer dúvida que tiver, pode me chamar em alguma das minhas redes sociais! <3

Resolvendo erro de build no projeto de arquitetura Intel para arquitetura Apple Silicon (M1)

Lys — Wed, 09 Jun 2021 21:29:41 +0000

Resolvendo "error: module was created for incompatible target arm64-apple-ios9.0"

Meu primeiro dia de trabalho foi bem interessante, ainda não tínhamos testado o projeto em um computador Mac com Apple Silicon (M1), com isso, tivemos um erro subindo o projeto.

Uma informação que nos ajudará a entender o problema é que, com essa nova plataforma teremos o macOS baseado em arm64, seus simuladores também serão executados em arm64, ao contrário da atual arquitetura x86/64 baseada na Intel.

O projeto do trabalho, que havia sido criado com arquitetura x64, tem algumas dependências que não suportam a nova arquitetura dos MacBooks, então foi preciso mexer em uma configuração.

Como podemos ver abaixo, foi assim que ficou o Build Settings após fazer as alterações, fomos em Excluded Architectures, depois em Debug e Release adicionamos a arquitetura que queremos excluir quando subirmos o projeto no simulador (Any iOS Simulator).

Nesse vídeo eu mostro como configurei, porém em outro projeto que estava mexendo.

https://www.youtube.com/watch?v=l3Cmcyqbvxg

Lembrando que eu não rodo o projeto em um celular, e sim no simulador do Xcode mesmo.

Fazendo isso, pode acontecer com que o build fique mais lento, porque ele praticamente faz a transcrição do código com a arquitetura x64 (Intel) para a arm64 (Apple Silicon), mas isso resolveu o problema, já que iremos evitar as dependências que não suportam essa nova arquitetura de nos impedir de subir o projeto.

O M1 consegue executar códigos feitos na arquitetura Intel com o Rosetta 2. Um link interessante sobre isso aqui

E um agradecimento final ao meu líder que conseguiu me explicar isso pacientemente e me ajudar a solucionar o problema. Obrigada, Felipe!

COMO CONSEGUI MEU PRIMEIRO ESTÁGIO E DICAS PARA LHE AJUDAR A CONSEGUIR O SEU

Lys — Tue, 29 Sep 2020 23:05:54 +0000

Olá! Atualmente estou terminando o primeiro ano do curso de Sistemas de Informação e decidi escrever esse meu primeiro artigo para contar um pouco da minha vivência na procura por estágio, como consegui meu trabalho atual (estagiária em desenvolvimento back-end), além de compartilhar algumas das dicas que eu gostaria de ter recebido bem como as que recebi, as quais acabaram sendo muito úteis para eu chegar onde estou hoje.

Se cadastre em plataformas que oferecem estágio

Se cadastre em plataformas tais como Nube [https://www.nube.com.br], Ciee [https://portal.ciee.org.br], Vagas [https://www.vagas.com.br], Companhia de Estágio [https://www.ciadeestagios.com.br], Infojobs [https://www.infojobs.com.br], Linkedin [https://www.linkedin.com], dentre outras.

O primeiro passo é pesquisar a respeito de plataformas que sejam comuns onde você mora e manter seu currículo sempre atualizado em tais plataformas. Grande parte das entrevistas que consegui foram a partir delas, a menor parte foram em sua maioria a partir de grupos de tecnologia no Facebook e indicação de amigos.

Mantenha sempre seu currículo atualizado, eu gosto de colocar cursos que conclui, link de portfólio, trabalhos voluntários/comunidades que faço parte, uma descrição básica com quem eu sou, o que sei, o que estou procurando, e minhas competências.

Eu consegui minha vaga pelo Nube, foi uma contratação muito tranquila e rápida, me chamaram para uma entrevista e pegaram meu currículo de lá, fui aprovada na mesma semana e comecei a trabalhar aproximadamente duas semanas depois.

Entenda o mercado, suas possibilidades de trabalho e saiba alinhar expectativas

Na hora de pesquisar a respeito de estágio é importante saber no que você gostaria de focar ou aprender em suas primeiras experiências de mercado. Claro que o período de estágio costuma ser de descoberta, entretanto, a partir desses conhecimentos você conseguirá se comunicar melhor com o recrutador e também otimizar seus estudos.

Para entender melhor sobre as vagas que forem aparecendo e ter conhecimento de mercado é importante pesquisar e conversar com pessoas de diferentes áreas, seja back-end, front-end, infraestrutura e afins.

Saber mais sobre, e manter contato, com pessoas que estão em posições que você almeja estar ou trabalham com tecnologias que você deseja conhecer vão te ajudar a buscar inspiração e a entender melhor a rotina dos profissionais da área, o que vai acabar lhe ajudando na hora das suas próprias escolhas.

Esse é um ponto que não segui e me arrependo, pois tive pouco contato com profissionais que trabalham com Java, e até então não havia estudado muito da linguagem, o que fez com que eu me deixasse levar por comentários alheios de que Java era difícil, feio, chato etc. Hoje penso que se tivesse estudado mais da linguagem teria mais facilidade em muitas coisas do trabalho e talvez até passado em entrevistas anteriores.

Pesquise sobre a empresa e o que ela oferece

Isso com certeza foi algo que me ajudou bastante e até me deu mais ânimo para a entrevista, porque gostei muito do produto que a empresa oferecia e, durante a entrevista, consegui desenvolver uma boa conversa com o recrutador sobre a empresa, onde pude demonstrar melhor o meu interesse.

Algumas empresas têm blogs técnicos onde postam sobre as tecnologias que usam; se houver essa possibilidade, é interessante que você leia alguns dos posts, cite o que achar mais interessante na hora da entrevista e, isso pode ser de interesse até para que possa se preparar, caso haja algum tipo de teste de conhecimento.
Acho legal primeiramente por saber a missão da empresa, e a partir dai desenvolver como você pode ajudá-la, pesquisar alguns dados e curiosidades, notícias recentes, é legal para puxar conversa com o recrutador e mostrar mais interesse.

No meu caso, a empresa onde trabalho tem um canal no Youtube, uma área de serviço com cursos e treinamentos e um portal de empregos. Assisti alguns vídeos, escrevi algumas dúvidas que tive referente ao assunto que eles traziam no canal (é uma empresa que mexe com contabilidade), sobre os cursos falei da minha vontade de futuramente dar aulas de programação, e que teria vontade de ajudar com isso. Pense em coisas que a empresa oferece e como seus objetivos de vida podem ajudá-la.

Dar especial atenção para experiências passadas e projetos desenvolvidos

Geralmente o estágio é sua primeira experiência profissional. Logo, se este for seu caso, saiba usar seu portfólio a seu favor, mostrando sua experiência e competências, mesmo que apenas estudos. Faça projetos simples e os hospede em algum repositório (indico o Github - https://github.com/) e na hora de entrevista saiba mencionar o que você já desenvolveu.

Se você já tem experiência de mercado anterior, dê atenção a isso (mas o portfólio continua sendo importante), cite o que já fez e os resultados que isso trouxe para a empresa na qual você trabalhou.

No meu caso, eu falei o que estava estudando (no caso, estava aprendendo a consumir uma API com Javascript, o que foi muito importante pra mim, porque hoje estou alocada em um projeto de API, mas com Java), sobre projetos que tive na faculdade e usei Java, mesmo que simples, citei que assinei a plataforma Alura mesmo antes de começar as aulas na faculdade, o que mostrou dedicação, e percebi isso pela forma que o recrutador me questionou sobre o por que de eu ter assinado mesmo sem o início das aulas.

Mostre autonomia, muitas coisas usadas no trabalho você terá que aprender fora da faculdade, então é importante que o recrutador saiba que você já está atrás disso, não dependa da faculdade para absorver conhecimento.

Você tem algo que gosta de fazer e pode encaixar tecnologia nisso? Eu por exemplo, que sou vegana, e faço musculação, estava criando um projeto simples como uma calculadora de macronutrientes e calorias para alimentos veganos. Acaba sendo útil para você e é uma coisa legal de citar na entrevista.

Fale e saiba mostrar suas competências não técnicas

Fale sobre suas habilidades de comunicação, organização, de trabalho em grupo, resiliência, criatividade, flexibilidade e afins. Como no estágio geralmente (deveria ser sempre, risos) não é pedido conhecimento técnico, foque também em suas habilidades de cunho mais comportamental.

Eu entrei no meu estágio com pouco conhecimento em Java, mas falei muito sobre minha vontade de aprender, minha dedicação em começar a estudar mesmo antes de ter começado a faculdade, os trabalhos em grupo que já tinha desenvolvido na faculdade e me mostrei comunicativa. Não existe uma regra do que falar, seja sincero com relação às habilidades que tem, e as valorize o quanto der.

Eu me mostrei comunicativa desde o começo, fazendo perguntas, questionando quais tecnologias a empresa mais usava, sobre os projetos, mais importante do que falar sobre, é mostrar quem você é, sei que timidez é algo complicado, mas vá treinando modelos de entrevista com algumas pessoas, eu fiz isso no dia anterior e senti que isso me deixou mais tranquila.

Nessas horas é legal falar também sobre trabalhos voluntários feitos, causas que você acredita, não somos robôs e temos vida fora do trabalho, lembre-se disso.

Networking é importante

Vá em meetups, frequente comunidades de software, converse com pessoas na faculdade. Existem muitas vagas as quais são divulgadas fora de plataformas convencionais de estágio e indicações acabam sendo muito úteis nessas horas, além de que estar em grupos com pessoas da mesma área que você pode te ajudar a estar atualizado a respeito de novas tecnologias, para que possas treinar sua comunicação, no aprendizado de coisas novas e na parte de ter pessoas para se inspirar.

Eu não participava de nenhuma comunidade especialmente de Java, na verdade tinha até medo da linguagem, então quanto mais longe, melhor (quem diria né). Ir em meetups me ajudou na comunicação, a conhecer pessoas que me ajudaram com meu currículo, com recomendação de plataformas de estudo, cada ajuda, mesmo que pequena, é muito importante nessas horas, e conhecer pessoas que já passaram por isso é essencial.

Essas dicas são importantes, mas além de tudo é importante se conhecer, a partir disso você vai saber sua melhor forma de aprendizado, suas melhores qualidades, e como vende-las em uma entrevista.

Aproveite a faculdade para treinar sua comunicação com as pessoas, liderança com trabalhos em grupo, conversar com os professores sobre suas perspectivas de mercado. De tudo que vivi até agora, a faculdade não me ensinou nada do que uso no trabalho, mas é importante tirar proveito de onde você está, as pessoas de lá muitas vezes estão passando pelo mesmo que você, e apoio nessas horas é importante também.

Lembre-se também do autocuidado, descansar a mente, dar uma pausa, valorizar sua saúde mental e respeitar o tempo das coisas, as vezes acho que entraria como uma estagiária melhor se tivesse estudado um pouco mais antes, então não tenha pressa, procurar é importante, mas não fique obcecado nisso e não perca sua sanidade mental.

É bobo falar, mas se conseguir, faça exercícios físicos, se alimente bem, principalmente dias antes da entrevista, não te deixa tão ansioso e é bom para sua produtividade.

Espero que tenha sido útil para você, não deixe de me chamar para caso tiver alguma dúvida, para pedir algum conselho, dar uma crítica, ou sugestão, isso é muito importante pra mim, obrigada!