Vai al contenuto
megapromotingParliamone

Competenza · Applicazioni mobili

Applicazioni per telefono, costruite in modo che la logica possa essere verificata senza telefono.

Costruiamo applicazioni native iOS in Swift, con sensori e HealthKit, e applicazioni con un solo codice per iOS, Android e web quando il progetto non richiede sensori. Il nucleo della logica viene testato separatamente dallo schermo.

Già costruitoSono tre implementazioni proprie, non una. Un repository con cinque target di applicazione (quattro iOS e uno macOS) definiti in `project.yml`, i cui test di logica abbiamo eseguito oggi: 160 su 160 passano. Una seconda app iOS, in un altro progetto, con 40 file Swift e HealthKit. E una terza direzione, con un solo codice per iOS, Android e web, la cui variante web risponde oggi. La riserva che cambia la risposta alla domanda che ogni acquirente pone prima di tutto: nessuna delle nostre app è pubblicata su App Store o Google Play. Il motivo è uno solo e ha un nome — `DEVELOPMENT_TEAM` è vuoto nella configurazione del progetto, cioè manca l’identificatore del team dell’Apple Developer Program. La macchina ha un’identità di firma valida, sufficiente per l’installazione sul proprio dispositivo, insufficiente per la distribuzione nello store. È un problema di account, non di codice, ma resta un problema e lo scriviamo qui, non in fondo.

Un’app mobile ha due parti che si rompono in modo diverso. La parte che legge i sensori e calcola qualcosa — un angolo, un punteggio, uno stato — e la parte che disegna gli schermi. Le teniamo separate, e non per motivi estetici: nel nostro deposito principale iOS, i file del nucleo non importano l’interfaccia, quindi possono essere compilati direttamente con `swiftc` su Mac ed eseguiti come un programma normale, senza simulatore e senza telefono. La suite ha 160 verifiche raggruppate in 16 fasi; l’abbiamo eseguita oggi e passa integralmente. Questo è il motivo per cui possiamo dire esattamente cosa fa un algoritmo, invece di dire che «funziona bene».

Su iOS lavoriamo in Swift 6, con obiettivo minimo iOS 17. Lo stesso deposito definisce cinque applicazioni come target separati: quattro per iPhone e una per macOS, e quella per macOS riutilizza quindici file dal nucleo di iOS, senza copia. I sensori si leggono alla fonte: l’interfaccia Apple per i sensori nelle cuffie espone l’orientamento della testa, e l’app confronta l’angolo corrente con una posizione che l’utente calibra all’inizio della sessione. Le soglie non sono «regolazioni interne»: sotto 7° è diritto, tra 7° e 13° è inclinazione, oltre 13° mantenuto per tre secondi fa scattare l’allerta, e la smussatura usa una media esponenziale con coefficiente 0,15. Tutti e quattro i valori stanno in quattro righe consecutive di codice e possono essere mostrati.

Quando il progetto non ha bisogno di sensori, non raccomandiamo il nativo. La terza direzione nel portafoglio è un solo codice che si compila per iPhone, Android e browser — React Native con Expo — e la variante web è pubblicata e risponde oggi. La differenza pratica per il cliente: un questionario, un calcolatore o una dashboard non giustificano due team e due depositi; un’applicazione che ascolta un sensore a venti campioni al secondo, sì.

Ciò che non possiamo ancora fare. Nessuna delle nostre applicazioni è su App Store o Google Play. Non perché non compili — compila, si installa sul simulatore e passa i test — ma perché nella configurazione del progetto l’identificatore del team Apple è vuoto, cioè non esiste una registrazione nell’Apple Developer Program collegata a questi build. Su Mac esiste un’identità di firma valida, di tipo sviluppo, che basta per l’installazione sul proprio dispositivo e non basta per lo store. Per un progetto cliente, l’account sviluppatore si apre a nome della società cliente e resta suo — questa è la discussione che va fatta all’inizio, non alla fine.

Cosa comprende

Il lavoro, per componenti

Leggiamo il sensore alla fonte, non tramite una libreria intermedia

Su iOS usiamo direttamente le interfacce Apple: `CMHeadphoneMotionManager` per l’orientamento della testa nelle cuffie, con delegato per connessione e disconnessione, e verifica esplicita dello stato di autorizzazione prima di avviare il flusso. Se il sensore non è disponibile, lo stato passa a `waiting`, non a un errore silenzioso.

Il nucleo della logica non sa che esiste uno schermo

I file di analisi, calibrazione, storico e politiche sono semplice Swift. Si compilano con `swiftc` insieme al file di test e si eseguono come binario da riga di comando. Il risultato di oggi: 160 verifiche, 16 fasi da 10, tutte passate. Un test che gira in due secondi su Mac si esegue a ogni modifica; uno che richiede il simulatore, no.

L’interfaccia si costruisce sopra il nucleo, su iOS e su macOS contemporaneamente

SwiftUI per entrambi. Il target macOS nello stesso deposito include quindici file del nucleo iOS come sorgenti condivise, non come file copiati, quindi una correzione nell’algoritmo arriva simultaneamente in entrambe le applicazioni.

Un solo codice per iOS, Android e web, quando questa è la scelta corretta

Expo sopra React Native, con `react-native-web` per la variante browser, font caricati dal pacchetto e icone dell’app separate per Android, inclusa la variante monocromatica richiesta dal sistema. La stessa applicazione gira sul telefono e nella pagina, da un solo deposito.

Dati sanitari: una politica dichiarata per ogni tipo di dato

Non «leggiamo HealthKit», ma una tabella nel codice: undici tipi di dato (angoli posturali, movimento grezzo dalle cuffie, pulsazioni e variabilità, sonno, camminata, esposizione audio, sessioni guidate e altri) e cinque regimi possibili (solo locale, lettura da HealthKit, scrittura di allenamento, scrittura di sessione di relax, scrittura di percorso). Ogni tipo riceve esplicitamente uno dei regimi. La seconda applicazione iOS del portfolio, in un progetto privato, usa lo stesso approccio su 40 file Swift.

I file di privacy richiesti da Apple, presenti fin dall’inizio

Quattro target hanno `PrivacyInfo.xcprivacy` incluso come risorsa di build, non aggiunto in fretta al primo rifiuto. Le descrizioni d’uso per movimento, fotocamera, microfono, HealthKit e notifiche sono scritte in romeno, nella configurazione del progetto, non generate automaticamente.

Ciò che esce dal telefono: nel caso dell’app iOS di riferimento, nulla

La ricerca di `URLSession` nei sorgenti del target iOS restituisce zero risultati. La cronologia si scrive sul dispositivo, tramite `FileManager` e `UserDefaults`, con opzione di eliminazione del file. L’unico codice di rete nel repository è in una funzione dell’app macOS, in un file separato. Quando un’app non ha bisogno di un server, non gliene mettiamo uno.

Il percorso iniziale, testato come stato, non come schermata

L’onboarding ha 24 passaggi con identificatori unici e ordinati, e alcuni passaggi richiedono una conferma esplicita (i limiti del sensore, il funzionamento in primo piano, la riservatezza, la preparazione) senza la quale il pulsante di continuazione resta bloccato. Lo stato viene codificato e ripreso. Dieci dei 160 test verificano proprio questo.

Firma e distribuzione, dette fin dall’inizio

Verifichiamo quale account sviluppatore esiste, per quale azienda, chi lo amministra e cosa manca perché il build possa essere firmato per lo store. È una lista breve e noiosa, ma è la differenza tra un’app che funziona sul nostro telefono e una che arriva agli utenti.

Come si presenta

Il percorso, passo dopo passo.

01

Decidiamo nativo o codice comune, in base ai sensori

La domanda non è di gusto, ma di hardware: l’app ha bisogno di movimento, salute, Bluetooth, fotocamera in tempo reale, background? Se sì, nativo. Se si tratta di moduli, calcoli, liste e una dashboard, un solo codice per iOS, Android e web fa lo stesso lavoro con metà della manutenzione. Consegnamo la decisione scritta, con il motivo.

02

Costruiamo il nucleo prima delle schermate e lo copriamo con test che girano senza telefono

L’algoritmo, le soglie, gli stati e la persistenza. I test si compilano direttamente sul Mac e girano in pochi secondi. Consegniamo la suite e il suo risultato, non una promessa di qualità.

03

Mettiamo l’interfaccia sopra il nucleo e la eseguiamo su simulatore e su dispositivo

SwiftUI su iOS e macOS, oppure React Native quando abbiamo scelto il codice comune. Verifichiamo il percorso iniziale, le autorizzazioni e il comportamento quando il sensore manca o si disconnette a metà sessione — il caso che si rompe spesso nella pratica.

04

Prepariamo la distribuzione, con l’account del cliente

Identificatore del pacchetto, versione, icone, file di privacy, descrizioni delle autorizzazioni, identificatore del team dell’Apple Developer Program. Qui si bloccano i progetti che non hanno discusso dell’account all’inizio — compresi i nostri, che è esattamente il motivo per cui mettiamo questo passaggio per iscritto.

Ce vede utilizatorulL'applicazioneRete e sicurezzaHosting e datiOGNI STRATO, SCELTO E SPIEGATO
Quattro strati, dal basso verso l'alto: i sensori della piattaforma (movimento dalle cuffie, HealthKit, notifiche); il nucleo di logica in Swift semplice, che non importa l'interfaccia e per questo può essere eseguito su Mac senza telefono; l'interfaccia SwiftUI, la stessa per iPhone e macOS; e lo strato di distribuzione — file di privacy, permessi dichiarati, firma. L'ultimo strato è l'unico che non abbiamo percorso fino in fondo, e per questo è disegnato aperto.

I dati

Cosa tocchiamo, dove risiedono e quanto rimangono

Le domande che pone chiunque abbia un responsabile della protezione dei dati — poste qui prima che le ponga lui.

Dove stanno i dati quando l’app non ha server
Sul dispositivo. La cronologia posturale viene serializzata in un file proprio tramite `FileManager`, mentre le preferenze in `UserDefaults`, con chiavi prefissate per applicazione. Esiste un comando per eliminare il file della cronologia. Nulla viene inviato a un server per il semplice motivo che l’applicazione non contiene codice di rete.
I dati sanitari vengono letti solo con consenso, e solo quelli dichiarati
HealthKit richiede il consenso dell’utente a livello di tipo di dato, e l’applicazione dichiara nella configurazione perché li richiede. La politica nel codice separa esplicitamente ciò che viene letto da ciò che viene scritto di nuovo in Salute. Non viene fatta alcuna diagnosi e non viene trasmesso nulla a noi.
Ciò che Apple richiede di dichiarare, indipendentemente da cosa si faccia con i dati
Il file di privacy dell’applicazione e le descrizioni d’uso per ogni permesso (movimento, camera, microfono, salute, notifiche). Sono una condizione di accettazione nello store, non un’opzione, e si scrivono nella lingua parlata dall’utente.
Per quanto tempo viene conservato
Per il tempo deciso dall’utente, quando i dati restano sul telefono: la disinstallazione dell’applicazione li porta con sé, mentre l’eliminazione dall’applicazione è un’operazione esplicita. Quando un progetto ha comunque un server, la retention si scrive nel contratto prima della prima riga di codice, perché determina cosa si può e cosa non si può costruire.
L’account sviluppatore e le chiavi di firma
Rimangono del cliente, sulla società del cliente. Noi lavoriamo con accesso delegato. Il motivo è pratico, non di principio: un’applicazione pubblicata sull’account del fornitore diventa impossibile da trasferire il giorno in cui il fornitore cambia.

Un caso

Un’applicazione per iPhone che misura una sola cosa, e la misura in modo verificabile

La situazione

Un progetto proprio, non di un cliente: un cronometro di concentrazione che osserva di quanto si è inclinata la testa rispetto a una posizione calibrata dall’utente all’inizio della sessione. Avevamo bisogno di un caso in cui le affermazioni sull’algoritmo potessero essere mostrate, non descritte.

Cosa abbiamo costruito

Ho separato il nucleo dall’interfaccia e ho scritto le soglie nel codice, non nella documentazione: sotto 7° diritto, tra 7° e 13° scorrimento, oltre 13° tenuto per tre secondi attiva l’allerta aptica, con smussamento esponenziale al coefficiente 0,15. I dati arrivano dall’interfaccia Apple per i sensori nelle cuffie, con gestione esplicita della disconnessione. L’onboarding ha 24 passaggi, dei quali quattro richiedono la conferma dei limiti prima di lasciare l’utente andare avanti. Ho costruito dallo stesso nucleo anche una variante per macOS.

Cosa è emerso

La suite di logica si compila con `swiftc` e gira su Mac in pochi secondi: 160 verifiche in 16 fasi, tutte superate all’ultima esecuzione. L’applicazione si installa e si avvia sul simulatore. Qualsiasi affermazione del paragrafo sopra può essere verificata aprendo quattro righe di codice.

Cosa non dice il caso

Non è nell’App Store. La configurazione del progetto ha l’identificatore di team Apple vuoto, quindi il build non può essere firmato per la distribuzione — una mancanza di iscrizione al programma Apple, non una mancanza di funzionalità. E c’è ancora un altro limite, del prodotto e non del codice: misura l’inclinazione della testa, non la salute della colonna, e funziona con le cuffie che espongono sensori di movimento tramite l’interfaccia Apple.

Domande

Cosa ci chiedono le persone prima di chiamare

Avete un’applicazione pubblicata nell’App Store, così posso vederla?

No. Nessuna delle nostre applicazioni è nell’App Store o in Google Play, ed è corretto chiedere questo per prima cosa. Quello che possiamo mostrare: cinque target di applicazione definiti nello stesso progetto, dei quali quattro per iPhone e uno per macOS, che compilano e si installano sul simulatore, più la suite di logica di 160 verifiche, eseguita su richiesta davanti a Lei. Il blocco alla pubblicazione è `DEVELOPMENT_TEAM` vuoto nella configurazione del progetto, cioè l’assenza di un identificatore di team dell’Apple Developer Program. Su Mac esiste un’identità di firma valida, di tipo sviluppo — sufficiente per l’installazione su dispositivo proprio, non per lo store.

Allora da dove so che potete portare un’applicazione fino allo store?

Da nulla, se chiede una prova di pubblicazione — non ne abbiamo una e non la inventiamo. Quello che può verificare è il resto della catena: codice che compila, test che passano, file di privacy presenti, permessi dichiarati, icone e versioni configurate. Il passo che manca è un’iscrizione pagata a un programma Apple, fatta sulla società che possiede l’applicazione. In un progetto di cliente, quell’account è del cliente e si apre all’inizio, proprio per non far sì che sia lui il passo che sorprende qualcuno alla fine.

Nativa o una sola applicazione per iOS e Android?

Dipende dai sensori. Se l’app legge movimento, salute, Bluetooth o fotocamera in tempo reale, nativa — quelle interfacce sono della piattaforma e qualsiasi livello intermedio aggiunge ritardo e nuovi modi di rompersi. Se l’app è essenzialmente moduli, calcoli e schermate di risultato, un solo codice copre iOS, Android e browser da un unico repository. Abbiamo entrambe le varianti nel portafoglio e le scegliamo con un argomento scritto, non per impostazione predefinita.

Realizzate anche app per Android?

Tramite il codice comune, sì: lo stesso progetto Expo produce build per Android, con l’icona adattiva e la variante monocromatica richiesta dal sistema, già configurate. Android nativo, in Kotlin, non è nel nostro portafoglio — se un progetto lo richiede, lo diciamo prima, non dopo la firma.

Come verificate che la logica sia corretta se non avete il mio telefono?

Dal fatto che il nucleo non dipende dallo schermo. I file di analisi si compilano separatamente, con il compilatore Swift, e vengono eseguiti come programma su Mac. L’attuale suite ha 160 verifiche in 16 fasi ed è eseguita in pochi secondi. Ciò che non si può verificare così — come si percepisce una vibrazione, come appare una schermata su un telefono specifico, come si comportano gli auricolari quando escono da un orecchio — si testa sul dispositivo, e si dice chiaramente qual è quale.

L’app può leggere i miei dati in Salute?

Solo se li approva, tipo per tipo, nella schermata Apple, e solo quelli dichiarati. Nel codice la politica è esplicita per ogni tipo di dato: alcuni restano solo sul telefono, altri si leggono da HealthKit, altri possono essere riscritti come allenamento o come sessione di rilassamento. Non si fa diagnosi e i dati non arrivano a noi.

Cosa succede ai dati se l’app non ha un server?

Rimangono sul telefono. Nell’app iOS di riferimento del nostro portfolio non esiste alcuna chiamata di rete — la ricerca di `URLSession` nei sorgenti di quel target restituisce zero risultati. La cronologia viene scritta in un file locale e può essere eliminata dall’app. Quando un progetto ha bisogno di un server, lo costruiamo, ma non lo inseriamo per riflesso.

Possiamo prendere in carico un’app esistente, fatta da altri?

Si comincia con una verifica di compatibilità, non con un’offerta: quale versione della piattaforma punta, quali dipendenze ha e quali di esse sono ancora mantenute, se il build si riproduce su una macchina pulita, chi possiede l’account sviluppatore e le chiavi. Ci sono progetti in cui la risposta onesta è che riscrivere il nucleo costa meno che mantenerlo.

Realizzate anche app desktop?

Su macOS, sì, e dallo stesso nucleo: nel nostro repository principale il target macOS riusa quindici file di logica dall’app per iPhone, come sorgenti condivisi. Windows non è nel portafoglio.

Su cosa si basano le affermazioni sopra (11 fonti)
  1. La variante web dell'applicazione con codice comune risponde oggihttps://longevita-alpha.vercel.app/ · 2026-09-06

10 di esse sono codice e file dei nostri repository. Non ne pubblichiamo il nome né la riga: insieme, in un'unica pagina, descriverebbero con troppa precisione come sono costruiti sistemi che non sono solo nostri. Le esaminiamo con te, nel repository, su richiesta — la verifica resta possibile, solo che avviene in una discussione.

Cosa vorresti che funzionasse meglio?

Raccontaci il tuo processo. Insieme stabiliamo cosa vale la pena costruire, cosa possiamo collegare e come verifichiamo il risultato.

Parliamone