@@ -4,6 +4,30 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.7] - 2026-08-26
+
+### Fixed
+
+- **The weather broadcast is real but rare, and the app forgot it between restarts.** The action
+  is confirmed: the head unit's weather app sends `com.saicmotor.weather` when *it* refreshes,
+  not on any cadence this app can ask for. 2.1.6 listened and gave up between refreshes, and the
+  app is restarted every time the driver opens it to look at the log — which is the worst moment
+  to start waiting. The last reading is now kept across restarts for two hours, and the platform
+  is asked at start-up and on every temperature-less upload for a held broadcast, which costs
+  nothing and answers immediately if the weather app sends its update sticky.
+
+### Changed
+
+- **`map=bound` in 2.1.6 corrected the release note that shipped with it.** That release said the
+  map service never bound; the log showed the binder alive and the *query* returning nothing,
+  which is a different failure with a different fix. The map query is now timed, and the elapsed
+  time appears in the log — the query is bounded by a two-second wait inside EVHardware, so a
+  null returning at once was refused or answered undecodably while a null returning at the bound
+  is a service that did not answer in time. Nothing outside the library distinguishes them, and
+  guessing which one it was is what produced the wrong note.
+- The broadcast reading now carries its age in the log (`bcast=Toulouse/12min`): where a value
+  came from does not say whether it still describes the day.
+
 ## [2.1.6] - 2026-08-26
 
 ### Fixed
 
@@ -34,8 +34,8 @@ android {
         applicationId "com.evsuite.abrp"
         minSdk 27
         targetSdk 36
-        versionCode 14
-        versionName "2.1.6"
+        versionCode 15
+        versionName "2.1.7"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
 
@@ -111,6 +111,18 @@ public class AbrpUploadService extends Service {
      * enough for ten minutes to matter to a consumption model.
      */
     private static final long   WEATHER_TTL_MS = 10 * 60 * 1000L;
+    /**
+     * How long a broadcast temperature keeps standing in for the car's thermometer.
+     *
+     * The weather app broadcasts when it refreshes itself, not on a cadence this app can ask
+     * for, so a reading has to outlive the moment it arrived or it would be useless between
+     * refreshes. Two hours is long enough to bridge them and short enough that the value has
+     * not stopped describing the day.
+     */
+    private static final long   WEATHER_MAX_AGE_MS = 2 * 60 * 60 * 1000L;
+    private static final String KEY_WEATHER_TEMP  = "weather_temp_c";
+    private static final String KEY_WEATHER_PLACE = "weather_place";
+    private static final String KEY_WEATHER_MS    = "weather_received_ms";
 
     // Set from the main thread (LocationListener uses Main looper), read from
     // the scheduler thread inside doUpload. volatile is sufficient since Location
@@ -149,9 +161,12 @@ public class AbrpUploadService extends Service {
     private final BroadcastReceiver weatherReceiver = new BroadcastReceiver() {
         @Override public void onReceive(Context context, Intent intent) {
             headUnitWeather.accept(intent);
+            saveWeather();
         }
     };
     private volatile boolean weatherReceiverRegistered = false;
+    /** How long the last map-service query took, or -1 when it was never made. */
+    private volatile long lastQueryMs = -1L;
 
     // ---------- Lifecycle ----------
 
@@ -470,7 +485,10 @@ private void doUpload() {
             // The broadcast first. It is what fills the head unit's own status bar, so on this
             // car it is the source known to be producing a number, where the map service's
             // query never even bound.
-            Float broadcast = headUnitWeather.temperatureC();
+            // The broadcast arrives when the weather app feels like it, so a reading that
+            // never came is retried here rather than only at start-up.
+            if (headUnitWeather.temperatureC() == null) probeStickyWeather();
+            Float broadcast = weatherIsFresh() ? headUnitWeather.temperatureC() : null;
             if (TelemetryPayload.isPlausibleTemp(broadcast)) {
                 extTemp = broadcast;
                 tempSource = "bcast:" + headUnitWeather.diagnostic();
@@ -484,7 +502,8 @@ private void doUpload() {
                     // "the broadcast never arrives" and "it arrives in a shape this cannot
                     // read" — and nothing on the ABRP side tells them apart.
                     tempSource = "none bcast=" + headUnitWeather.diagnostic()
-                            + " map=" + (SaicWeather.INSTANCE.isAvailable() ? "bound" : "unbound");
+                            + " map=" + (SaicWeather.INSTANCE.isAvailable() ? "bound" : "unbound")
+                            + (lastQueryMs < 0 ? "" : "/" + lastQueryMs + "ms");
                 }
             }
         }
@@ -547,18 +566,66 @@ private void doUpload() {
      * through ContextCompat, which picks the right overload for the platform underneath.
      */
     private void registerWeatherReceiver() {
+        restoreWeather();
         try {
             androidx.core.content.ContextCompat.registerReceiver(
                     this, weatherReceiver, new IntentFilter(HeadUnitWeather.ACTION),
                     androidx.core.content.ContextCompat.RECEIVER_EXPORTED);
             weatherReceiverRegistered = true;
+            // A null receiver asks the platform for the last broadcast it is holding without
+            // subscribing to anything. If the weather app sends its update sticky, this is the
+            // reading straight away rather than after however long until its next refresh —
+            // and the app is started to look at the log, which is exactly the wrong moment to
+            // begin waiting.
+            probeStickyWeather();
         } catch (Exception e) {
             // A car whose weather app broadcasts nothing is a car without ext_temp, not a
             // reason to lose the upload service.
             Log.w(TAG, "Weather broadcast unavailable: " + e.getMessage());
         }
     }
 
+    /** Asks for the last held broadcast, if the platform is holding one. Harmless when not. */
+    private void probeStickyWeather() {
+        try {
+            headUnitWeather.accept(
+                    registerReceiver(null, new IntentFilter(HeadUnitWeather.ACTION)));
+            saveWeather();
+        } catch (Exception e) {
+            Log.w(TAG, "Sticky weather probe failed: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Keeps the last reading across a restart.
+     *
+     * The broadcast arrives when the weather app refreshes, so a service that forgets on every
+     * start would spend most of its life with no temperature at all — and the app is restarted
+     * every time the driver opens it.
+     */
+    private void saveWeather() {
+        Float celsius = headUnitWeather.temperatureC();
+        if (celsius == null) return;
+        prefs.edit()
+                .putFloat(KEY_WEATHER_TEMP, celsius)
+                .putString(KEY_WEATHER_PLACE, headUnitWeather.place())
+                .putLong(KEY_WEATHER_MS, headUnitWeather.receivedMs())
+                .apply();
+    }
+
+    private void restoreWeather() {
+        long whenMs = prefs.getLong(KEY_WEATHER_MS, 0L);
+        if (whenMs <= 0L || System.currentTimeMillis() - whenMs > WEATHER_MAX_AGE_MS) return;
+        headUnitWeather.restore(prefs.getFloat(KEY_WEATHER_TEMP, 0f),
+                prefs.getString(KEY_WEATHER_PLACE, ""), whenMs);
+    }
+
+    /** True while the stored reading still describes the day — see {@link #WEATHER_MAX_AGE_MS}. */
+    private boolean weatherIsFresh() {
+        long whenMs = headUnitWeather.receivedMs();
+        return whenMs > 0L && System.currentTimeMillis() - whenMs <= WEATHER_MAX_AGE_MS;
+    }
+
     /**
      * Current conditions where the car is, or null when nothing can answer.
      *
@@ -572,9 +639,15 @@ private SaicWeather.Reading weatherAt(Location loc) {
         long now = System.currentTimeMillis();
         SaicWeather.Reading cached = lastWeather;
         if (cached != null && now - lastWeatherMs < WEATHER_TTL_MS) return cached;
-        if (!SaicWeather.INSTANCE.isAvailable()) return cached;
+        if (!SaicWeather.INSTANCE.isAvailable()) { lastQueryMs = -1L; return cached; }
+        // How long the call took is the only thing that separates its failure modes from out
+        // here: the query is bounded by a two-second wait inside the library, so a null that
+        // comes back at once was refused or answered undecodably, and a null that comes back
+        // at the bound is a service that did not answer in time. The library reports neither.
+        long startedMs = System.currentTimeMillis();
         SaicWeather.Reading reading = SaicWeather.INSTANCE.currentAt(
                 loc.getLatitude(), loc.getLongitude(), weatherLanguage());
+        lastQueryMs = System.currentTimeMillis() - startedMs;
         if (reading == null) return cached;
         lastWeather = reading;
         lastWeatherMs = now;
 
@@ -63,15 +63,30 @@ long receivedMs() {
      * are indistinguishable from the ABRP side.
      */
     String diagnostic() {
-        if (temperatureC != null) return place.isEmpty() ? "ok" : place;
-        return problem;
+        if (temperatureC == null) return problem;
+        String age = (System.currentTimeMillis() - receivedMs) / 60000 + "min";
+        return (place.isEmpty() ? "ok" : place) + "/" + age;
     }
 
     /** Reads whatever the head unit just broadcast. Never throws: this runs in a receiver. */
     void accept(Intent intent) {
+        if (intent == null) {
+            // Only reached from the sticky probe, which answers null when the platform is
+            // holding no such broadcast. Says nothing about whether one will ever be sent.
+            if (temperatureC == null) problem = "none held, none sent yet";
+            return;
+        }
         acceptPayload(payloadOf(intent));
     }
 
+    /** Restores the last reading across a restart — see the service's prefs. */
+    void restore(float celsius, String named, long whenMs) {
+        temperatureC = celsius;
+        place = named == null ? "" : named;
+        receivedMs = whenMs;
+        problem = null;
+    }
+
     /**
      * The half of {@link #accept} that has no Android in it, so the search below is testable
      * against the payloads it might be handed rather than only against the one it expects.
 
@@ -24,7 +24,9 @@ public void readsATemperatureAndThePlaceItIsFor() {
                         + "\"address\":\"Toulouse\",\"conditionType\":1}}"));
         assertEquals(27f, weather.temperatureC(), 0.01f);
         assertEquals("Toulouse", weather.place());
-        assertEquals("Toulouse", weather.diagnostic());
+        // The diagnostic carries the reading's age: a broadcast arrives when the weather app
+        // refreshes, so "where from" without "how long ago" does not say whether to trust it.
+        assertEquals("Toulouse/0min", weather.diagnostic());
     }
 
     @Test
@@ -88,4 +90,20 @@ public void malformedJsonDoesNotEscapeTheReceiver() {
         assertNull(weather.temperatureC());
         assertTrue(weather.diagnostic(), weather.diagnostic().contains("reading broadcast"));
     }
+
+    @Test
+    public void aRestoredReadingIsReportedWithItsAge() {
+        HeadUnitWeather weather = new HeadUnitWeather();
+        weather.restore(19.5f, "Toulouse", System.currentTimeMillis() - 45 * 60 * 1000L);
+        assertEquals(19.5f, weather.temperatureC(), 0.01f);
+        assertEquals("Toulouse/45min", weather.diagnostic());
+    }
+
+    @Test
+    public void anAbsentStickyBroadcastIsNotMistakenForAFailedParse() {
+        HeadUnitWeather weather = new HeadUnitWeather();
+        weather.accept(null);
+        assertNull(weather.temperatureC());
+        assertEquals("none held, none sent yet", weather.diagnostic());
+    }
 }