fix(battery): address Greptile race + backoff + burst-gating findings (#57)

* fix(battery): address greptile race + backoff-consistency + burst-gating

Follow-up to #56. Three Greptile findings:

1. P1 — mScanning = true was assigned outside the synchronized block
   in MeterScanner.scanRunnable, opening a window where a concurrent
   stopScan(false) (e.g. processScanResult on line 126) sees
   mScanning == false, skips scanStopper(), and returns — leaving the
   BLE scan active for the full 6.5 min scantimeout. Move
   mScanning=true into the same synchronized block that clears
   scanpending and resets currentwait so the state transition is
   atomic.

2. P2 — currentwait is written under synchronized(MeterScanner.this)
   but read in stopScan() without the lock (JMM data race). Declare
   currentwait and scanpending volatile so the read in stopScan is
   guaranteed to see the latest value without expanding the lock
   scope.

3. P2 — onScanFailed (MeterScanner line 202) hard-coded
   scanStarter(scaninterval) so the new exponential backoff in
   currentwait was bypassed on BLE-stack-reported failures
   (SCAN_FAILED_APPLICATION_REGISTRATION_FAILED /
   SCAN_FAILED_INTERNAL_ERROR). Use currentwait so both failure paths
   stay consistent and a stream of scan failures backs off up to
   scanstartmaxwait (5 min) instead of always retrying in 60 s.

4. P2 (testlab.yml, discussion_r3489714891) — the inter-start burst
   warning was nested inside 'if len(ble_starts) > len(ble_stops) +
   1:'. A balanced but rapid cycle satisfied starts == stops and got
   the 'balanced' line, hiding what could be a high-frequency
   startScan burst. Hoist the delta computation out of that branch
   and lower the _short threshold from >= 3 to >= 2 so the warning
   fires for balanced rapid cycles too.

* fix(battery): make mScanning volatile (greptile follow-up on #57)

Greptile second-pass on #57 flagged that the volatile fix applied to
currentwait and scanpending was incomplete: mScanning has the same
shape — written inside synchronized(MeterScanner.this) in
scanRunnable, read outside any lock in stopScan() when called from
the timeout runnable. The JMM doesn't guarantee the timeout thread
sees mScanning = true, so stopScan(true) could skip scanStopper()
and reschedule a redundant scan. Make mScanning volatile so the
read in stopScan sees the latest value without expanding the lock
scope.

---------

Co-authored-by: Rob <rob@performanceinsights.ai>

Author: robster7674

.github/workflows/testlab.yml

@@ -616,24 +616,27 @@ jobs:
           lines.append(f"- Registered: **{len(ble_starts)}**  stopped: **{len(ble_stops)}**")
           if len(ble_starts) > len(ble_stops) + 1:
               lines.append(f"- ⚠️ {len(ble_starts)-len(ble_stops)} unmatched start(s)")
-              # Surface the worst scan-restart bursts so they're actionable.
-              from datetime import datetime
-              _ts_re = re.compile(r'^(\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+)')
-              def _ts(s):
-                  m = _ts_re.match(s)
-                  if not m: return None
-                  try: return datetime.strptime(m.group(1), '%m-%d %H:%M:%S.%f')
-                  except ValueError: return None
-              _starts = [(t, l) for l in ble_starts if (t := _ts(l)) is not None]
-              if len(_starts) >= 3:
-                  _starts.sort()
-                  _gaps = [(_starts[i+1][0]-_starts[i][0]).total_seconds() for i in range(len(_starts)-1)]
-                  _short = [g for g in _gaps if g < 60]
-                  if len(_short) >= 3:
-                      lines.append(f"- ⚠️ {len(_short)}/{len(_gaps)} scan restarts fired <60s apart — likely redundant startScan calls")
-                      lines.append("<details><summary>Start timestamps</summary>\n\n```")
-                      lines.extend(f"{t.strftime('%H:%M:%S.%f')[:-3]}" for t, _ in _starts[:30])
-                      lines.append("```\n</details>")
+
+          # Surface the worst scan-restart bursts so they're actionable. Computed
+          # independently of the matched/unmatched check so a balanced but rapid
+          # cycle (e.g. many short start/stop pairs) is not silently hidden.
+          from datetime import datetime
+          _ts_re = re.compile(r'^(\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+)')
+          def _ts(s):
+              m = _ts_re.match(s)
+              if not m: return None
+              try: return datetime.strptime(m.group(1), '%m-%d %H:%M:%S.%f')
+              except ValueError: return None
+          _starts = [(t, l) for l in ble_starts if (t := _ts(l)) is not None]
+          if len(_starts) >= 3:
+              _starts.sort()
+              _gaps = [(_starts[i+1][0]-_starts[i][0]).total_seconds() for i in range(len(_starts)-1)]
+              _short = [g for g in _gaps if g < 60]
+              if len(_short) >= 2:
+                  lines.append(f"- ⚠️ {len(_short)}/{len(_gaps)} scan restarts fired <60s apart — likely redundant startScan calls")
+                  lines.append("<details><summary>Start timestamps</summary>\n\n```")
+                  lines.extend(f"{t.strftime('%H:%M:%S.%f')[:-3]}" for t, _ in _starts[:30])
+                  lines.append("```\n</details>")
 
           # ── App AlarmManager calls ─────────────────────────────────────────
           if power_only:

Common/src/mobile/java/tk/glucodata/MeterScanner.java

@@ -52,7 +52,7 @@ class MeterScanner  {
    List<BluetoothDevice> devices=new ArrayList<BluetoothDevice>();
    List<String> deviceNames=new ArrayList<String>();
    private static final String LOG_ID="MeterScanner";
-   private boolean mScanning=false;
+   private volatile boolean mScanning=false;
    private BluetoothLeScanner mBluetoothLeScanner=null;
    boolean knowName=true;
    MeterScanner() {
@@ -199,7 +199,7 @@ public void onScanFailed(int errorCode) {
               if(errorCode != SCAN_FAILED_ALREADY_STARTED) {
                 stopScan(false);
                 if(errorCode != SCAN_FAILED_FEATURE_UNSUPPORTED) {
-                   scanStarter(scaninterval) ;
+                   scanStarter(currentwait) ;
                    }
                   }
                  }
@@ -262,8 +262,8 @@ public void scanStopper() {
 
 private static final int  scaninterval=60000;
 private static final int scanstartmaxwait=300000;
-private int currentwait=scaninterval;
-private boolean scanpending=false;
+private volatile int currentwait=scaninterval;
+private volatile boolean scanpending=false;
 public void stopScan(boolean retry) {
     if(doLog) {Log.d(LOG_ID,"Stop scanning "+(retry?"retry":"don't retry"));};
      if(scanFuture!=null) {
@@ -303,8 +303,8 @@ public void run() {
            scanpending=true;
        }
        if(scanStarter()) {
-               mScanning = true;
                synchronized(MeterScanner.this) {
+                   mScanning=true;
                    scanpending=false;
                    currentwait=scaninterval;
                }