La mappa di Google, i miei autovelox, un’app sola
Sullo schermo dell’auto volevo una cosa sola. La mappa di Google, il traffico di Google e le indicazioni svolta per svolta di Google, con sopra i miei dati sugli autovelox, che mi avvisassero solo per gli autovelox puntati davvero sul mio lato della strada.
Su Android Auto non ho trovato niente che lo facesse. Google Maps ha la mappa e i percorsi, ma non c’è modo di caricarci dentro un proprio database di autovelox. Quindi me lo sto costruendo.
Si chiama AutoNavAlerts. È un’app di navigazione per Android Auto costruita sul Navigation SDK di Google, con sopra un sistema di avvisi per autovelox e punti di interesse. La prima fonte di autovelox è PocketGPSWorld, con il mio abbonamento a pagamento. Il codice è pubblico con licenza Apache 2.01 su github.com/damo2929/AutoNavAlerts.
Questa è la prima parte di una serie. Racconta cosa fa l’app, cosa Google permette e non permette a un’app di terze parti sullo schermo dell’auto, e come è stata costruita, perché quasi ogni riga è stata scritta da Claude, il modello di intelligenza artificiale di Anthropic, mentre io fissavo le regole, la collaudavo e mi prendevo la responsabilità del risultato. Quest’ultima parte è una storia a sé.
È la versione 0.1.0. Si installa a mano, non è sul Play Store, e ha fatto un solo viaggio vero. Leggila come un diario di lavoro, non come il lancio di un prodotto.
Cosa fa oggi
Ecco cosa c’è nella build di prova e a cosa serve ogni parte:
| Area | Cosa fa |
|---|---|
| Navigazione | Mappa di Google con traffico, ricerca dei luoghi, anteprima del percorso con l’orario di arrivo, svolta per svolta sullo schermo dell’auto, sulla barra laterale e sul display del conducente |
| Guida verso un contatto | Di’ o scrivi un nome e gli indirizzi salvati del contatto compaiono sopra i risultati di Places. A Google va solo l’indirizzo che scegli |
| Convive con la tua musica | Solo modelli di navigazione, così la musica tiene la sua scheda a schermo diviso. La voce degli avvisi abbassa la musica, non la mette mai in pausa |
| Avvisi autovelox | Tre fasi per autovelox, solo per quelli rivolti nella tua direzione di marcia, sulla strada che stai percorrendo |
| Zone di velocità media | Una zona parte solo quando davanti a te c’è un altro autovelox con lo stesso limite, e finisce all’ultimo autovelox |
| Pannello velocità | La tua velocità e il limite della strada, sempre affiancati, in basso a destra |
| Limiti di velocità offline | Un solo download dei limiti OpenStreetMap per il Regno Unito: 1.326.619 strade in 29 MB sul telefono. Niente da cercare mentre guidi |
| Percorsi per auto elettriche | Il percorso più veloce e quello a basso consumo di Google affiancati, e scegli tu |
| Dati autovelox | Il tuo abbonamento PocketGPSWorld, controllato ogni giorno, mai sostituito mentre navighi. Oppure importa file iGO, KML, GPX, OV2 o CSV |
| Segnala un autovelox | Un tocco in auto salva posizione, direzione e limite, con un commento vocale facoltativo. Revisione e invio si fanno sul telefono, mai durante la guida |
Gli avvisi degli autovelox sono il motivo per cui l’app esiste, quindi si prendono la sezione successiva.
Un autovelox conta solo se è rivolto verso di te
Un avviso che scatta per la carreggiata opposta è peggio di nessun avviso. Ti abitua a ignorarlo. Quindi la prima regola ferrea del progetto è che un autovelox avvisa solo quando è rivolto nella tua direzione di marcia, e quella regola non viene mai allentata, mai aggirata con un valore predefinito e mai abbandonata quando i dati sono scomodi.
Il motore gira a ogni posizione rilevata, fino a dieci al secondo. Per ogni autovelox vicino si fa quattro domande, in ordine:
| Controllo | Passa quando | Perché c’è |
|---|---|---|
| Abbastanza vicino | entro la distanza di attivazione più 200 m, al massimo 3 km | nessun lavoro sprecato su autovelox a chilometri di distanza |
| Davanti a te | rotta verso l’autovelox entro 45° dalla tua direzione | un autovelox alle spalle è passato |
| Rivolto verso di te | la direzione dell’autovelox entro 45° dalla tua, o dalla rotta verso l’autovelox in curva | la carreggiata opposta resta muta |
| Sulla tua strada | entro 50 m dal percorso davanti, o un corridoio di 40 m che si allarga con la distanza in guida libera | la strada parallela resta muta |
I 45° non sono generosi. I file TomTom di PocketGPSWorld danno la direzione di un autovelox in otto punti cardinali, quindi 22,5° se ne vanno nei dati prima di tutto il resto. La direzione GPS costa qualche grado in più, e la curva della strada qualche altro ancora. Ecco perché a nient’altro è permesso di eroderli.
Un autovelox che non supera il controllo di direzione viene comunque disegnato sulla mappa, attenuato, con una freccia che mostra dove guarda. Lo vedi. Solo che non ti parla.
Le fasi sono a tempo, non a distanze fisse. Il primo avviso arriva 15 secondi prima alla tua velocità attuale e il secondo a metà di quel tempo, entrambi con un minimo perché non si accalchino mai sul terzo. Il terzo è fisso a 100 yard, ed è obbligatorio ogni volta che l’audio è attivo. La distanza di attivazione cresce soltanto durante un avvicinamento, quindi frenare forte non accorcia l’avviso che ti spettava già.
Cosa Google lascia fare a un’app sullo schermo dell’auto
Qui diventa interessante, perché un’app di terze parti su Android Auto non è Google Maps. Gira dentro le regole fissate dalla Car App Library di Android Auto, che dà alle app «a set of visual templates approved for driver safety»2, e dentro quello che il Navigation SDK sceglie di esporre.
Tre lacune hanno dato forma all’app più di qualunque cosa io abbia scelto di costruire:
| Cosa | Google Maps in auto | Un’app sul Navigation SDK |
|---|---|---|
| Segnalare un incidente, la polizia o lavori in corso | integrato | non offerto. La documentazione di Google: «real-time disruptions are not available on Android Auto»3 |
| Il limite di velocità della strada | mostrato | solo la percentuale di quanto lo superi, e solo mentre lo superi4 |
| Il tocco sui controlli della mappa dell’SDK | non pertinente | nessuno. Android Auto «limits screen surface interaction to a series of SurfaceCallback methods»2 |
Prendi il limite di velocità. Google lo conosce. Google dice a un’app di quanto lo stai superando, come percentuale e come gravità, e niente del tutto mentre sei sotto. Posso chiedere perché un conducente può conoscere il limite solo quando lo sta già infrangendo? Una risposta non l’avrò, quindi l’app ci gira intorno. Mentre sei sopra, ricava il limite dalla tua velocità e dalla percentuale. Sotto, usa l’autovelox a cui ti stai avvicinando, poi il download di OpenStreetMap, e mostra un trattino invece di niente quando non ha alcun limite.
La segnalazione degli incidenti ha la stessa forma. Le API di segnalazione esistono nella vista di navigazione del telefono e non in quella dell’auto. Qualcuno l’ha già chiesto a Google5, e la richiesta è ancora aperta. L’app controlla le API in fase di esecuzione, quindi se un SDK futuro le aggiunge, il pulsante di segnalazione di Google compare senza alcuna modifica al mio codice. Un job di GitHub Actions controlla ogni trimestre e apre una issue il giorno in cui succede.
La regola sul tocco mi ha fregato per bene. La mappa dell’SDK per l’auto disegna da sé la scheda di arrivo, l’intestazione, il pulsante per ricentrare, il tachimetro e la barra del viaggio. Nessuno di questi può ricevere un tocco, perché nessun tocco arriva alla vista dell’SDK. Sembrano pulsanti e non fanno nulla. Quindi sono tutti spenti, e l’app disegna i propri controlli dove un tocco arriva davvero.
Porta la tua chiave, porta i tuoi dati
Due decisioni tengono quest’app onesta su soldi e licenze, ed entrambe sono volute.
Non c’è una chiave Maps integrata. Google Maps Platform richiede «a billing-enabled Cloud project»6, e il Navigation SDK richiede un progetto in cui sia abilitato7. Se distribuissi una chiave, la guida di tutti verrebbe addebitata a me, oppure la chiave finirebbe in giro e verrebbe addebitata a me lo stesso. Quindi ogni utente porta la sua chiave, nel suo account Google Cloud. L’app sul telefono può crearne una con il tuo account Google, oppure la incolli tu. Viene salvata cifrata sul telefono. Non c’è alcun ripiego, e l’app non fa una sola chiamata all’SDK finché la tua chiave non c’è.
Nell’app non ci sono dati sugli autovelox. PocketGPSWorld concede il suo database in licenza per uso individuale, marca ogni download con il nome dell’iscritto e vieta di metterlo dove possa arrivarci chiunque non sia l’acquirente. Quindi l’app non lo distribuisce, non lo ospita e non lo sincronizza tra telefoni. Accedi con il tuo abbonamento, e il telefono scarica la tua copia marcata in una memoria privata esclusa dai backup. Al banco erano 19.826 autovelox in 33 set, un set per file, mai uniti.
La sincronizzazione automatica è educata. Legge il feed RSS pubblico di PocketGPSWorld una volta al giorno8 e accede solo quando c’è una nuova versione. Non sostituisce mai gli autovelox mentre stai navigando.
Una clausola della loro licenza non è del tutto risolta da questo, quella sull’incorporare i dati in un’applicazione. Per il mio uso personale lo accetto. Prima che l’app vada a chiunque altro, PocketGPSWorld riceverà un’email con la domanda.
Due giorni, 87 commit, e prima un documento di progetto
Ora la parte su cui si discuterà. Questo codice non l’ho scritto io. L’ha scritto Claude, tramite Claude Code, con due modelli, Claude Fable e Claude Opus. Io ho scritto i requisiti, preso ogni decisione, gestito il banco di prova, guidato l’auto e rivisto quello che tornava indietro. Ogni commit con modifiche scritte dall’IA porta una riga finale che lo dice, e lo dice anche il README.
Questi sono i numeri, letti dal repository:
| Misura | Valore |
|---|---|
| Commit | 87, dalle 22:10 dell'11 ottobre alle 12:44 del 13 ottobre 2026 |
| Commit con una riga di coautore Claude | 83 (56 Fable, 27 Opus) |
| Kotlin nell’app e nella sua libreria di base | 15.334 righe |
| Test unitari | 211, in 3.464 righe |
DESIGN.md, la specifica | 1.763 righe, scritte prima di qualunque codice |
Il documento di progetto è venuto prima, ed è la cosa più utile che posso dire a chiunque lo faccia. La sua prima riga dice che nessun codice si scrive finché non è approvato, e ogni modifica successiva si fa prima lì. Ogni classe ha un compito scritto accanto. Ogni soglia ha una ragione. Ogni regola che ho fissato è segnata come mia, con la data.
Conta perché un modello dimentica. Una sessione lunga viene riassunta, e il riassunto tiene il succo e perde il dettaglio, e il dettaglio è dove stanno i bug. Lo stesso AGENTS.md del repository lo dice chiaro: non fidarti di un riassunto di questi file a memoria o da una sessione precedente. L’agente torna al documento. Ogni volta.
Due agenti hanno anche lavorato in parallelo sulla seconda fase, uno sulle indicazioni, la mappa e le schermate, l’altro su posizione, avvisi, voce e marcatori sulla mappa. Ognuno aveva una lista scritta di file, e le interfacce tra loro erano fissate in anticipo: aggiungere, non rinominare. Si sono uniti senza intoppi perché il confine era stato deciso prima che uno dei due partisse, non scoperto dopo.
Ogni regola ferrea nasce da qualcosa che ho visto
Il progetto ha una lista di regole ferree, e nessuna è nata davanti a una lavagna. Ognuna è nata guardando la cosa girare sul Desktop Head Unit9, l’emulatore di Google per lo schermo dell’auto sul PC, o in auto, e vedendola fare qualcosa di sbagliato.
| Regola ferrea | Cosa ho visto che l’ha resa una regola |
|---|---|
| Un autovelox avvisa solo quando è rivolto verso di te | gli avvisi per la carreggiata opposta sono rumore che ti insegna a ignorare gli avvisi |
| Niente sullo schermo dell’auto che non funzioni | due pulsanti di stop a schermo, uno dei due morto |
| Nessuna funzione mostrata due volte | quella stessa coppia, più due pulsanti per ricentrare, due indicatori di velocità |
| Un solo annulla, quello di Google | la scheda nell’angolo con la X è di Android Auto, disegnata dal viaggio che l’app pubblica, quindi il pulsante di stop dell’app se n’è andato |
| Niente tremolio sullo schermo dell’auto | la schermata Altro che sobbalzava con l’auto ferma, perché rimandava una schermata identica ogni secondo e Android Auto anima ogni aggiornamento |
| Ogni pulsante sul lato destro | i pulsanti della mappa stavano in alto a sinistra finché lo schermo dell’auto non comunicava le sue dimensioni; ora una colonna sul bordo destro fin dall’inizio, niente di nostro a sinistra |
| Nessuna chiave Maps integrata, mai | la guida di nessuno viene addebitata a qualcun altro |
Il tremolio è il mio preferito, perché è così piccolo e sarebbe arrivato in produzione. Una riga GPS dal vivo si aggiornava una volta al secondo. A ogni aggiornamento veniva rimandata tutta la schermata, invariata, e l’host la animava, così ogni riga sotto ballava mentre l’auto era ferma. La correzione è un solo confronto: ridisegna solo quando una riga è cambiata. La regola è più grande della correzione. Una schermata che sta ferma deve sembrare ferma, e si verifica con una raffica di screenshot che devono essere identici.
Questo è il vero lavoro quando il codice lo scrive un’IA. Non si stanca e non le pesa riscrivere, ma lo schermo dell’auto non lo vede. Tu sì. Scrivere ciò che hai visto come regola, con la data, è quello che gli impedisce di tornare tre sessioni dopo.
Cosa ha sbagliato il codice, e come è stato scoperto
Parecchio. Niente di esotico, e ogni errore è stato scoperto facendolo girare, non leggendolo:
| Difetto | Cosa faceva | Come è stato scoperto |
|---|---|---|
| Percorso agganciato al tratto sbagliato | Il percorso di Google da un’auto parcheggiata andava a nord, faceva inversione a una rotatoria e tornava a sud sulla stessa strada. Il matcher fissava l’auto al tratto verso nord a 10 m di distanza, quindi ogni autovelox verso sud risultava «fuori strada» di oltre un chilometro. Non avvisava niente | una guida simulata al banco; il registro degli avvisi diceva offRoad lateral=1204 per ogni autovelox |
| Watchdog della voce troppo corto | concedeva 1,5 s più 70 ms per carattere. I numeri richiedono più tempo per essere pronunciati, quindi ogni avviso di seconda fase veniva troncato a metà frase | le registrazioni vocali di una prova al banco |
| Un limite di frequenza nel motore | con una finestra di tre secondi, di due autovelox allo stesso incrocio, uno andava perso per sempre | seguendo gli avvisi rimasti muti nel primo viaggio vero |
| Una direzione vecchia | l’emulatore riporta una rotta di 0° qualunque cosa tu faccia, quindi su una strada verso sud ogni autovelox falliva il controllo di direzione | una corsa simulata lungo la A61 |
| Cambi di limite annunciati come avvisi autovelox | un cambio di limite più avanti veniva accodato come avviso autovelox di prima fase | il registro vocale al banco |
Il secondo merita una pausa. Ogni singolo test passava. Il codice era corretto secondo il suo stesso metro. Aveva solo un timeout scelto da qualcuno che non aveva mai sentito un telefono leggere una distanza ad alta voce. Il test che lo scopre è una voce vera, cronometrata, in una corsa vera.
Il primo viaggio vero
Il 12 ottobre ho messo una build di rilascio sul telefono e l’ho portata in giro sulla XPENG G6 con Android Auto senza fili. Due cose sono andate storte. Un percorso impostato da fermo si cancellava da solo pochi secondi dopo la partenza. E alcuni avvisi venivano pronunciati e altri no, senza uno schema che riuscissi a vedere.
Poi il problema peggiore. Non era rimasto niente da leggere. Il ColorOS del mio telefono butta via le righe di log dell’app, quindi il viaggio non ha lasciato alcuna prova. Era l’app, l’SDK di Google o Android Auto stesso? Non sapevo dirlo.
Quindi la correzione per il primo viaggio non è stata una modifica al codice. È stata la prova. L’app ora scrive sempre due log sul telefono, uno per percorsi e mappa e uno per ogni decisione sugli avvisi, a blocchi di 15 secondi, più un registratore di viaggio facoltativo che salva ogni posizione così un viaggio si può riprodurre al banco. Poi le ipotesi sono state corrette, ognuna scritta per fare meno e registrare di averlo fatto. Ogni modo in cui la guida può terminare ora registra chi l’ha terminata.
Da allora, al banco, Android Auto ha chiamato lo stop una volta, 2 minuti e 35 secondi dentro una guida assistita. In quel momento stavo cliccando in giro sull’head unit, quindi molto probabilmente era la X sulla sua scheda. Non è successo con nessuno che toccasse lo schermo. Il prossimo viaggio lo chiarirà, perché questa volta il viaggio lascia una traccia.
Cosa viene dopo
La lista del banco è ancora lunga. I prossimi viaggi verificano il pulsante annulla, le curve e i contromano, il passaggio tra il GPS dell’auto e quello del telefono, e se il display del conducente della G6 mostra davvero le schede di svolta di un’app di terze parti.
Le parti successive della serie entrano come si deve nella matematica del motore degli avvisi, nei trucchi per il limite di velocità, nei formati di PocketGPSWorld e nel banco stesso: come si collauda un’app Android Auto senza auto, con un GPS scriptato e un emulatore convinto che ogni strada vada a nord.
La macchina scrive, lo standard è tuo
Ho sentito parlare molto di IA che scrive codice, quasi sempre da chi la vende o da chi ne ha paura. Quello che ho trovato è più noioso di entrambe le cose, e più utile.
Scrive in fretta e non si annoia. Riscrive una schermata per la quarta volta senza un sospiro. Quello che non fa è accorgersi che la schermata Altro trema, o che una frase è stata troncata, o che un pulsante morto sta accanto a uno vivo. L’auto non la vede. Quelle cose toccava a me vederle, e l’unico motivo per cui sono corrette è che le ho scritte una per una come regole che deve leggere prima di toccare qualsiasi cosa.
Per questo la responsabilità non si sposta. Il codice è mio perché lo standard a cui è tenuto l’ho fissato io e in auto ci sono io. Niente di ciò che l’ha tenuto onesto è un metodo da IA. Scrivere la specifica prima del codice, mettere per iscritto ciò che impari e tenere le prove invece di tirare a indovinare è come l’ingegneria fatta bene si è sempre fatta. Lo strumento non lo cambia. Fa solo scoprire prima chi se lo stava saltando.
Apache License, Version 2.0 — la licenza con cui è pubblicato il codice di AutoNavAlerts. ↩︎
Google — Navigation SDK for Android: Android Auto — la Car App Library fornisce «a set of visual templates approved for driver safety», e «Android Auto limits screen surface interaction to a series of SurfaceCallback methods». ↩︎ ↩︎
Google — Navigation SDK for Android: real-time disruptions — «real-time disruptions are not available on Android Auto». ↩︎
Google — Navigation SDK for Android: speed alerts —
onSpeedingUpdated(float percentageAboveLimit, SpeedAlertSeverity speedAlertSeverity): la percentuale oltre il limite e una gravità, non il limite stesso. ↩︎googlemaps/flutter-navigation-sdk issue #726 — «Incident reporting on Android Auto & CarPlay», aperta il 17 giugno 2026, ancora aperta. ↩︎
Google Maps Platform — Get started — «you must create a billing-enabled Cloud project and enable the desired APIs or SDKs». ↩︎
Google — Navigation SDK for Android: set up your project — «A Google Cloud console project with the Navigation SDK enabled.» ↩︎
PocketGPSWorld — il database britannico degli autovelox da cui l’app si sincronizza, con l’abbonamento personale di ciascun utente. ↩︎
Android Developers — Test using the Desktop Head Unit — l’emulatore di Google per lo schermo di Android Auto. ↩︎