Perguntas para Entrevista de Desenvolvedor Mobile Sênior (iOS): Guia Completo

class Pessoa {
    var nome: String
    var apartamento: Apartamento?
    
    init(nome: String) { self.nome = nome }
    deinit { print("\(nome) está sendo desalocado(a)") }
}

class Apartamento {
    var unidade: String
    weak var inquilino: Pessoa?  // weak para quebrar o ciclo de retenção
    
    init(unidade: String) { self.unidade = unidade }
    deinit { print("Apartamento \(unidade) está sendo desalocado(a)") }
}

// Função genérica
func trocar<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Tipo genérico
struct Pilha<Elemento> {
    private var itens: [Elemento] = []
    
    mutating func push(_ item: Elemento) {
        itens.append(item)
    }
    
    mutating func pop() -> Elemento? {
        return itens.popLast()
    }
}

// Restrição de tipo
func encontrarIndice<T: Equatable>(de valorParaEncontrar: T, em array: [T]) -> Int? {
    for (indice, valor) in array.enumerated() {
        if valor == valorParaEncontrar {
            return indice
        }
    }
    return nil
}

class GerenciadorDeRede {
    var completionHandlers: [() -> Void] = []
    
    // Closure escaping - armazenada para mais tarde
    func buscarDados(completion: @escaping (Data?) -> Void) {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            completion(data)  // Chamada depois que a função retorna
        }.resume()
    }
    
    // Closure non-escaping - executada imediatamente
    func processarDados(_ data: Data, transform: (Data) -> String) -> String {
        return transform(data)  // Chamada antes que a função retorne
    }
}

let numeros = [1, 2, 3, 4, 5]

// map
let dobrados = numeros.map { $0 * 2 }
// [2, 4, 6, 8, 10]

// compactMap - remove nil
let strings = ["1", "2", "tres", "4"]
let numerosValidos = strings.compactMap { Int($0) }
// [1, 2, 4]

// flatMap - achata arrays
let aninhado = [[1, 2], [3, 4], [5]]
let achatado = aninhado.flatMap { $0 }
// [1, 2, 3, 4, 5]

@propertyWrapper
struct Capitalizado {
    private var valor: String = ""
    
    var wrappedValue: String {
        get { value }
        set { value = newValue.capitalized }
    }
}

struct Usuario {
    @Capitalizado var primeiroNome: String
    @Capitalizado var ultimoNome: String
}

var usuario = Usuario()
usuario.primeiroNome = "joão"
print(usuario.primeiroNome)  // "João"

// Wrapper UserDefaults
@propertyWrapper
struct UserDefault<T> {
    let chave: String
    let valorPadrao: T
    
    var wrappedValue: T {
        get { UserDefaults.standard.object(forKey: chave) as? T ?? valorPadrao }
        set { UserDefaults.standard.set(newValue, forKey: chave) }
    }
}

struct Configurações {
    @UserDefault(key: "nomeDeUsuario", defaultValue: "Convidado")
    static var nomeDeUsuario: String
}

enum ErroDeRede: Error {
    case urlInvalida
    case semDados
    case erroDeDecodificação
}

func buscarUsuario(id: Int, completion: @escaping (Result<Usuario, ErroDeRede>) -> Void) {
    guard let url = URL(string: "https://api.example.com/users/\(id)") else {
        completion(.failure(.urlInvalida))
        return
    }
    
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data else {
            completion(.failure(.semDados))
            return
        }
        
        do {
            let usuario = try JSONDecoder().decode(Usuario.self, from: data)
            completion(.success(usuario))
        } catch {
            completion(.failure(.erroDeDecodificação))
        }
    }.resume()
}

// Uso
buscarUsuario(id: 1) { result in
    switch result {
    case .success(let usuario):
        print("Usuário: \(usuario.nome)")
    case .failure(let error):
        print("Erro: \(error)")
    }
}

// Model
struct Usuario {
    let id: Int
    let primeiroNome: String
    let ultimoNome: String
}

// ViewModel
class UserViewModel {
    private let usuario: Usuario
    
    var nomeCompleto: String {
        "\(usuario.primeiroNome) \(usuario.ultimoNome)"
    }
    
    var textoDeExibição: String {
        "Usuário #\(usuario.id): \(nomeCompleto)"
    }
    
    init(usuario: Usuario) {
        self.usuario = usuario
    }
}

// View
class UserViewController: UIViewController {
    private let viewModel: UserViewModel
    private let label = UILabel()
    
    init(viewModel: UserViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        label.text = viewModel.textoDeExibição
    }
}

protocol Coordinator {
    var navigationController: UINavigationController { get }
    func start()
}

class AppCoordinator: Coordinator {
    let navigationController: UINavigationController
    
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }
    
    func start() {
        mostrarLogin()
    }
    
    func mostrarLogin() {
        let loginVC = LoginViewController()
        loginVC.coordinator = self
        navigationController.pushViewController(loginVC, animated: true)
    }
    
    func mostrarHome() {
        let homeVC = HomeViewController()
        homeVC.coordinator = self
        navigationController.pushViewController(homeVC, animated: true)
    }
}

// Protocolo para abstração
protocol ServicoDeRede {
    func buscarDados(completion: @escaping (Result<Data, Error>) -> Void)
}

// Implementação concreta
class URLSessionServicoDeRede: ServicoDeRede {
    func buscarDados(completion: @escaping (Result<Data, Error>) -> Void) {
        // Chamada de rede real
    }
}

// Mock para testes
class MockServicoDeRede: ServicoDeRede {
    func buscarDados(completion: @escaping (Result<Data, Error>) -> Void) {
        completion(.success(Data()))
    }
}

// ViewModel com injeção de dependência
class UserViewModel {
    private let servicoDeRede: ServicoDeRede
    
    // Injeção de construtor
    init(servicoDeRede: ServicoDeRede) {
        self.servicoDeRede = servicoDeRede
    }
    
    func carregarUsuarios() {
        servicoDeRede.buscarDados { result in
            // Lidar com o resultado
        }
    }
}

// Uso
let viewModel = UserViewModel(servicoDeRede: URLSessionServicoDeRede())

// Testes
let testViewModel = UserViewModel(servicoDeRede: MockServicoDeRede())

protocol UserRepository {
    func getUser(id: Int) async throws -> Usuario
    func saveUser(_ user: Usuario) async throws
}

class UserRepositoryImpl: UserRepository {
    private let apiService: APIService
    private let cacheService: CacheService
    
    init(apiService: APIService, cacheService: CacheService) {
        self.apiService = apiService
        self.cacheService = cacheService
    }
    
    func getUser(id: Int) async throws -> Usuario {
        // Verificar cache primeiro
        if let cachedUser = try? await cacheService.getUser(id: id) {
            return cachedUser
        }
        
        // Buscar da API
        let user = try await apiService.fetchUser(id: id)
        
        // Atualizar cache
        try? await cacheService.saveUser(user)
        
        return user
    }
    
    func saveUser(_ user: Usuario) async throws {
        try await apiService.updateUser(user)
        try await cacheService.saveUser(user)
    }
}

class ImageTableViewCell: UITableViewCell {
    static let identifier = "ImageCell"
    private let customImageView = UIImageView()
    
    override func prepareForReuse() {
        super.prepareForReuse()
        customImageView.image = nil  // Limpar imagem antiga
    }
}

// No view controller
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: ImageTableViewCell.identifier, for: indexPath) as! ImageTableViewCell
    
    // Carregar imagem assincronamente
    DispatchQueue.global(qos: .userInitiated).async {
        let image = self.loadAndResizeImage(at: indexPath)
        DispatchQueue.main.async {
            cell.imageView?.image = image
        }
    }
    
    return cell
}

class ViewController: UIViewController {
    var closure: (() -> Void)?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // RUIM - ciclo de retenção
        closure = {
            self.view.backgroundColor = .red
        }
        
        // BOM - weak self
        closure = { [weak self] in
            self?.view.backgroundColor = .red
        }
        
        // BOM - unowned self (se self sempre existe)
        closure = { [unowned self] in
            self.view.backgroundColor = .red
        }
    }
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    
    // Crítico: Configurar janela e view controller raiz
    setupWindow()
    
    // Adiar trabalho não crítico
    DispatchQueue.main.async {
        self.setupAnalytics()
        self.setupCrashReporting()
    }
    
    // Trabalho de fundo
    DispatchQueue.global(qos: .background).async {
        self.preloadData()
    }
    
    return true
}

class ImageCache {
    static let shared = ImageCache()
    
    private let memoryCache = NSCache<NSString, UIImage>()
    private let fileManager = FileManager.default
    private let cacheDirectory: URL
    
    private init() {
        cacheDirectory = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("ImageCache")
        try? fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true)
    }
    
    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
        let key = url.absoluteString as NSString
        
        // Verificar cache de memória
        if let cachedImage = memoryCache.object(forKey: key) {
            completion(cachedImage)
            return
        }
        
        // Verificar cache de disco
        let fileURL = cacheDirectory.appendingPathComponent(url.lastPathComponent)
        if let diskImage = UIImage(contentsOfFile: fileURL.path) {
            memoryCache.setObject(diskImage, forKey: key)
            completion(diskImage)
            return
        }
        
        // Download
        URLSession.shared.dataTask(with: url) { data, _, _ in
            guard let data = data, let image = UIImage(data: data) else {
                completion(nil)
                return
            }
            
            // Salvar em caches
            self.memoryCache.setObject(image, forKey: key)
            try? data.write(to: fileURL)
            
            DispatchQueue.main.async {
                completion(image)
            }
        }.resume()
    }
}

// Maneira antiga com completion handlers
func buscarUsuario(id: Int, completion: @escaping (Result<Usuario, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        // Lidar com o resultado
    }.resume()
}

// Nova maneira com async/await
func buscarUsuario(id: Int) async throws -> Usuario {
    let (data, _) = try await URLSession.shared.data(from: url)
    let user = try JSONDecoder().decode(Usuario.self, from: data)
    return user
}

// Uso
Task {
    do {
        let user = try await buscarUsuario(id: 1)
        print(user.nome)
    } catch {
        print("Erro: \(error)")
    }
}

// Execução paralela
async let user1 = buscarUsuario(id: 1)
async let user2 = buscarUsuario(id: 2)
let users = try await [user1, user2]

actor BankAccount {
    private var balance: Double = 0
    
    func deposit(amount: Double) {
        balance += amount
    }
    
    func withdraw(amount: Double) -> Bool {
        guard balance >= amount else { return false }
        balance -= amount
        return true
    }
    
    func getBalance() -> Double {
        return balance
    }
}

// Uso
let account = BankAccount()

Task {
    await account.deposit(amount: 100)
    let balance = await account.getBalance()
    print("Balance: \(balance)")
}

// Main Actor para atualizações da UI
@MainActor
class ViewModel: ObservableObject {
    @Published var data: [String] = []
    
    func loadData() async {
        let newData = await fetchDataFromAPI()
        // Automaticamente na thread principal
        self.data = newData
    }
}

import Combine

class UserViewModel: ObservableObject {
    @Published var searchText = ""
    @Published var users: [Usuario] = []
    
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $searchText
            .debounce(for: .milliseconds(300), scheduler: RunLoop.main)
            .removeDuplicates()
            .filter { !$0.isEmpty }
            .flatMap { query in
                self.searchUsers(query: query)
            }
            .receive(on: DispatchQueue.main)
            .sink { [weak self] users in
                self?.users = users
            }
            .store(in: &cancellables)
    }
    
    func searchUsers(query: String) -> AnyPublisher<[Usuario], Never> {
        // Retornar publisher
        URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [Usuario].self, decoder: JSONDecoder())
            .replaceError(with: [])
            .eraseToAnyPublisher()
    }
}

// Fila serial
let serialQueue = DispatchQueue(label: "com.app.serial")
serialQueue.async { print("Tarefa 1") }
serialQueue.async { print("Tarefa 2") }
// Saída: Tarefa 1, Tarefa 2 (sempre em ordem)

// Fila concorrente
let concurrentQueue = DispatchQueue(label: "com.app.concurrent", attributes: .concurrent)
concurrentQueue.async { print("Tarefa A") }
concurrentQueue.async { print("Tarefa B") }
// Saída: Tarefa A, Tarefa B OU Tarefa B, Tarefa A (ordem não garantida)

// Barreira para operações de escrita
concurrentQueue.async(flags: .barrier) {
    // Acesso exclusivo - nenhuma outra tarefa é executada simultaneamente
    print("Operação de escrita")
}

class CoreDataManager {
    let persistentContainer: NSPersistentContainer
    
    var viewContext: NSManagedObjectContext {
        return persistentContainer.viewContext
    }
    
    func performBackgroundTask(_ block: @escaping (NSManagedObjectContext) -> Void) {
        persistentContainer.performBackgroundTask { context in
            block(context)
            
            if context.hasChanges {
                try? context.save()
            }
        }
    }
}

// Uso
coreDataManager.performBackgroundTask { context in
    let user = Usuario(context: context)
    user.nome = "João"
    // O contexto salva automaticamente
}

class UsersViewController: UITableViewController, NSFetchedResultsControllerDelegate {
    var fetchedResultsController: NSFetchedResultsController<Usuario>!
    
    func setupFetchedResultsController() {
        let fetchRequest: NSFetchRequest<Usuario> = Usuario.fetchRequest()
        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        
        fetchedResultsController = NSFetchedResultsController(
            fetchRequest: fetchRequest,
            managedObjectContext: context,
            sectionNameKeyPath: nil,
            cacheName: nil
        )
        
        fetchedResultsController.delegate = self
        try? fetchedResultsController.performFetch()
    }
    
    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return fetchedResultsController.sections?[section].numberOfObjects ?? 0
    }
    
    func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        tableView.reloadData()
    }
}