> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Creare un'app iOS con Devin
> Creare un'app iOS con Devin su una VM macOS: build, testing e TestFlight
In questo tutorial, Devin crea un piccolo habit tracker in SwiftUI partendo da un repository vuoto. Devin scrive il codice, lo compila con Xcode, lo esegue nell'iOS Simulator e apre una pull request. Tu segui il suo lavoro, esamini il risultato e poi fai pubblicare a Devin una build beta su TestFlight.
## Prima di iniziare
* **VM macOS**: le sessioni di Devin devono essere eseguite su macOS. Se utilizzi una distribuzione Dedicated SaaS, chiedi al tuo account team di abilitare le VM macOS. Consulta [Supporto macOS](/it/onboard-devin/environment/macos-support).
* **Un repository**: crea un repository vuoto (ad esempio, `habit-tracker`) e concedi a Devin l'accesso tramite la tua [integrazione Git](/it/onboard-devin/environment#before-you-start).
* **Desktop mode**: attiva **Enable desktop mode** in [Settings > Customization](https://app.devin.ai/customization) così che Devin possa interagire con il Simulator e registrare il testing. Consulta [Computer Use](/it/work-with-devin/computer-use).
Le sessioni macOS consumano lo stesso utilizzo delle sessioni Linux. Non è previsto alcun sovrapprezzo per macOS.
## Passaggio 1: chiedi a Devin di creare l'app
Avvia una nuova sessione sul repository che hai scelto e scegli **macOS** dal menu delle piattaforme sotto la casella del prompt. Xcode, l'iOS Simulator e Homebrew sono preinstallati, quindi non serve configurare nulla in anticipo.
In Slack, aggiungi il [bang command](/it/integrations/slack) `!mac` al tuo messaggio. Tramite l'[API](/it/api-reference/overview), imposta `platform: "macos"` quando crei una sessione.
Fornisci a Devin un prompt specifico che descriva le funzionalità dell'app, gli strumenti da usare e come dimostrare che tutto funziona. Ecco un esempio:
```text theme={null}
Crea un'app iOS in SwiftUI chiamata HabitTracker in questo repo.
Requisiti:
- Target iOS 17+. Usa SwiftUI e il framework Observation.
- Schermata principale: un elenco di abitudini, ciascuna con un nome, un'icona
SF Symbol e un pulsante di spunta che segna l'abitudine come completata per oggi.
- Mostra la serie attuale (giorni consecutivi completati) accanto a ogni abitudine.
- Un pulsante "+" nella toolbar apre un foglio per aggiungere un'abitudine. Scorri per eliminare.
- Per ora tieni le abitudini in memoria. Nessuna persistenza.
Setup del progetto:
- Installa xcodegen, swiftlint e xcbeautify con Homebrew.
- Definisci il progetto in project.yml con XcodeGen. Fai il commit di project.yml
e aggiungi il file .xcodeproj generato al .gitignore.
- Aggiungi un target di unit test con test XCTest per il calcolo della serie.
- Assicurati che swiftlint passi senza errori.
Verifica:
- Compila ed esegui i test sul Simulator.
- Installa e avvia l'app nel Simulator. Aggiungi due abitudini, segnane una
come completata ed eliminane una. Registra il tutto e inviami una schermata
della schermata principale.
- Apri una PR con un breve riepilogo e la schermata.
```
Un buon prompt per iOS:
* **Indica la versione della piattaforma e i framework**, così Devin non deve indovinare il target di distribuzione o l'architettura.
* **Indica il dispositivo del simulatore**, così i comandi di build usano una destinazione che esiste sulla VM.
* **Descrive un flusso di verifica concreto**, così Devin testa il comportamento che ti interessa invece di limitarsi a verificare che il codice compili.
## Passaggio 2: osserva Devin mentre compila e testa
Devin affronta l'attività proprio come farebbe uno sviluppatore iOS:
1. **Imposta la struttura del progetto**: scrive `project.yml`, le view SwiftUI, il modello delle abitudini e il target di test, quindi esegue `xcodegen generate`.
2. **Compila e corregge gli errori**: esegue `xcodebuild` dalla sua shell, legge l'output del compilatore e corregge gli errori finché la build e i test non vanno a buon fine.
3. **Esegue l'app nel Simulator**: avvia il dispositivo, installa e lancia la build:
```bash theme={null}
xcrun simctl boot "iPhone 17"
xcrun simctl install booted
xcrun simctl launch booted
```
4. **Testa il flusso che hai descritto**: naviga nell'app con [Computer Use](/it/work-with-devin/computer-use), verifica il risultato a schermo e [registra](/it/work-with-devin/testing-and-recordings) il run.
5. **Apre una pull request** con il riepilogo e lo screenshot.
Apri la tab **iOS Simulator** nel workspace della sessione per seguire in diretta il simulatore avviato mentre Devin naviga nell'app.
Se la build non riesce a trovare una destinazione, chiedi a Devin di eseguire `xcrun simctl list devices available` e di usare un dispositivo e un sistema operativo effettivamente disponibili sulla VM.
## Passaggio 3: rivedi e itera
Rivedi la pull request come faresti con qualsiasi altra. Verifica che lo screenshot e la registrazione corrispondano a quanto hai richiesto. Poi continua a sviluppare nella stessa sessione con prompt di follow-up:
```text theme={null}
Rendi persistenti le abitudini e la cronologia dei completamenti con
SwiftData, in modo che sopravvivano ai riavvii dell'app. Aggiungi un test
che inserisca un'abitudine in un container di modelli in memoria e
verifichi la serie. Riavvia l'app nel Simulator per verificare che le
abitudini vengano mantenute, poi fai push sulla stessa PR.
```
```text theme={null}
Aggiungi un target di test UI con un XCUITest che aggiunga un'abitudine, la
segni come completata e verifichi che la serie mostri 1. Eseguilo sul Simulator iPhone 17.
```
```text theme={null}
Supporta la modalità scura e il Dynamic Type. Verifica la schermata
principale nel Simulator con aspetto scuro e con la dimensione del testo di
accessibilità più grande, quindi invia le schermate di entrambi i casi.
```
Puoi anche lasciare commenti della review sulla pull request: Devin risponde finché la sessione è attiva. Consulta [integrazione GitHub](/it/integrations/gh) e [Devin Review](/it/work-with-devin/devin-review).
## Passaggio 4: Distribuire una beta su TestFlight
Una volta che l'app funziona nel Simulator, Devin può archiviarla, firmarla e caricare la build su TestFlight, così i tester possono installarla su dispositivi reali.
Serve una configurazione una tantum da eseguire personalmente. [Caricare build iOS su TestFlight](/it/onboard-devin/environment/testflight) illustra ogni passaggio:
1. **Configura App Store Connect**: accetta i contratti, registra il bundle ID, crea il record dell'app, crea un gruppo beta e rispondi alle domande sulla conformità all'esportazione.
2. **Crea una API key di App Store Connect** e scarica il relativo file `.p8`.
3. **Aggiungi i secret di Devin**: `ASC_KEY_ID`, `ASC_ISSUER_ID`, `ASC_PRIVATE_KEY` e `APPLE_TEAM_ID`.
4. **Consenti l'accesso alla rete** ai server Apple se la tua organizzazione utilizza una network policy restrittiva.
Usa lo stesso bundle ID in `project.yml` e in App Store Connect. Se nel Passaggio 1 Devin ha scelto un bundle ID segnaposto, chiedigli prima di aggiornare il progetto.
Avvia quindi una nuova sessione, in modo che i secret siano disponibili, e invia questo prompt a Devin:
```text theme={null}
Archivia lo scheme HabitTracker e caricalo su TestFlight. Usa un numero di
build superiore a quello dell'ultima build su App Store Connect, aggiungi la
build al gruppo beta "QA" e inviami il numero di build al termine.
```
Devin scrive l'API key su disco, archivia l'app con `xcodebuild archive` e la carica con `xcodebuild -exportArchive`. Poi aggiunge la build elaborata al gruppo beta. Per riutilizzare questi passaggi senza doverli ripetere in ogni prompt, aggiungi una entry `testflight` alla sezione `knowledge` del blueprint. Consulta [Salvare i passaggi nel blueprint](/it/onboard-devin/environment/testflight#save-the-steps-in-your-blueprint).
## Suggerimenti
* **Blocca la toolchain**: le immagini macOS includono più di una versione di Xcode. Usa `DEVELOPER_DIR` o `xcode-select` nel blueprint per sceglierne una. Vedi [Selezionare una versione di Xcode](/it/onboard-devin/environment/macos-support#selecting-an-xcode-version).
* **Archivia le credenziali come secret**: le API key di App Store Connect, i certificati di firma e i token dei registry di pacchetti privati vanno inseriti in [Secrets](/it/product-guides/secrets). Devin li legge come variabili d'ambiente.
* **Consenti i registry di pacchetti**: se la tua organizzazione usa una network policy restrittiva, assicurati che l'allowlist di macOS includa Swift Package Manager, CocoaPods o qualsiasi registry privato utilizzato dalla tua app. Vedi [Accesso alla rete](/it/onboard-devin/environment/macos-support#network-access).
* **Riavvia il Simulator dopo un risveglio**: quando una sessione va in sleep e poi si risveglia, i file rimangono ma i processi in esecuzione no. Chiedi a Devin di avviare di nuovo il Simulator prima del testing.
* **Chiedi evidenze**: richiedi schermate o una recording di schermate specifiche, così puoi verificare la UI senza dover eseguire tu stesso l'app.
## Limitazioni
* Devin esegue le app su simulatori, non su iPhone o iPad fisici. Per testare su un dispositivo reale, installa una build [TestFlight](#step-4-ship-a-beta-to-testflight).
* I risultati di timing e profiling all'interno di una VM non riflettono le prestazioni reali di un dispositivo.
* I container vengono eseguiti tramite emulazione software sulle VM macOS, quindi le attività che ne fanno ampio uso risultano lente.
Per i dettagli, consulta le [limitazioni del supporto macOS](/it/onboard-devin/environment/macos-support#limitations).
## Passaggi successivi
Configurazione di App Store Connect, API key e secret per caricare le build
Opzioni dei blueprint, strumenti preinstallati e risoluzione dei problemi per le sessioni macOS
Come Devin testa la tua app e registra i risultati