fix: degrade 所在地 to nationwide when GPS is unavailable

A lost GPS fix left RegionStore on the stale last-known township, so the
home backdrop kept framing and outlining a place the user wasn't in.
LocationMonitor now clears the code when location becomes unusable, and
the backdrop frames on a cached fix (never a live read) so a simulator
with no location falls back to the nationwide view instantly instead of
waiting out the 10s GPS timeout.

lib/core/geo/location_monitor.dart

@@ -87,9 +87,19 @@ class LocationMonitor extends ChangeNotifier with WidgetsBindingObserver {
     final previous = _status;
     final status = await _location.status();
     _status = status;
+    final wasUsable = _usable(previous);
+    final nowUsable = _usable(status);
+    // GPS lost (services off / permission revoked): 所在地 must not keep
+    // presenting the last-known township as where the user is. Clearing the
+    // code puts the whole app back in the "can't locate" state (nationwide map
+    // + the header's notice) instead of a stale place.
+    if (wasUsable && !nowUsable) {
+      _publishedCode = null;
+      _regions.setCurrentCode(null);
+    }
     // Recover only on an unusable → usable transition (services back / granted),
     // not on every resume — avoids re-subscribing the position stream needlessly.
-    if (_seeded && _usable(status) && !_usable(previous)) {
+    if (_seeded && nowUsable && !wasUsable) {
       _reporter.restart();
       final code = (await _location.currentTown())?.code;
       _publishedCode = code;

lib/core/geo/location_service.dart

@@ -26,8 +26,12 @@ class LocationService {
     this._boundaries,
     Future<bool> Function()? isAvailable,
     Future<GpsFix?> Function()? fix,
+    Future<GpsFix?> Function()? lastKnown,
+    Future<LocationStatus> Function()? status,
   }) : _isAvailable = isAvailable ?? _geolocatorAvailable,
-       _fix = fix ?? _geolocatorFix;
+       _fix = fix ?? _geolocatorFix,
+       _lastKnownFix = lastKnown ?? _geolocatorLastKnown,
+       _status = status ?? _geolocatorStatus;
 
   final TownDirectory _directory;
 
@@ -37,21 +41,14 @@ class LocationService {
 
   final Future<bool> Function() _isAvailable;
   final Future<GpsFix?> Function() _fix;
+  final Future<GpsFix?> Function() _lastKnownFix;
+  final Future<LocationStatus> Function() _status;
 
   /// The combined location-availability [LocationStatus] (services + permission).
   /// Never throws — a fault degrades to [LocationStatus.denied].
   Future<LocationStatus> status() async {
     try {
-      if (!await Geolocator.isLocationServiceEnabled()) {
-        return LocationStatus.serviceOff;
-      }
-      return switch (await Geolocator.checkPermission()) {
-        LocationPermission.always => LocationStatus.ready,
-        LocationPermission.whileInUse => LocationStatus.whileInUseOnly,
-        LocationPermission.deniedForever => LocationStatus.deniedForever,
-        LocationPermission.denied ||
-        LocationPermission.unableToDetermine => LocationStatus.denied,
-      };
+      return await _status();
     } catch (error, stackTrace) {
       Log.handle(error, stackTrace, 'location status');
       return LocationStatus.denied;
@@ -182,6 +179,22 @@ class LocationService {
     }
   }
 
+  /// The most recent cached fix if it's fresh enough ([_maxLastKnownAge]),
+  /// else null — never a live read, so it returns immediately.
+  ///
+  /// For surfaces that must frame instantly (the home backdrop) and would
+  /// otherwise wait out a GPS timeout: on a simulator with no location the
+  /// cached fix is null, so it can fall back to the nationwide view right away
+  /// instead of holding the previous frame for the live-read window.
+  Future<GpsFix?> lastKnownFix() async {
+    try {
+      return await _lastKnownFix();
+    } catch (error, stackTrace) {
+      Log.handle(error, stackTrace, 'last-known GPS fix');
+      return null;
+    }
+  }
+
   /// The current township from GPS, or null if unavailable / no fix.
   Future<Town?> currentTown() async {
     try {
@@ -224,6 +237,27 @@ class LocationService {
         permission == LocationPermission.whileInUse;
   }
 
+  static Future<GpsFix?> _geolocatorLastKnown() async {
+    final cached = await Geolocator.getLastKnownPosition();
+    if (cached != null && _isFresh(cached.timestamp)) {
+      return (lat: cached.latitude, lng: cached.longitude);
+    }
+    return null;
+  }
+
+  static Future<LocationStatus> _geolocatorStatus() async {
+    if (!await Geolocator.isLocationServiceEnabled()) {
+      return LocationStatus.serviceOff;
+    }
+    return switch (await Geolocator.checkPermission()) {
+      LocationPermission.always => LocationStatus.ready,
+      LocationPermission.whileInUse => LocationStatus.whileInUseOnly,
+      LocationPermission.deniedForever => LocationStatus.deniedForever,
+      LocationPermission.denied ||
+      LocationPermission.unableToDetermine => LocationStatus.denied,
+    };
+  }
+
   /// How old a cached OS fix may be and still stand in for a live one. The
   /// cached fix is only a head start on the first frame, so it has to be recent
   /// enough that it still describes where the user *is*: an hours-old fix from

lib/features/home/presentation/widgets/home_map_backdrop.dart

@@ -159,13 +159,6 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
     _refreshRadar();
   }
 
-  /// The selected township code, or null for the nationwide (whole-island) view.
-  String? get _selectedCode => switch (_regions?.selected) {
-    SavedArea(:final code) => code,
-    CurrentArea(:final code) => code,
-    _ => null,
-  };
-
   /// Frames the map on the selected township and highlights it — or fits the
   /// whole island for the nationwide view. Skips unchanged selections.
   Future<void> _applySelection() async {
@@ -179,38 +172,57 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
     // ends. Frame into that band, not the whole map.
     final topInset = MediaQuery.paddingOf(context).top + RegionBar.height;
     final boundariesFuture = context.read<Future<TownBoundaries>>();
-    final code = _selectedCode;
+    final selected = _regions?.selected;
+    final code = switch (selected) {
+      SavedArea(:final code) => code,
+      CurrentArea(:final code) => code,
+      _ => null,
+    };
     final styleEpoch = _styleEpoch;
     // 所在地 is a *place*, not a region: the current GPS fix is the point, so
     // the camera centres on it (a fixed span around the fix) instead of framing
-    // the whole township the way a saved area does. Falls back to the township
-    // box — or the whole island when GPS is unavailable — if no fix is had.
-    final gpsCentred = _regions?.selected is CurrentArea;
+    // the whole township the way a saved area does.
+    final gpsCentred = selected is CurrentArea;
     final location = context.read<LocationService>();
     // Nothing changed since the last apply (an unrelated RegionStore notify) —
     // don't re-add layers or re-run the camera.
     if (code == _appliedCode && styleEpoch == _appliedCodeEpoch) return;
     final gen = ++_selectionGen;
 
+    // The GPS fix decides 所在地's subject. No fix — services off, permission
+    // denied, or a fix timeout — degrades 所在地 to the nationwide view: the
+    // last-known township is not where the user is, so it must not frame or
+    // outline it. Falls back to the township box — or the whole island when no
+    // code is had — when a fix exists but the township isn't resolved.
+    //
+    // A *cached* fix, never a live read: `currentFix` can wait out a 10s GPS
+    // timeout, and while it did the backdrop sat on the base map's pre-layout
+    // camera (a tiny Taiwan) instead of framing. The cached fix answers
+    // instantly, and the position stream's own updates re-apply this when they
+    // land. A `CurrentArea` whose code is null means 所在地 has no township at
+    // all (GPS lost) — skip the lookup entirely and go nationwide.
+    GpsFix? fix;
+    if (gpsCentred && code != null) {
+      fix = await location.lastKnownFix();
+      if (!mounted || gen != _selectionGen || styleEpoch != _styleEpoch) return;
+    }
+    final effective = gpsCentred && fix == null ? null : code;
+
     List<double>? bounds;
-    if (code != null) {
+    if (effective != null) {
       final boundaries = await boundariesFuture;
       if (!mounted || gen != _selectionGen || styleEpoch != _styleEpoch) return;
-      bounds = boundaries.boundsFor(code);
+      bounds = boundaries.boundsFor(effective);
     }
 
     LatLngBounds frame;
-    if (gpsCentred) {
-      final fix = await location.currentFix();
-      if (!mounted || gen != _selectionGen || styleEpoch != _styleEpoch) return;
-      frame = fix == null
-          ? _latLngBounds(bounds)
-          : _latLngBounds([
-              fix.lng - _gpsSpan,
-              fix.lat - _gpsSpan,
-              fix.lng + _gpsSpan,
-              fix.lat + _gpsSpan,
-            ]);
+    if (gpsCentred && fix != null) {
+      frame = _latLngBounds([
+        fix.lng - _gpsSpan,
+        fix.lat - _gpsSpan,
+        fix.lng + _gpsSpan,
+        fix.lat + _gpsSpan,
+      ]);
     } else {
       frame = _latLngBounds(bounds);
     }
@@ -229,7 +241,7 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
     final bottomInset = size.height * HomeSheetExtent.rest;
     _queue(() async {
       if (!mounted || gen != _selectionGen || styleEpoch != _styleEpoch) return;
-      await _restackOverlays(controller);
+      await _restackOverlays(controller, code: effective);
       // Frame the box in the band above the resting sheet — computed in Dart
       // (boundsFitCamera) and applied as a plain centre+zoom, so a degenerate or
       // not-yet-laid-out viewport can't abort the app the way MapLibre's native
@@ -245,7 +257,7 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
           CameraUpdate.newLatLngZoom(fit.target, fit.zoom),
         );
       }
-      _appliedCode = code;
+      _appliedCode = effective;
       _appliedCodeEpoch = styleEpoch;
     });
   }
@@ -261,9 +273,15 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
   /// whole-island framing is far enough out that 368 outlines collapse into a
   /// grey wash over the echo, and there the county frame is the only boundary
   /// carrying information.
-  Future<void> _restackOverlays(MapLibreMapController controller) async {
-    final code = _selectedCode;
-    final wanted = backdropBoundaries(code);
+  Future<void> _restackOverlays(
+    MapLibreMapController controller, {
+    String? code,
+  }) async {
+    // The caller passes the *effective* code (GPS-aware). A radar refresh has no
+    // selection context, so it falls back to the last applied one — the outline
+    // must match what the camera is framing, never drift back to a stale code.
+    final subject = code ?? _appliedCode;
+    final wanted = backdropBoundaries(subject);
     // Bottom-up, so a later add lands above an earlier one: the coarse county
     // frame should win where the two run together along a coastline.
     for (final boundary in [AdminBoundary.town, AdminBoundary.county]) {
@@ -273,7 +291,7 @@ class _HomeMapBackdropState extends State<HomeMapBackdrop>
       }
     }
     // The selection is the point of the backdrop — always last, always on top.
-    await _addSelectedLayers(controller, _filterFor(_townCode(code)));
+    await _addSelectedLayers(controller, _filterFor(_townCode(subject)));
   }
 
   /// (Re)adds the purple selection outline on the vector `town` layer (filtered

test/core/geo/location_monitor_test.dart

@@ -3,9 +3,11 @@ import 'dart:async';
 import 'package:dpip/core/geo/device_location_reporter.dart';
 import 'package:dpip/core/geo/location_monitor.dart';
 import 'package:dpip/core/geo/location_service.dart';
+import 'package:dpip/core/geo/location_status.dart';
 import 'package:dpip/core/geo/town_directory.dart';
 import 'package:dpip/core/settings/prefs.dart';
 import 'package:dpip/core/settings/region_store.dart';
+import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
@@ -47,7 +49,9 @@ void main() {
     SharedPreferences.setMockInitialValues({});
     final prefs = Prefs(await SharedPreferences.getInstance());
     regions = RegionStore(prefs);
-    positions = StreamController<GpsFix>();
+    // Broadcast so a recovery-driven `reporter.restart()` can re-subscribe (a
+    // single-subscription stream throws on the second listen).
+    positions = StreamController<GpsFix>.broadcast();
     reporter = DeviceLocationReporter(
       positions: () => positions.stream,
       prefs: prefs,
@@ -133,4 +137,66 @@ void main() {
     await pumpEventQueue();
     expect(regions.currentCode, _tainanCode);
   });
+
+  test('GPS loss clears the township so 所在地 degrades to nationwide', () async {
+    var available = true;
+    final location = LocationService(
+      _directory(),
+      isAvailable: () async => available,
+      fix: () async => _tainanFix,
+      status: () async =>
+          available ? LocationStatus.ready : LocationStatus.serviceOff,
+    );
+    final monitor = LocationMonitor(
+      location: location,
+      reporter: reporter,
+      regions: regions,
+    )..start();
+    reporter.start();
+    await pumpEventQueue();
+
+    positions.add((lat: _tainanFix.lat, lng: _tainanFix.lng));
+    await pumpEventQueue();
+    expect(regions.currentCode, _tainanCode);
+
+    // Services off → the monitor re-checks on resume and must not keep the
+    // last-known township as the current one (the backdrop would frame it).
+    available = false;
+    WidgetsBinding.instance.handleAppLifecycleStateChanged(
+      AppLifecycleState.resumed,
+    );
+    await pumpEventQueue();
+    expect(regions.currentCode, isNull);
+
+    monitor.dispose();
+  });
+
+  test('GPS returning re-resolves the current township', () async {
+    var available = false;
+    final location = LocationService(
+      _directory(),
+      isAvailable: () async => available,
+      fix: () async => _taipeiFix,
+      status: () async =>
+          available ? LocationStatus.ready : LocationStatus.serviceOff,
+    );
+    final monitor = LocationMonitor(
+      location: location,
+      reporter: reporter,
+      regions: regions,
+    )..start();
+    reporter.start();
+    await pumpEventQueue();
+    expect(regions.currentCode, isNull);
+
+    // Recovery re-resolves 所在地 instead of leaving it nationwide.
+    available = true;
+    WidgetsBinding.instance.handleAppLifecycleStateChanged(
+      AppLifecycleState.resumed,
+    );
+    await pumpEventQueue();
+    expect(regions.currentCode, _taipeiCode);
+
+    monitor.dispose();
+  });
 }

test/core/geo/location_service_test.dart

@@ -57,4 +57,35 @@ void main() {
     );
     expect(await service.currentTown(), isNull);
   });
+
+  test('lastKnownFix serves the cached fix without a live read', () async {
+    var liveReads = 0;
+    final service = LocationService(
+      _dir(),
+      lastKnown: () async => (lat: 25.05, lng: 121.55),
+      fix: () async {
+        liveReads++;
+        return (lat: 25.05, lng: 121.55);
+      },
+    );
+    expect(await service.lastKnownFix(), (lat: 25.05, lng: 121.55));
+    expect(liveReads, 0, reason: 'the live read must not run');
+  });
+
+  test('lastKnownFix is null when no cached fix exists', () async {
+    final service = LocationService(
+      _dir(),
+      lastKnown: () async => null,
+      fix: () async => (lat: 25.05, lng: 121.55),
+    );
+    expect(await service.lastKnownFix(), isNull);
+  });
+
+  test('a lastKnownFix fault degrades to null, never throws', () async {
+    final service = LocationService(
+      _dir(),
+      lastKnown: () async => throw Exception('platform fault'),
+    );
+    expect(await service.lastKnownFix(), isNull);
+  });
 }