Scanned the two public ARPA Piemonte APIs and recorded what they actually
contain, so this question does not get re-litigated from the marketing pages
later. Neither needs a key, a token or a registration.
This corrects something I got wrong. The docs said ARPA states no licence for
its data, based on the open-data page saying only "gratuiti". The site's legal
notice does state one — CC BY 4.0, commercial use explicitly permitted, credit
"Fonte: Arpa Piemonte - www.arpa.piemonte.it" — and both APIs link that notice
from their OpenAPI description, so anything they serve is covered. Only the
radar volumes remain ambiguous, because their own page does not repeat the
licence and the access link is still issued by email; both questions belong in
the same message to ARPA.
The survey's operative findings:
- api_realtime carries 374 stations with coordinates, of which 286 have a rain
gauge, spanning 74 m to 2820 m of elevation.
- Its observations lag by about 4.5 hours on an hourly cadence, measured
uniformly across every station sampled. That is the property that decides how
it can be used: it is an observation archive with a publishing delay, not a
real-time feed, and it must never sit next to 5-minute radar looking current.
- Only 4 of 143 hydrometer stations publish guard and danger thresholds, and 5
publish a river name. A river-level warning built on this would be empty for
97% of stations, so that idea is recorded as rejected rather than pending.
- Meteoweb is a 3.27-million-record historical archive plus a seismic
catalogue: a research dataset, not app content.
One thing is worth adopting: rain-gauge accumulations as ground truth for the
radar. Radar infers rainfall from reflectivity aloft, gauges measure what
reached the ground, and the network is densest exactly where Alpine terrain
blocks the beam. It belongs behind the worker, clearly timestamped, once the
worker exists.
Also notes that the credit ARPA asks for is the full "Fonte: Arpa Piemonte -
www.arpa.piemonte.it", not the bare name currently in the region config, to be
adopted the moment any ARPA-sourced data is displayed.
No code changes: nothing is integrated yet.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Drops forecasts, lightning, the home-screen widget and advertising. What
remains is radar on a map, the official ARPA alert bulletin, and rain
notifications.
The base map is now OpenFreeMap's Positron style: real OpenStreetMap vector
tiles with no API key, no registration, no request limits and commercial use
permitted. Every other free tier — MapTiler, Stadia, Jawg, Thunderforest —
needs a key, which is a secret to manage, a quota to outgrow and a signup to
complete before anyone can build the project, and the map is the one thing the
app cannot work without. Positron rather than Liberty or Bright because the
radar overlay has to be the loudest thing on screen, and a desaturated grey
base is built to sit under data.
Its style JSON carries no `attribution` field, so MapLibre displays no credits
by itself. The app renders them from the region config instead: the two
mandatory credits, OpenStreetMap and OpenMapTiles, go in the always-visible
bar, and OpenFreeMap's own credit — optional by their terms — is listed on the
Sources screen with the rest. The bundled offline style is still reachable with
MAP_STYLE_URL=offline, and still claims no base map attribution, because
crediting OpenStreetMap while showing it would be a false claim.
Radar-DPC stays the source. ARPA Piemonte's own radar remains a disabled stub
for two reasons that belong to the project owner, not to the code: the
real-time access link is only issued by email, and the open-data page states
the data is "gratuiti" and nothing else. Free of charge is not a licence, and
rendering those volumes into frames served from a CDN is redistribution. Both
questions go in the same email. An earlier draft of the docs recorded ARPA
radar as CC BY 4.0; the source page does not support that, so the claim is
removed rather than carried forward.
The documentation is updated throughout rather than annotated: CLAUDE.md gains
an explicit scope boundary, data-sources drops MET Norway and ISTAT and gains
the base map, licenses records that free of charge is not a licence, privacy
loses the whole advertising section, and the roadmap is renumbered so the
backend worker is next — until it exists, DpcRadarSource has nothing to read.
licenses.md keeps Open-Meteo and Blitzortung listed as excluded even though the
features that would have used them are gone: both are non-commercial-only, ads
are a plausible future, and neither should be adopted on the grounds that there
are none today.
Verified: analyze clean, 130 tests passing, and on the emulator the radar
overlay sits correctly over Piedmont on real OSM tiles with Turin, Milan and
Genoa labelled, the age reads "Aggiornato 4 minuti fa", and the Sources screen
lists all five credits with their licences.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Completes milestone 3: frames render over the map, play as a loop, and can be
scrubbed, with the legend drawn from the manifest rather than a constant that
could drift from what the worker actually rendered.
The overlay alternates two MapLibre image sources. Updating one source in place
flickers, because the layer briefly shows a half-written texture; adding every
frame as its own layer avoids that but pins them all in GPU memory, and twenty
512x512 RGBA frames is about 80 MB. Two buffers cost the same whether the
timeline holds six frames or sixty. Platform-channel work is serialised because
`show` is called faster than the round trip completes during playback, and
overlapping updates would swap visibility out of order and strobe.
Prefetching loads a window around the playhead, nearest first and forward
before backward, since playback moves forward and that frame is needed
soonest. `FrameCache` is byte-budgeted rather than entry-counted because frame
size tracks how much precipitation is on screen, and it evicts by distance from
the playhead: plain LRU would keep frames the prefetcher touched a moment ago
even after the playhead moved to the far end of the timeline.
Also adds DpcRadarSource, which reads published frames from our CDN and never
from the DPC API. Without it, the `dpc` adapter would have had to fall back to
mock, putting demo frames on screen under the label of live data — exactly the
confusion the adapter split exists to prevent. It now fails naming the missing
setting instead.
Running it on the emulator caught three things the tests had not:
- The notifier wrote to `state` from inside `build()`, which Riverpod rejects
as an uninitialised provider. That broke startup, not just tests.
- Eight-month-old demo frames rendered as "Aggiornato 342535 minuti fa". The
age formatter now steps up to hours and days.
- Demo mode sat permanently behind a stale-data warning and so never showed the
working state it exists to demonstrate. MockRadarSource now shifts the
bundled timestamps onto the present, leaving images, order and spacing
untouched, so the timeline behaves exactly as it would on live data.
Corrects docs/stack-decisions.md, which described a disk cache that was not
built: mock frames already live in the asset bundle, so a disk layer belongs
with the network adapter where it would save a real request.
Verified: analyze clean, 129 tests passing, and on the emulator the loop
advances, wraps, and reports "Aggiornato ora".
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
F5 now builds, installs and attaches the debugger on the emulator, with the
emulator booted automatically first, so there is no manual setup step between
opening the project and stepping through code.
tool/start_emulator.ps1 backs the preLaunchTask and is idempotent: it returns in
about three seconds when a device is already attached, so re-launching the
debugger cannot stack emulator instances. It fails with a useful message when
the AVD is missing rather than hanging until a timeout.
Five configurations rather than one, because they answer different questions.
The profile-mode entry matters most for what comes next: debug builds run the
Dart VM unoptimised, so the radar animation always looks worse than it is, and
milestone 3's acceptance criterion is about whether it runs smoothly. The
Windows entry trades the map away for a launch that takes seconds, which is
worth it for pure UI work.
Verified on this machine: the script cold-boots the AVD and waits for
sys.boot_completed, and a second run exits immediately.
Also removes the broken pixel_7_-_api_35 AVD, which could not boot because its
system image was never installed. That returned 4.8 GB, taking free disk from
3.5 GB to 10.7 GB.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The AVD's quickboot snapshot had grown to 2.6 GB, which took this machine down
to 1.4 GB free. Saving a minute of boot time is not worth that here, so cold
boot is now the default and the snapshot directory is gone.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Running the app on an emulator for the first time showed two problems that the
unit tests could not have caught, because both are about what the pixels
actually do.
The configured initial zoom of 7.2 puts the viewport entirely inside the
region on a 411dp-wide screen, so the map rendered as a flat expanse of fill
colour with no outline, border or reference point anywhere in view — it read as
a failure to load. A single zoom number cannot frame a region on both a phone
and a tablet, so the camera now fits the region bounds once the map is ready,
which is correct at any screen size. The configured zoom stays as the starting
position before the fit.
The attribution bar sat behind the system gesture pill. A credit that is
covered by the navigation bar is a credit that is not being displayed, which is
the thing ODbL and CC BY-SA actually require, so it now sits inside a SafeArea.
Also records how to run and screenshot the app on the `nuvolari` AVD, and notes
the pre-existing broken `pixel_7_-_api_35` AVD that is holding 4.8 GB.
Verified on the emulator: the region outline is framed with margin, the
attribution bar is clear of the pill, and the Sources screen shows the
disclaimer, all four credits with their licences, the "no licence stated" line
for ARPA and the share-alike note.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Introduces the RadarSource seam and the manifest it speaks, plus the demo
frames that make the app runnable with no network and no credentials.
MockRadarSource is a real adapter rather than test scaffolding, and that is
what makes the rest of milestone 3 testable: the timeline, prefetching, cache
eviction and every degraded path can be exercised offline because the demo
frames parse the same manifest document the Python worker will publish. Its
assets come from tool/generate_mock_frames.py — committed so the app runs from
a clone, generated by a script so they can be regenerated instead of
hand-edited. Twenty-four 512x512 frames total 108 KB, and the generator is
pure standard library so nobody needs Pillow to build the app.
The manifest parser rejects three things that would otherwise fail silently and
look plausible:
- A CRS other than EPSG:3857. The map overlays each PNG on a lat/lng quad,
which only lines up if the image is already in Web Mercator; anything else
renders visibly skewed with no error to explain why.
- A missing attribution. The frames are a derived product of CC BY-SA data, so
the credit has to travel with them rather than be remembered at render time.
- Legend stops that do not ascend, which would silently mislabel intensities.
The legend travels in the manifest rather than living as a constant here,
because the worker chose those colours when it rendered the PNGs and a local
copy could drift. RadarLegend.colorFor returns null below the lowest stop:
"no precipitation" has to be transparent, not the first colour of the ramp, or
a dry region renders as drizzle everywhere.
Every failure reaches the caller as a single RadarUnavailableException
regardless of cause, because the app's response is the same in all of them —
hold the last good frame and say how old it is — and branching on cause would
only invite divergence.
ArpaRadarSource is a stub whose every method throws. It is named by the region
config as unavailable and must fail loudly: quietly serving something else
would misreport where the data came from.
Verified: analyze clean, 95 tests passing, including a check that every frame
the manifest lists exists and is a real PNG, and that its bbox matches the
region config.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Hiding the NDK and rebuilding showed the build fails without it, and the reason
is not obvious from this repository: maplibre_gl pins ndkVersion 28.2.13676358
in its own build file, and AGP needs every module to agree on one NDK. The app
has no native sources and no Dart FFI, so the declaration reads like dead
configuration and invites exactly the deletion that was just tried.
Costs about 2 GB of Android SDK. Notes the full toolchain disk budget in the
README as well, since a warm Gradle cache plus build output pushes the total to
roughly 14 GB.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Puts a MapLibre map on screen framed on the region, with the credit
obligations that come with showing third-party data satisfied structurally
rather than by remembering to add a label.
The base map style comes from MAP_STYLE_URL, and with no key configured the
app generates a fallback style from the region's own bounding box: a flat
background and the extent outline, no network sources at all. That keeps a
fresh clone runnable offline without pulling in a boundary dataset that would
carry its own licence, and it deliberately looks like a placeholder so it is
not mistaken for a finished map.
Attribution is driven by what is actually rendered. The bar lists the credits
for the active sources only, because crediting OpenStreetMap while showing the
fallback style would be a false attribution, and it says plainly when no base
map is configured. It sits below the map rather than floating over it so no
map control or gesture overlay can occlude a credit that the ODbL and CC BY-SA
terms require to be visible.
The Sources screen leads with the independence disclaimer, before the sources
it qualifies, so a reader who stops after the first screenful has still seen
it. Sources with no stated licence — ARPA publishes none for the alert
bulletin — say so explicitly rather than being shown bare or given an invented
one. A separate note explains that the rendered radar frames inherit CC BY-SA
from the DPC source data.
Also declares the INTERNET permission in the main manifest: Flutter injects it
into the debug and profile manifests only, so a release build would otherwise
fail every request on device.
Verified: analyze clean, 66 tests passing, appbundle builds with the native
MapLibre plugin. Not verified visually — this machine has no Android device or
emulator image, so nobody has watched the map render.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Creates the app skeleton and the seam everything else in the project hangs
off: region-specific data lives in an asset file, not in code, so adding a
region later is a new JSON file rather than a refactor.
Notable choices:
- applicationId and namespace are it.nuvolari.app rather than the doubled
it.nuvolari.nuvolari that `flutter create` produces, with the Kotlin package
and the iOS bundle identifiers moved to match.
- SDK levels are pinned instead of inherited from `flutter.*`. Google Play
requires API 36, and that is a release blocker rather than something to let a
Flutter upgrade change silently. minSdk 24 is the highest floor the planned
dependencies impose.
- Riverpod and Dio-free for now, no code generation: see docs/stack-decisions.md.
- Italian is the l10n source language, so app_it.arb is the template rather
than a translation of an English original.
The region parser rejects rather than repairs. An inverted bounding box, a map
centre outside its own bounds, an unknown adapter name, a duplicate zone code
or an empty attribution list all throw with the offending field named. Each of
those would otherwise fail silently and visibly wrong: a swapped latitude and
longitude renders the radar in the wrong place, an unknown adapter falling back
to mock would show demo frames where live data was expected, and a missing
attribution is a licence violation rather than a cosmetic gap.
Tests run against the asset that actually ships and against a captured copy of
the live ARPA CAP feed, so the eleven zone codes in the config are checked
against the eleven the feed really emits rather than against a list retyped
from documentation.
Verified: dart format clean, flutter analyze 0 issues, 50 tests passing,
flutter build appbundle --debug produces an AAB with applicationId
it.nuvolari.app, minSdk 24, targetSdk 36.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Sets up the Nuvolari monorepo layout (app/, backend/, docs/, tool/) with the
groundwork that does not depend on the Flutter toolchain: gitignore covering
Flutter, Python and every secret file shape; env.example.json as the template
for --dart-define-from-file; a verification script that skips stages whose
target does not exist yet so it is runnable from day one; and a CI workflow in
GitHub Actions syntax so it runs unchanged on Gitea or GitHub.
The documentation records facts verified against the live services rather than
restated from the brief. Two of them change the design:
- DPC VMI rasters are 1200x1400 Float32 on a 1 km grid in a custom projection
centred on Italy, not EPSG:4326 or EPSG:3857, and their GeoKeys are
internally inconsistent. Reprojection is mandatory and the source CRS must be
read from each file rather than hardcoded.
- The ARPA CAP feed carries six level values, not four: BIANCO for the
avalanche scale out of season and "-" for no data. Collapsing either into
VERDE would report "no alert" where the bulletin reports "not assessed".
Also documents why the frames we publish inherit CC BY-SA from the DPC source,
and why rain notifications subscribe to cell topics from the device so no user
location ever reaches a server.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The Nuvolari app is being rebuilt as a Flutter project targeting Android
first and iOS later on a single codebase, so the original Xamarin.Android
skeleton no longer applies. Its files were already removed from the working
tree; this records the removal.
Adds CLAUDE.md with the golden rules that constrain the rewrite: English
code and commit messages with Italian UI via ARB, no secrets in the repo,
AdMob test IDs only, no direct polling of ARPA/DPC from the app, and no
server-side precise user locations.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Implementate le configurazioni iniziali in `AndroidManifest.xml` e `Nuvolari.csproj`.
Creata la classe `MainActivity` per gestire la mappa con `SearchView` per la ricerca di luoghi.
Definiti i layout in `activity_main.axml` e `activity_main.xml`.
Aggiunti file di risorse per le icone dell'app e creato `ic_launcher_background.xml` per il colore di sfondo.
Definiti i testi dell'app in `strings.xml`.
Alby96andClaude Opus 5