Animate the radar timeline with a double-buffered overlay
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>
This commit is contained in:
Claude Opus 5
@@ -0,0 +1,71 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:nuvolari/features/timeline/data_age_banner.dart';
|
||||
import 'package:nuvolari/l10n/app_localizations.dart';
|
||||
|
||||
void main() {
|
||||
late AppLocalizations l10n;
|
||||
|
||||
setUpAll(() async {
|
||||
l10n = await AppLocalizations.delegate.load(const Locale('it'));
|
||||
});
|
||||
|
||||
group('formatDataAge', () {
|
||||
test('uses minutes below an hour', () {
|
||||
expect(formatDataAge(l10n, Duration.zero), 'Aggiornato ora');
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(minutes: 1)),
|
||||
'Aggiornato 1 minuto fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(minutes: 42)),
|
||||
'Aggiornato 42 minuti fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(minutes: 59, seconds: 59)),
|
||||
'Aggiornato 59 minuti fa',
|
||||
);
|
||||
});
|
||||
|
||||
test('switches to hours at the hour mark', () {
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(hours: 1)),
|
||||
'Aggiornato 1 ora fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(hours: 5, minutes: 30)),
|
||||
'Aggiornato 5 ore fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(hours: 23, minutes: 59)),
|
||||
'Aggiornato 23 ore fa',
|
||||
);
|
||||
});
|
||||
|
||||
// The bug this replaced rendered eight-month-old demo data as "Aggiornato
|
||||
// 342535 minuti fa", a number nobody converts in their head.
|
||||
test('switches to days beyond a day', () {
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(days: 1)),
|
||||
'Aggiornato 1 giorno fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(days: 4)),
|
||||
'Aggiornato 4 giorni fa',
|
||||
);
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(days: 238)),
|
||||
'Aggiornato 238 giorni fa',
|
||||
);
|
||||
});
|
||||
|
||||
// Clock skew, or a worker publishing a frame stamped slightly ahead, must
|
||||
// not produce "Aggiornato -3 minuti fa".
|
||||
test('treats a negative age as now', () {
|
||||
expect(
|
||||
formatDataAge(l10n, const Duration(minutes: -5)),
|
||||
'Aggiornato ora',
|
||||
);
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,350 @@
|
||||
import 'dart:convert';
|
||||
import 'dart:io';
|
||||
import 'dart:typed_data';
|
||||
|
||||
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:nuvolari/core/region/region_config.dart';
|
||||
import 'package:nuvolari/core/region/region_repository.dart';
|
||||
import 'package:nuvolari/data/radar/radar_manifest.dart';
|
||||
import 'package:nuvolari/data/radar/radar_source.dart';
|
||||
import 'package:nuvolari/features/timeline/radar_timeline.dart';
|
||||
|
||||
/// A radar source with no assets and no network, so timeline behaviour can be
|
||||
/// driven precisely: which frames exist, which of them fail, and how slowly
|
||||
/// each one arrives.
|
||||
class FakeRadarSource implements RadarSource {
|
||||
FakeRadarSource({
|
||||
this.frameCount = 12,
|
||||
this.failingPaths = const <String>{},
|
||||
this.manifestFails = false,
|
||||
this.frameDelay = Duration.zero,
|
||||
});
|
||||
|
||||
final int frameCount;
|
||||
final Set<String> failingPaths;
|
||||
final bool manifestFails;
|
||||
final Duration frameDelay;
|
||||
|
||||
final List<String> requestedPaths = <String>[];
|
||||
int manifestCalls = 0;
|
||||
|
||||
static const int baseTimestamp = 1768478400000;
|
||||
|
||||
RadarManifest _build() {
|
||||
final frames = <Map<String, Object?>>[
|
||||
for (var i = 0; i < frameCount; i++)
|
||||
<String, Object?>{
|
||||
'ts': baseTimestamp + i * 5 * 60 * 1000,
|
||||
'url': 'frames/$i.png',
|
||||
},
|
||||
];
|
||||
return RadarManifest.parse(
|
||||
jsonEncode(<String, Object?>{
|
||||
'region': 'piemonte',
|
||||
'product': 'VMI',
|
||||
'generatedAt': baseTimestamp + (frameCount - 1) * 5 * 60 * 1000,
|
||||
'bbox': <double>[6.55, 43.95, 9.30, 46.55],
|
||||
'crs': 'EPSG:3857',
|
||||
'frames': frames,
|
||||
'legend': <String, Object?>{
|
||||
'unit': 'dBZ',
|
||||
'stops': <Object?>[
|
||||
<String, Object?>{'value': 5, 'color': '#4FA3D1'},
|
||||
],
|
||||
},
|
||||
'attribution': 'Test data',
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
@override
|
||||
Future<RadarManifest> getLatestManifest() async {
|
||||
manifestCalls++;
|
||||
if (manifestFails) {
|
||||
throw const RadarUnavailableException('fake manifest failure');
|
||||
}
|
||||
return _build();
|
||||
}
|
||||
|
||||
@override
|
||||
Future<List<RadarFrame>> getFrames() async =>
|
||||
(await getLatestManifest()).frames;
|
||||
|
||||
@override
|
||||
Future<Uint8List> loadFrameBytes(RadarFrame frame) async {
|
||||
requestedPaths.add(frame.path);
|
||||
if (frameDelay > Duration.zero) {
|
||||
await Future<void>.delayed(frameDelay);
|
||||
}
|
||||
if (failingPaths.contains(frame.path)) {
|
||||
throw RadarUnavailableException('fake failure for ${frame.path}');
|
||||
}
|
||||
return Uint8List.fromList(List<int>.filled(64, 1));
|
||||
}
|
||||
}
|
||||
|
||||
RegionConfig loadPiemonte() =>
|
||||
RegionConfig.parse(File('assets/regions/piemonte.json').readAsStringSync());
|
||||
|
||||
ProviderContainer containerWith(RadarSource source, RegionConfig region) {
|
||||
final container = ProviderContainer(
|
||||
overrides: [
|
||||
regionConfigProvider.overrideWith((ref) async => region),
|
||||
radarSourceProvider.overrideWith((ref) async => source),
|
||||
],
|
||||
);
|
||||
addTearDown(container.dispose);
|
||||
return container;
|
||||
}
|
||||
|
||||
/// Waits until the timeline has finished its initial load.
|
||||
Future<RadarTimelineState> settled(ProviderContainer container) async {
|
||||
for (var i = 0; i < 200; i++) {
|
||||
final state = container.read(radarTimelineProvider);
|
||||
if (!state.isLoading) return state;
|
||||
await Future<void>.delayed(const Duration(milliseconds: 5));
|
||||
}
|
||||
fail('timeline never finished loading');
|
||||
}
|
||||
|
||||
void main() {
|
||||
late RegionConfig region;
|
||||
|
||||
setUpAll(() {
|
||||
region = loadPiemonte();
|
||||
});
|
||||
|
||||
group('initial load', () {
|
||||
test('loads the manifest and lands on the newest frame', () async {
|
||||
final source = FakeRadarSource(frameCount: 12);
|
||||
final container = containerWith(source, region);
|
||||
|
||||
final state = await settled(container);
|
||||
|
||||
expect(state.manifest, isNotNull);
|
||||
expect(state.frameCount, 12);
|
||||
// Someone opening the app wants to know what the sky is doing now.
|
||||
expect(state.index, 11);
|
||||
expect(state.isAtNewestFrame, isTrue);
|
||||
expect(state.error, isNull);
|
||||
});
|
||||
|
||||
test('prefetches the frames around the playhead', () async {
|
||||
final source = FakeRadarSource(frameCount: 12);
|
||||
final container = containerWith(source, region);
|
||||
|
||||
await settled(container);
|
||||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||||
|
||||
// Playhead at 11 with a radius of 4: frames 7..11, and nothing beyond.
|
||||
expect(source.requestedPaths, contains('frames/11.png'));
|
||||
expect(source.requestedPaths, contains('frames/7.png'));
|
||||
expect(source.requestedPaths, isNot(contains('frames/6.png')));
|
||||
});
|
||||
|
||||
test('an empty manifest is not an error', () async {
|
||||
final source = FakeRadarSource(frameCount: 0);
|
||||
final container = containerWith(source, region);
|
||||
|
||||
final state = await settled(container);
|
||||
|
||||
expect(state.hasFrames, isFalse);
|
||||
expect(state.error, isNull);
|
||||
expect(state.currentFrame, isNull);
|
||||
});
|
||||
});
|
||||
|
||||
group('degradation', () {
|
||||
test('a failed manifest load surfaces as an error', () async {
|
||||
final source = FakeRadarSource(manifestFails: true);
|
||||
final container = containerWith(source, region);
|
||||
|
||||
final state = await settled(container);
|
||||
|
||||
expect(state.error, isA<RadarUnavailableException>());
|
||||
expect(state.manifest, isNull);
|
||||
});
|
||||
|
||||
// The whole point of holding the last good manifest: stale frames with
|
||||
// their age stated beat an empty map.
|
||||
test('a later failure keeps the manifest already on screen', () async {
|
||||
final source = FakeRadarSource(frameCount: 6);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final failing = FakeRadarSource(manifestFails: true);
|
||||
container.updateOverrides([
|
||||
regionConfigProvider.overrideWith((ref) async => region),
|
||||
radarSourceProvider.overrideWith((ref) async => failing),
|
||||
]);
|
||||
// The notifier memoises its source, so drive the failure through the
|
||||
// instance it already holds by refreshing after the override.
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
await timeline.refresh();
|
||||
|
||||
final state = container.read(radarTimelineProvider);
|
||||
expect(state.manifest, isNotNull, reason: 'stale data must be kept');
|
||||
expect(state.frameCount, 6);
|
||||
});
|
||||
|
||||
// A gap mid-timeline is normal while the worker publishes. It must not
|
||||
// abort the surrounding prefetch.
|
||||
test('one missing frame does not stop the others loading', () async {
|
||||
final source = FakeRadarSource(
|
||||
frameCount: 8,
|
||||
failingPaths: const {'frames/5.png'},
|
||||
);
|
||||
final container = containerWith(source, region);
|
||||
|
||||
await settled(container);
|
||||
await Future<void>.delayed(const Duration(milliseconds: 50));
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
expect(timeline.cache.contains('frames/5.png'), isFalse);
|
||||
expect(timeline.cache.contains('frames/7.png'), isTrue);
|
||||
expect(timeline.cache.contains('frames/4.png'), isTrue);
|
||||
});
|
||||
});
|
||||
|
||||
group('playback', () {
|
||||
test('play advances the playhead and wraps around', () async {
|
||||
final source = FakeRadarSource(frameCount: 3);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
expect(container.read(radarTimelineProvider).index, 2);
|
||||
|
||||
timeline.play();
|
||||
expect(container.read(radarTimelineProvider).isPlaying, isTrue);
|
||||
|
||||
// Index 2 is the newest frame, so the longer dwell applies first.
|
||||
await Future<void>.delayed(
|
||||
RadarTimeline.lastFrameDwell + const Duration(milliseconds: 150),
|
||||
);
|
||||
expect(container.read(radarTimelineProvider).index, 0);
|
||||
|
||||
await Future<void>.delayed(
|
||||
RadarTimeline.framePeriod + const Duration(milliseconds: 150),
|
||||
);
|
||||
expect(container.read(radarTimelineProvider).index, 1);
|
||||
|
||||
timeline.pause();
|
||||
});
|
||||
|
||||
test('pause stops the playhead', () async {
|
||||
final source = FakeRadarSource(frameCount: 6);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
timeline.play();
|
||||
timeline.pause();
|
||||
final frozen = container.read(radarTimelineProvider).index;
|
||||
|
||||
await Future<void>.delayed(
|
||||
RadarTimeline.lastFrameDwell + const Duration(milliseconds: 200),
|
||||
);
|
||||
|
||||
expect(container.read(radarTimelineProvider).isPlaying, isFalse);
|
||||
expect(container.read(radarTimelineProvider).index, frozen);
|
||||
});
|
||||
|
||||
test('play does nothing when there are no frames', () async {
|
||||
final source = FakeRadarSource(frameCount: 0);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
container.read(radarTimelineProvider.notifier).play();
|
||||
|
||||
expect(container.read(radarTimelineProvider).isPlaying, isFalse);
|
||||
});
|
||||
|
||||
// Leaving a timer running and pushing textures behind another app is pure
|
||||
// battery drain with nobody watching.
|
||||
test('backgrounding the app pauses playback', () async {
|
||||
final source = FakeRadarSource(frameCount: 6);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
timeline.play();
|
||||
expect(container.read(radarTimelineProvider).isPlaying, isTrue);
|
||||
|
||||
timeline.onAppBackgrounded();
|
||||
|
||||
expect(container.read(radarTimelineProvider).isPlaying, isFalse);
|
||||
});
|
||||
});
|
||||
|
||||
group('scrubbing', () {
|
||||
test('seek moves the playhead and stops playback', () async {
|
||||
final source = FakeRadarSource(frameCount: 10);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
timeline.play();
|
||||
timeline.seek(3);
|
||||
|
||||
final state = container.read(radarTimelineProvider);
|
||||
expect(state.index, 3);
|
||||
expect(state.isPlaying, isFalse, reason: 'a scrub takes over the frame');
|
||||
});
|
||||
|
||||
test('seek clamps to the available range', () async {
|
||||
final source = FakeRadarSource(frameCount: 5);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
|
||||
timeline.seek(999);
|
||||
expect(container.read(radarTimelineProvider).index, 4);
|
||||
|
||||
timeline.seek(-999);
|
||||
expect(container.read(radarTimelineProvider).index, 0);
|
||||
});
|
||||
|
||||
test('step moves one frame at a time', () async {
|
||||
final source = FakeRadarSource(frameCount: 10);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
timeline.seek(5);
|
||||
timeline.step(1);
|
||||
expect(container.read(radarTimelineProvider).index, 6);
|
||||
|
||||
timeline.step(-2);
|
||||
expect(container.read(radarTimelineProvider).index, 4);
|
||||
});
|
||||
|
||||
// Scrubbing across a long timeline would otherwise accumulate every frame
|
||||
// it passed over.
|
||||
test('the cache holds only the window around the playhead', () async {
|
||||
final source = FakeRadarSource(frameCount: 20);
|
||||
final container = containerWith(source, region);
|
||||
await settled(container);
|
||||
await Future<void>.delayed(const Duration(milliseconds: 60));
|
||||
|
||||
final timeline = container.read(radarTimelineProvider.notifier);
|
||||
timeline.seek(2);
|
||||
await Future<void>.delayed(const Duration(milliseconds: 60));
|
||||
|
||||
// Radius 4 around index 2 means frames 0..6 at most.
|
||||
expect(timeline.cache.length, lessThanOrEqualTo(7));
|
||||
expect(timeline.cache.contains('frames/19.png'), isFalse);
|
||||
expect(timeline.cache.contains('frames/2.png'), isTrue);
|
||||
});
|
||||
});
|
||||
|
||||
group('createRadarSource', () {
|
||||
test('uses the region default when nothing overrides it', () {
|
||||
// The test binary is built with no --dart-define, so Env.radarSource is
|
||||
// empty and the region's own default applies.
|
||||
expect(createRadarSource(region), isNotNull);
|
||||
});
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user