A criação de um painel de mercado de ações em tempo real para iOS exige uma compreensão sólida da rede, manipulação de dados e renderização de gráficos. Este guia abrange todo o fluxo de trabalho – desde a configuração do projeto e integração de APIs até atualizações ao vivo e ajuste de desempenho – para que você possa fornecer um aplicativo responsivo e de qualidade de produção.

Pré-requisitos e ferramentas

Antes de começar, certifique-se de que seu ambiente está pronto:

  • macOS com a versão mais recente do Xcode instalado.
  • Swift 5.7+ – a linguagem utilizada durante toda esta implementação.
  • Alamofire – uma biblioteca de rede de alto nível para simplificar solicitações HTTP e manipulação de resposta. Integrar via Swift Package Manager (SPM) ou CocoaPods.
  • [[FLT: 0]]Gráficos[[FLT: 1]] – a conhecida biblioteca de gráficos iOS (uma porta do MPAndroidChart). Use SPM: [[FLT: 0]]
  • Uma API de dados de stock – as opções populares incluem Alpha Vantage[ (nível livre com chave API), IEX Cloud[, ou Finnhub[.Cada uma oferece endpoints históricos em tempo real.
  • CocoaPods ou SPM – gerentes de dependência. SPM é incorporado no Xcode e recomendado.

Configuração e Dependências do Projeto

Criar um novo projeto Xcode usando o modelo [[FLT: 0]]App[[ FLT: 1]] que se destina ao iOS 16+. Sob [[ FLT: 2] Arquivo & gt; Adicionar Pacotes[[ FLT: 3]], adicione Alamofire e Gráficos. Para o Alamofire, use o URL principal do ramo [[ FLT: 1]] e para o uso de Gráficos [[ FLT: 2]]. Isto evita downloads manuais e mantém suas dependências atualizadas.

Uma vez adicionado, configure seu Info.plist para permitir o acesso à rede (HTTP se necessário) com uma exceção de Segurança de Transporte de Aplicativos para seu domínio API, ou melhor, use os endpoints HTTPS.

Desenhando os Modelos de Dados

Crie uma estrutura que espelha a estrutura do JSON devolvida pelo seu provedor. A maioria das APIs devolvem arrays de objetos com campos como , , , , , e . Para um painel em tempo real, foque no preço mais recente e numa janela de dados históricos (por exemplo, os últimos 100 tiques).

struct StockDataPoint: Codable {
 let timestamp: TimeInterval
 let price: Double
 let volume: Int
}

Defina um recipiente que contenha uma matriz destes pontos, mais metadados como o símbolo e a última atualização. Use para combinar snake case da API com camelCase em Swift.

Camada de rede com capacidades em tempo real

Crie uma classe que usa Alamofire para obter dados. Para atualizações em tempo real, você tem duas abordagens:

  • Polling – envie periodicamente solicitações HTTP GET (a cada 5-30 segundos dependendo dos limites de taxa de API). Mais simples, mas menos eficiente.
  • WebSocket – mantenha uma conexão persistente para receber atualizações de push (suportadas por Finnhub, IEX, etc.).

Implemente um método que devolve um editor ou use um padrão para obter os dados mais recentes. Para votação, agende um no seu modelo de visualização. Para WebSockets, use o da Apple] ou uma biblioteca como Starscream (embora o Alamofire 5 também tenha suporte experimental para WebSocket).

Exemplo função de obtenção:

func fetchLatestPrice(for symbol: String) async throws -> StockDataPoint {
 let url = "https://api.example.com/quote?symbol=\(symbol)&apikey=\(apiKey)"
 let response = try await AF.request(url).serializingDecodable(StockDataPoint.self).value
 return response
}

Processamento e armazenamento de dados

Seu modelo de visualização deve lidar com a resposta, mapeá- la para os itens de gráfico e manter um buffer de pontos recentes. Use propriedades para que as visualizações SwiftUI ou UIKit possam reagir às mudanças. Por exemplo, mantenha uma matriz de objetos (da biblioteca de gráficos) que representam os últimos pontos de dados N.

Quando chegarem novos dados, adicione os itens e apare os antigos para manter a visão de gráfico finita. Isto evita o inchaço da memória e mantém o gráfico legível.

Construindo o Gráfico com Biblioteca de Gráficos

Arraste um [[FLT: 22]] da biblioteca de gráficos para o seu storyboard ou instanceie- o programáticamente. Defina as suas restrições e configure a aparência:

  • Usar com arrays.
  • Active para etiquetas de preços, mas limite-se a alguns pontos para evitar confusão.
  • Definir para linhas mais suaves.
  • Personalizar formatação de eixos – para formatação de eixos x (tempo) e eixo y (preço).

Exemplo:

let entries = stockDataPoints.map { ChartDataEntry(x: $0.timestamp, y: $0.price) }
let dataSet = LineChartDataSet(entries: entries, label: "\(symbol) Price")
dataSet.drawCirclesEnabled = false
dataSet.lineWidth = 2
dataSet.setColor(.systemBlue)

let chartData = LineChartData(dataSet: dataSet)
lineChartView.data = chartData

Para atualizações em tempo real, você não irá redefinir todo o conjunto de dados em cada tique. Em vez disso, adicione nova entrada e chame para atualizar a visualização incrementalmente.

Estratégias de Atualização em Tempo Real

Polação com o timer

Use um no seu modelo de visualização. Invalide-o quando a visualização desaparecer. Tenha cuidado com os limites de taxa de API – níveis livres muitas vezes permitem apenas 5-10 solicitações por minuto. Use um intervalo maior (10-15 segundos) e expire uma taxa de atualização configurável.

Ligação WebSocket

Se a sua API suporta WebSockets, crie uma conexão quando a visualização aparecer e chame em um loop para obter dados transmitidos. Analise cada mensagem recebida como JSON e atualize o gráfico. Exemplo usando :

let task = session.webSocketTask(with: url)
task.resume()
func receive() {
 task.receive { result in
 switch result {
 case .success(let message):
 if case .string(let text) = message,
 let data = text.data(using: .utf8),
 let point = try? JSONDecoder().decode(StockDataPoint.self, from: data) {
 DispatchQueue.main.async { self.updateChart(with: point) }
 }
 self.receive()
 case .failure(let error):
 // reconnect logic
 }
 }
}

WebSockets reduzem a latência e a carga da rede, mas requerem a manipulação de reconexão e pings keeplive.

Disposição e Responsividade da IU

Seu painel deve incluir:

  • A barra de pesquisa ou coletor para inserir um símbolo de estoque.
  • A ]relatório de preço atual que atualiza com animação (por exemplo, verde flash/vermelho para aumento/diminuição de preço).
  • O gráfico linha ocupa a maioria do espaço de tela.
  • métricas adicionais: porcentagem de mudança diária, alto/baixo, volume.
  • A ]indicador de estado mostrando o estado da conexão (ligado / desconectado / carregamento).

Use SwiftUI para um layout declarativo ou UIKit com Layout Auto. Certifique-se de trabalho pesado (parsing, construção de dados de gráfico) é executado fora do thread principal. Despache atualizações UI para .

Tratamento e Resiliência de Erros

Falhas de rede são inevitáveis. Implemente lógica de reteste com retrocesso exponencial para requisições HTTP ()RequestRetrier de Alamofire[). Para WebSockets, ouça códigos de fechamento e tente reconectar após um atraso.

Use com para lidar com erros graciosamente. Registre erros em um serviço remoto como Crashlytics apenas na produção.

Otimização de desempenho

Um gráfico em tempo real atualiza muitas vezes por minuto. Para manter a interface suave:

  • Limitar o número de pontos de dados a uma janela fixa (por exemplo, 200 entradas).
  • Desactivar o desenho de elementos desnecessários (, apenas para múltiplos).
  • Utilizar backbacking no UIKit ou preferir SwiftUI para a composição com suporte metálico.
  • Atualizações de aceleração: se as mensagens WebSocket chegarem mais rápido do que a taxa de atualização da tela (60 Hz), coloque vários pontos em lote em uma atualização de gráfico.

Testando o Painel

Escreva testes unitários para o processamento de dados e gerenciador de rede usando respostas do JSON simulado. Use ou para simular respostas da API. Para a visualização do gráfico, os testes de instantâneo com podem verificar a renderização correta após atualizações. Teste o comportamento em tempo real com testes de UI que injetam dados simulados por tempo real através de um servidor personalizado.

Considerações sobre a implantação

Guarde a chave API de forma segura – nunca codifice-a. Use variáveis de ambiente em esquemas Xcode ou em um que está gitgnored. Considere implementar um cache local (por exemplo, Dados de Base) para que o painel mostre os últimos dados conhecidos imediatamente no lançamento enquanto aguarda novos dados.

Para submissão App Store, certifique-se de que seu aplicativo respeita as configurações de atualização do aplicativo de fundo e use BGTaskScheduler[ se você quiser atualizações periódicas quando o aplicativo não for apresentado, embora para uma sensação real em tempo real, conexões WebSocket só funcionam em primeiro plano.

Conclusão

Ao combinar o Alamofire para solicitações de rede, a biblioteca de gráficos para visualização e pesquisas ou WebSockets para atualizações ao vivo, você pode construir um painel robusto de mercado em tempo real para iOS. Foque-se em arquitetura limpa, manipulação de erros graciosos e ajuste de desempenho para oferecer uma experiência profissional confiável pelos usuários. Lembre-se de respeitar os limites de taxa de API e fornecer feedback claro quando os dados forem atrasados. Com essas bases, você pode estender o painel com vários símbolos, indicadores técnicos ou até mesmo gerenciamento de listas de observação.