Realizzare un Dashboard di mercato azionario in tempo reale con grafici in Ios

Una volta aggiunto, configurare il Info.plist[[]] per consentire l'accesso alla rete (HTTP se necessario) con un'eccezione di sicurezza per il tuo dominio API, o meglio, utilizzare endpoint HTTPS.

Progettazione dei modelli di dati

Creare un costui che rispecchia la struttura JSON restituita dal tuo provider. La maggior parte delle API restituisce array di oggetti con campi come [, , , [], [], e cks]]]].

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

Definire un contenitore che contiene una serie di questi punti, più metadati come il simbolo e l'ultimo tempo di aggiornamento.

Livelli di rete con capacità in tempo reale

Crea una classe che utilizza Alamofire per recuperare i dati.Per aggiornamenti in tempo reale, hai due approcci:

• Polling[[] – invia periodicamente richieste HTTP GET (ogni 5-30 secondi a seconda dei limiti della velocità API).
• WebSocket[[]] – mantenere una connessione persistente per ricevere aggiornamenti push (supportati da Finnhub, IEX, ecc.).

Per la pubblicazione, programmare un []] nel modello di vista. Per WebSockets, utilizzare Apple ] o una libreria come Starscream (anche se Alamofire 5 ha anche supporto WebSocket sperimentale).

Esempio funzione di fetch:

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
}

Parsing e memorizzazione dei dati

Il modello di visualizzazione deve gestire la risposta, mapparla alle voci del grafico e mantenere un buffer di punti recenti. Utilizzare [ proprietà in modo che le viste SwiftUI o UIKit possano reagire alle modifiche. Ad esempio, mantenere una serie di oggetti [ (dalla libreria Charts) che rappresentano gli ultimi punti di dati N.

Quando arrivano nuovi dati, aggiungere l'entrata e tagliare quelli vecchi per mantenere la vista grafico finita. Questo impedisce la memoria bloat e mantiene il grafico leggibile.

Costruire la Carta con la Libreria dei Carte

Trascinare un dalla libreria Charts nel tuo storyboard o istantanelo programmaticamente. Impostare i suoi vincoli e configurare l'aspetto:

• Usa con array.
• Abilita per le etichette dei prezzi, ma limita a durare pochi punti per evitare l'ingombro.
• Set per linee più lisce.
• Personalizza i formatori dell'asse – per la formattazione di x-assi (tempo) e y-axis (prezzo).

Esempio:

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

Per aggiornamenti in tempo reale, non si resetterà l'intero dato impostato su ogni zecca. Invece, aggiungere nuova voce e chiamata [] per aggiornare la vista in modo incrementale.

Strategie di aggiornamento in tempo reale

Inquinamento con Timer

Utilizzare un nel modello di vista. Non Invalidare quando la vista scompare. Ricordatevi dei limiti di velocità API – i livelli liberi spesso permettono solo 5-10 richieste al minuto. Utilizzare un intervallo più lungo (10-15 secondi) e esporre una velocità di aggiornamento configurabile.

Connessione WebSocket

Se l'API supporta WebSockets, crea una connessione quando la visualizzazione appare e chiama [] in un loop per ottenere dati trasmessi. Parsare ogni messaggio in arrivo come JSON e aggiornare il grafico. Esempio utilizzando :

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 riduce la latenza e il carico di rete, ma richiedono la gestione di reconnection e Keepalive pings.

UI Layout e la Responsabilità

Il tuo cruscotto dovrebbe includere:

• barra di ricerca o raccoglitore[[]] per inserire un simbolo di stock.
• attuale etichetta dei prezzi[[]] che aggiorna con animazione (ad esempio, verde flash/rosso per aumento/dremento dei prezzi).
• Il grafico line chart[]] che occupa la maggior parte dello spazio dello schermo.
• metriche aggiuntive: variazione giornaliera percentuale, alto / basso, volume.
• Un [indicatore di stato[]] che mostra lo stato di connessione (connesso / disconnesso / caricamento).

Utilizzare SwiftUI per un layout dichiarativo o UIKit con Auto Layout. Assicurare il lavoro pesante (parsing, costruzione dati grafico) esegue il thread principale.

Gestione e Resilienza degli errori

Implementa la logica di riprova con lo backoff esponenziale per le richieste HTTP ([]Il Retrier di Alamofire[]]). Per WebSockets, ascolta i codici vicini e tenta di riconnettersi dopo un ritardo.

Utilizzare con ] per gestire gli errori con grazia.

Ottimizzazione delle prestazioni

Un grafico in tempo reale aggiorna molte volte al minuto. Per mantenere l'interfaccia utente liscia:

• Limitare il numero di punti di dati a una finestra fissa (ad esempio, 200 voci).
• Disattivare il disegno di elementi inutili (, solo per multipli).
• Usa layer backing[]] in UIKit o preferi SwiftUI ] per compositing a base di metallo.
• Aggiornamenti di soglia: se i messaggi WebSocket arrivano più velocemente della velocità di aggiornamento dello schermo (60 Hz), in batch più punti in un aggiornamento grafico.

Provare il Dashboard

Per la visualizzazione del grafico, i test istantanei con ] o []] possono verificare la corretta resa dopo gli aggiornamenti.

Considerazioni di adattamento

Utilizzare variabili di ambiente in schemi Xcode o un che è gitignored. Considerare l'implementazione di una cache locale (ad esempio, Dati core) in modo che il cruscotto mostra gli ultimi dati conosciuti immediatamente sul lancio in attesa di dati freschi.

Per la presentazione di App Store, assicurarsi che la vostra applicazione rispetta le impostazioni di aggiornamento di sfondo app e utilizza [BGTaskScheduler[[] se si desidera aggiornamenti periodici quando l'applicazione non è predestinata, anche se per un vero feeling in tempo reale, connessioni WebSocket funzionano solo in primo piano.

Conclusioni

Combinando Alamofire per le richieste di rete, la libreria Charts per la visualizzazione, e sia inquinando o WebSockets per gli aggiornamenti dal vivo, è possibile costruire un robusto cruscotto di mercato in tempo reale per iOS. Concentrati su architettura pulita, gestione degli errori graziosi e la messa a punto delle prestazioni per fornire un'esperienza professionale che gli utenti si fidano. Ricorda di rispettare i limiti della velocità API e fornire un feedback chiaro quando i dati sono ritardati.