forked from Blendman974/faceclaw
Fix remaining health review issues and document ring clock skew
This commit is contained in:
1 parent
7677dd254e
commit
27a5fe47ef
10 files changed
+323
-191
No files matched your search
+69
-116
@@ -87,6 +87,9 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
private final java.util.List<FaceclawMicStatusListener> micStatusListeners =
|
private final java.util.List<FaceclawMicStatusListener> micStatusListeners =
|
||||||
new java.util.concurrent.CopyOnWriteArrayList<>();
|
new java.util.concurrent.CopyOnWriteArrayList<>();
|
||||||
private volatile Thread workerThread;
|
private volatile Thread workerThread;
|
||||||
|
// Ring connect/write/health waits must never park the glasses sender.
|
||||||
|
// FaceclawBleManager serializes GATT operations per device address.
|
||||||
|
private volatile Thread ringWorkerThread;
|
||||||
private volatile boolean running;
|
private volatile boolean running;
|
||||||
private volatile boolean userDisconnectRequested;
|
private volatile boolean userDisconnectRequested;
|
||||||
// Set when a connect attempt failed while an arm's Android bond is gone:
|
// Set when a connect attempt failed while an arm's Android bond is gone:
|
||||||
@@ -106,7 +109,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
// inline because notifications arrive on the GATT callback thread and
|
// inline because notifications arrive on the GATT callback thread and
|
||||||
// bleManager.writeFrames() blocks waiting for onCharacteristicWrite, which
|
// bleManager.writeFrames() blocks waiting for onCharacteristicWrite, which
|
||||||
// that same thread has to deliver — writing there would deadlock until the
|
// that same thread has to deliver — writing there would deadlock until the
|
||||||
// write timeout. The worker loop drains the queue instead.
|
// write timeout. The ring worker drains the queue instead.
|
||||||
private final RingProtocol.Reassembler ringReassembler = new RingProtocol.Reassembler();
|
private final RingProtocol.Reassembler ringReassembler = new RingProtocol.Reassembler();
|
||||||
private final ArrayDeque<byte[]> ringOutbound = new ArrayDeque<>();
|
private final ArrayDeque<byte[]> ringOutbound = new ArrayDeque<>();
|
||||||
private final List<RingProtocol.HealthRecord> ringHealthRecords = new ArrayList<>();
|
private final List<RingProtocol.HealthRecord> ringHealthRecords = new ArrayList<>();
|
||||||
@@ -159,7 +162,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
private long ringHealthLastRequestedAtMs;
|
private long ringHealthLastRequestedAtMs;
|
||||||
/**
|
/**
|
||||||
* Set by {@link #requestRingHealthNow()} from whatever thread the UI is on;
|
* Set by {@link #requestRingHealthNow()} from whatever thread the UI is on;
|
||||||
* cleared by the worker loop, which is the only thread allowed to run the
|
* cleared by the ring worker, which is the only thread allowed to run the
|
||||||
* pull. Guarded by {@code lock}.
|
* pull. Guarded by {@code lock}.
|
||||||
*/
|
*/
|
||||||
private boolean ringHealthPullRequested;
|
private boolean ringHealthPullRequested;
|
||||||
@@ -389,6 +392,10 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
activeInstance = this;
|
activeInstance = this;
|
||||||
workerThread = new Thread(this, "FaceclawBleCommunicator");
|
workerThread = new Thread(this, "FaceclawBleCommunicator");
|
||||||
workerThread.start();
|
workerThread.start();
|
||||||
|
if (hasRingAddress()) {
|
||||||
|
ringWorkerThread = new Thread(this::runRingWorker, "FaceclawRing");
|
||||||
|
ringWorkerThread.start();
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -401,15 +408,19 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
releaseFaceclawFramebufferLease();
|
releaseFaceclawFramebufferLease();
|
||||||
}
|
}
|
||||||
Thread threadToJoin;
|
Thread threadToJoin;
|
||||||
|
Thread ringThreadToJoin;
|
||||||
synchronized (lock) {
|
synchronized (lock) {
|
||||||
userDisconnectRequested = true;
|
userDisconnectRequested = true;
|
||||||
running = false;
|
running = false;
|
||||||
audioCaptureActive = false;
|
audioCaptureActive = false;
|
||||||
audioPacketListener = null;
|
audioPacketListener = null;
|
||||||
threadToJoin = workerThread;
|
threadToJoin = workerThread;
|
||||||
|
ringThreadToJoin = ringWorkerThread;
|
||||||
|
lock.notifyAll();
|
||||||
}
|
}
|
||||||
setStateDisplay("disconnecting", "Disconnecting...");
|
setStateDisplay("disconnecting", "Disconnecting...");
|
||||||
interruptibleSleep.interrupt();
|
interruptibleSleep.interrupt();
|
||||||
|
if (ringThreadToJoin != null) ringThreadToJoin.interrupt();
|
||||||
if (threadToJoin != null) {
|
if (threadToJoin != null) {
|
||||||
threadToJoin.interrupt();
|
threadToJoin.interrupt();
|
||||||
try {
|
try {
|
||||||
@@ -418,8 +429,16 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
Thread.currentThread().interrupt();
|
Thread.currentThread().interrupt();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if (ringThreadToJoin != null) {
|
||||||
|
try {
|
||||||
|
ringThreadToJoin.join(5_000);
|
||||||
|
} catch (InterruptedException e) {
|
||||||
|
Thread.currentThread().interrupt();
|
||||||
|
}
|
||||||
|
}
|
||||||
synchronized (lock) {
|
synchronized (lock) {
|
||||||
workerThread = null;
|
workerThread = null;
|
||||||
|
ringWorkerThread = null;
|
||||||
resetSessionStateLocked();
|
resetSessionStateLocked();
|
||||||
clearAllMessagesLocked("disconnect");
|
clearAllMessagesLocked("disconnect");
|
||||||
// Unknown until the next connection's first push or settings poll.
|
// Unknown until the next connection's first push or settings poll.
|
||||||
@@ -1705,24 +1724,6 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (shouldAttemptRingConnect()) {
|
|
||||||
tryConnectRing("retry");
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Page ACKs queued from the GATT callback thread are written
|
|
||||||
// here, on the only thread allowed to block on a GATT write.
|
|
||||||
flushRingOutbound();
|
|
||||||
|
|
||||||
// An on-demand pull asked for from the UI thread runs here for
|
|
||||||
// the same reason: requestRingHealth() blocks on GATT writes and
|
|
||||||
// on its own RSP/DATA waits, which only this thread may do.
|
|
||||||
runRequestedRingHealthPull();
|
|
||||||
// An aborted pull is unfinished business, not a speculative
|
|
||||||
// repeat - see RING_HEALTH_ABORTED_RETRY_LIMIT. Cheap: returns
|
|
||||||
// immediately unless a pull actually failed to complete.
|
|
||||||
resumeAbortedRingHealthPull();
|
|
||||||
|
|
||||||
long sleepMs = driveSession();
|
long sleepMs = driveSession();
|
||||||
if (sleepMs > 0) {
|
if (sleepMs > 0) {
|
||||||
interruptibleSleep.sleep(sleepMs);
|
interruptibleSleep.sleep(sleepMs);
|
||||||
@@ -1735,6 +1736,35 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
logLine("communicator stop");
|
logLine("communicator stop");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Sole owner of blocking ring operations; callbacks only enqueue ACKs. */
|
||||||
|
private void runRingWorker() {
|
||||||
|
while (running && !Thread.currentThread().isInterrupted()) {
|
||||||
|
try {
|
||||||
|
if (shouldAttemptRingConnect()) tryConnectRing("ring worker");
|
||||||
|
if (!running) break;
|
||||||
|
flushRingOutbound();
|
||||||
|
runRequestedRingHealthPull();
|
||||||
|
resumeAbortedRingHealthPull();
|
||||||
|
synchronized (lock) {
|
||||||
|
if (running) lock.wait(100);
|
||||||
|
}
|
||||||
|
} catch (InterruptedException e) {
|
||||||
|
Thread.currentThread().interrupt();
|
||||||
|
break;
|
||||||
|
} catch (Throwable t) {
|
||||||
|
logLine("ring worker error: " + safeMessage(t));
|
||||||
|
// A ring failure must not tear down the glasses session.
|
||||||
|
synchronized (lock) {
|
||||||
|
ringConnected = false;
|
||||||
|
ringNotificationsReady = false;
|
||||||
|
ringReconnectAfterMs = SystemClock.elapsedRealtime() + ConnectionOptions.RING_RECONNECT_DELAY_MS;
|
||||||
|
}
|
||||||
|
bleManager.disconnect(ringAddress);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
logLine("ring worker stop");
|
||||||
|
}
|
||||||
|
|
||||||
@Override public void onNotification(String address, String characteristicUuid, byte[] data) {
|
@Override public void onNotification(String address, String characteristicUuid, byte[] data) {
|
||||||
if (address == null || characteristicUuid == null || data == null) {
|
if (address == null || characteristicUuid == null || data == null) {
|
||||||
return;
|
return;
|
||||||
@@ -2140,9 +2170,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
ringHealthPageCounter++;
|
ringHealthPageCounter++;
|
||||||
lock.notifyAll();
|
lock.notifyAll();
|
||||||
}
|
}
|
||||||
// The worker loop does the actual write; wake it so the ACK is not held
|
// lock.notifyAll() wakes the ring worker, independently of the glasses.
|
||||||
// for a whole idle tick.
|
|
||||||
interruptibleSleep.interrupt();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
private boolean journalRingFrame(RingProtocol.Frame frame) {
|
private boolean journalRingFrame(RingProtocol.Frame frame) {
|
||||||
@@ -2201,6 +2229,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
emitBatteryState(headsetBattery, headsetCharging);
|
emitBatteryState(headsetBattery, headsetCharging);
|
||||||
}
|
}
|
||||||
logLine(connected ? "direct ring BLE connected" : "direct ring BLE disconnected");
|
logLine(connected ? "direct ring BLE connected" : "direct ring BLE disconnected");
|
||||||
|
lock.notifyAll();
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (address.equalsIgnoreCase(rightAddress)) {
|
if (address.equalsIgnoreCase(rightAddress)) {
|
||||||
@@ -2297,7 +2326,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
logLine("queue settings query for firmware info");
|
logLine("queue settings query for firmware info");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
tryConnectRing("initial");
|
synchronized (lock) { lock.notifyAll(); }
|
||||||
} catch (Throwable t) {
|
} catch (Throwable t) {
|
||||||
logLine("connect failed: " + safeMessage(t));
|
logLine("connect failed: " + safeMessage(t));
|
||||||
String unpairedArm = firstUnpairedArm();
|
String unpairedArm = firstUnpairedArm();
|
||||||
@@ -2361,9 +2390,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
return running
|
return running
|
||||||
&& sessionReady
|
&& sessionReady
|
||||||
&& !ringNotificationsReady
|
&& !ringNotificationsReady
|
||||||
&& now >= ringReconnectAfterMs
|
&& now >= ringReconnectAfterMs;
|
||||||
&& pendingMessages.isEmpty()
|
|
||||||
&& inFlightMessages.isEmpty();
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -2554,6 +2581,7 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
public void requestRingHealthNow() {
|
public void requestRingHealthNow() {
|
||||||
synchronized (lock) {
|
synchronized (lock) {
|
||||||
ringHealthPullRequested = true;
|
ringHealthPullRequested = true;
|
||||||
|
lock.notifyAll();
|
||||||
}
|
}
|
||||||
interruptibleSleep.interrupt();
|
interruptibleSleep.interrupt();
|
||||||
}
|
}
|
||||||
@@ -2650,100 +2678,25 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Device-channel prelude the ring requires before it will answer any
|
* Device-channel initialization. 00:0e enables health recording; 00:05 sets
|
||||||
* channel-0x02 (health) request. <b>Confirmed live, 2026-09-10: without
|
* the clock (signed timezone minutes plus Unix seconds).
|
||||||
* this, the ring never responds at all to a bare health REQ - not even
|
|
||||||
* an RSP.</b> With it, RSPs start flowing immediately. The direct-ring
|
|
||||||
* path has no other handshake or auth step, so this is the whole gate.
|
|
||||||
*
|
*
|
||||||
* <p>These five frames were found by byte-for-byte comparison against a
|
* The inherited extra timezone shift is WRONG: on this PDT ring, fresh HR
|
||||||
* real Even-app sync (pkt 8814-9153 in the capture behind
|
* timestamps track receipt time + 7h. Firmware expects UTC seconds and
|
||||||
* {@code knowledge/staging/faceclaw-ring-protocol-decode-return.md}),
|
* applies the timezone separately. Do not simply deploy a seven-hour
|
||||||
* replayed here in the same order, right after the ring connects.
|
* rewind: stock firmware can format its health database on a backward
|
||||||
* <b>Which of the five is actually load-bearing is unknown</b> - all
|
* jump >= 1h. Existing pages also contain mixed clock domains and invalid
|
||||||
* five go out together because that combination is the only one proven
|
* daily anchors, so their dates cannot be repaired by one subtraction.
|
||||||
* to work; nobody has yet tried removing any of them. Three of them
|
|
||||||
* (00:08, 06:02, 00:0A) carry payload bytes with no known meaning beyond
|
|
||||||
* "the ring accepted them from Even's app" - opaque constants, copied
|
|
||||||
* verbatim, not derived. Do not change them without new evidence.
|
|
||||||
*
|
*
|
||||||
* <p>The other two (00:0E clock-set, 00:05 day-anchor) need a live
|
* TODO: controlled UTC migration after preserving ring history. Retain the
|
||||||
* value: both carry the current Unix time offset by the local UTC offset,
|
* existing wire behavior until that migration is authorized and validated.
|
||||||
* which in EDT is +14400s (4h) - and +14400s is what a real Even write
|
* See notes/ring-health-live-validation.md for evidence and the next test.
|
||||||
* carries. Verified 2026-09-11 against six separate real Even clock-set
|
|
||||||
* writes. As of 2026-09-12 the offset is COMPUTED from the device time
|
|
||||||
* zone rather than hardcoded, which is identical in EDT and stays correct
|
|
||||||
* across a DST change; see the comment in {@code sendRingHandshake()}.
|
|
||||||
*
|
|
||||||
* <p><b>Skew trap - read before "correcting" this number.</b> Earlier on
|
|
||||||
* 2026-09-11 this was changed to +28800s (8h) and that was wrong. The
|
|
||||||
* mistake: btsnoop packet timestamps on this phone run exactly 4 hours
|
|
||||||
* BEHIND the Android system clock (the system clock itself is correct -
|
|
||||||
* {@code adb shell date} agrees with real time). Measuring Even's sent
|
|
||||||
* value against the btsnoop timestamp therefore double-counts the 4h and
|
|
||||||
* makes a correct +14400 look like +28800. The skew is verified
|
|
||||||
* sub-second by lining btsnoop up against logcat on the same connect:
|
|
||||||
* logcat "direct ring BLE connected" 05:58:24.616 vs btsnoop MTU Req
|
|
||||||
* 01:58:24.618; "ring ready" .983 vs CCCD Write Rsp .981; "handshake
|
|
||||||
* sent" 25.085 vs first Write Command 25.071. Same milliseconds, hour
|
|
||||||
* off by four. <b>Always convert btsnoop timestamps to real local time
|
|
||||||
* (+4h) before comparing them to anything.</b>
|
|
||||||
*
|
|
||||||
* <p>A stale, yesterday's timestamp here was separately tested and ruled
|
|
||||||
* out as the reason DATA wasn't following RSP - but nothing says a stale
|
|
||||||
* value is harmless either, so this always sends the true current time.
|
|
||||||
*/
|
|
||||||
/**
|
|
||||||
* Round 2 (2026-09-11, ~00:55 EDT): compared this handshake against a
|
|
||||||
* fresh HCI-snoop capture of Even's own app completing a real successful
|
|
||||||
* sync minutes earlier. Two real findings from that comparison:
|
|
||||||
* - The 00:0A payload (the "app identity?" blob) is byte-for-byte
|
|
||||||
* identical between that capture and one from two nights before - a
|
|
||||||
* true fixed constant, not a rotating per-session token. Rules out the
|
|
||||||
* "stale identity token" theory tried first.
|
|
||||||
* - Even's real sequence also sends battery (00:01), firmware version
|
|
||||||
* (00:02), and device id (00:0B) - none of which round 1 ever sent -
|
|
||||||
* interleaved with the health requests, not just once upfront. Notably
|
|
||||||
* the firmware-version query lands immediately before Even's own first
|
|
||||||
* successful health request in the real trace. `06:02`, which round 1
|
|
||||||
* did send, never appears anywhere in that real successful sync -
|
|
||||||
* dropped here since there's now real evidence it isn't needed and it
|
|
||||||
* was never more than a guess to begin with.
|
|
||||||
* This round adds 00:01/00:02/00:0B up front rather than interleaved
|
|
||||||
* (interleaving would need restructuring requestRingHealth() too - a
|
|
||||||
* bigger change deferred until this simpler version is shown to help or
|
|
||||||
* not).
|
|
||||||
*/
|
*/
|
||||||
private void sendRingHandshake() {
|
private void sendRingHandshake() {
|
||||||
// +14400s was hardcoded here because every capture behind this work was
|
|
||||||
// taken in EDT, where 14400s happens to be the magnitude of the UTC
|
|
||||||
// offset - so the constant was right by coincidence of season, not by
|
|
||||||
// derivation, and would have gone an hour wrong at the next DST change.
|
|
||||||
// This computes it instead: identical in EDT, correct year-round.
|
|
||||||
//
|
|
||||||
// ⚠ MIND THE SIGN. The ring's clock runs AHEAD of real time by the
|
|
||||||
// magnitude of a west-of-UTC offset, so the quantity wanted here is
|
|
||||||
// NEGATIVE `TimeZone.getOffset()`, which is itself negative west of UTC
|
|
||||||
// (-14400000ms in EDT). Getting this backwards sets the ring's clock 8h
|
|
||||||
// wrong rather than 0h wrong. Measured 2026-09-12: the un-negated form
|
|
||||||
// logged -14400 and the ring then returned step buckets dated 8h out.
|
|
||||||
//
|
|
||||||
// Note this is the OPPOSITE of the "ring stores naive local time"
|
|
||||||
// hypothesis, which predicts `epoch + utc_offset` = epoch - 14400. The
|
|
||||||
// measured, working value is epoch + 14400. The hypothesis is therefore
|
|
||||||
// NOT confirmed by this code; what is preserved here is the behaviour
|
|
||||||
// verified against six real Even clock-set writes.
|
|
||||||
//
|
|
||||||
// ⚠ PAIRED with `ringClockOffsetMs()` in `app/health/health-live.ts`,
|
|
||||||
// which subtracts the same quantity on the way back out. These two must
|
|
||||||
// move together; both now compute the value rather than hardcoding EDT.
|
|
||||||
long nowMs = System.currentTimeMillis();
|
long nowMs = System.currentTimeMillis();
|
||||||
long clockOffsetSeconds = -TimeZone.getDefault().getOffset(nowMs) / 1000L;
|
long clockOffsetSeconds = -TimeZone.getDefault().getOffset(nowMs) / 1000L;
|
||||||
long liveClockSeconds = (nowMs / 1000L) + clockOffsetSeconds;
|
long liveClockSeconds = (nowMs / 1000L) + clockOffsetSeconds;
|
||||||
// Asserted at every handshake: in EDT this must read 14400. The clock write
|
Log.i(TAG, "ring handshake legacy clock offset seconds = " + clockOffsetSeconds
|
||||||
// is the part of this protocol that took two sessions to get working, so a
|
|
||||||
// changed value here is the one way a working pull silently breaks.
|
|
||||||
Log.i(TAG, "ring handshake clock offset seconds = " + clockOffsetSeconds
|
|
||||||
+ " (tz " + TimeZone.getDefault().getID() + ")");
|
+ " (tz " + TimeZone.getDefault().getID() + ")");
|
||||||
byte[] clock = le32(liveClockSeconds);
|
byte[] clock = le32(liveClockSeconds);
|
||||||
|
|
||||||
@@ -2924,11 +2877,11 @@ public class FaceclawBleCommunicator implements FaceclawBleListener, Runnable {
|
|||||||
* "genuinely nothing new" other than knowing independently whether fresh
|
* "genuinely nothing new" other than knowing independently whether fresh
|
||||||
* data should exist (e.g. from the export's own sampling cadence).
|
* data should exist (e.g. from the export's own sampling cadence).
|
||||||
*
|
*
|
||||||
* <p>Runs on the worker thread (from connectRing), which is the only
|
* <p>Runs on the ring worker (from connectRing), which is the only
|
||||||
* thread allowed to call the blocking write path - the wait loops below
|
* thread allowed to call the blocking write path - the wait loops below
|
||||||
* block that same thread, which is why {@link #flushRingOutbound} is
|
* block that same thread, which is why {@link #flushRingOutbound} is
|
||||||
* called inside the response and DATA waits rather than relying on the
|
* called inside the response and DATA waits rather than relying on the
|
||||||
* main loop's own call to it.
|
* ring loop's own call to it.
|
||||||
*/
|
*/
|
||||||
private boolean requestRingHealth() {
|
private boolean requestRingHealth() {
|
||||||
// A previous attempt may have left an ACK queued after a failed write.
|
// A previous attempt may have left an ACK queued after a failed write.
|
||||||
|
|||||||
+1
-5
@@ -8,15 +8,11 @@ import { Application } from '@nativescript/core'
|
|||||||
import { registerShareIntentHandler } from './native/share-intents'
|
import { registerShareIntentHandler } from './native/share-intents'
|
||||||
import { installNativeUserAgent } from './util/http'
|
import { installNativeUserAgent } from './util/http'
|
||||||
import { registerPhoneRotation } from './native/phone-rotation'
|
import { registerPhoneRotation } from './native/phone-rotation'
|
||||||
|
|
||||||
installNativeUserAgent()
|
|
||||||
registerShareIntentHandler()
|
|
||||||
registerPhoneRotation()
|
|
||||||
|
|
||||||
import { startLiveHealthSync, startAlignedRingPull } from './health/health-live'
|
import { startLiveHealthSync, startAlignedRingPull } from './health/health-live'
|
||||||
|
|
||||||
installNativeUserAgent()
|
installNativeUserAgent()
|
||||||
registerShareIntentHandler()
|
registerShareIntentHandler()
|
||||||
|
registerPhoneRotation()
|
||||||
|
|
||||||
// Ring health records live only in the communicator's memory until something
|
// Ring health records live only in the communicator's memory until something
|
||||||
// stores them. Both health surfaces store on open, but a pull that lands while
|
// stores them. Both health surfaces store on open, but a pull that lands while
|
||||||
|
|||||||
@@ -28,7 +28,7 @@ import {
|
|||||||
type InProcessAppOptions,
|
type InProcessAppOptions,
|
||||||
type InProcessWindow,
|
type InProcessWindow,
|
||||||
} from "../../ui/shell/in-process-window";
|
} from "../../ui/shell/in-process-window";
|
||||||
import { dailySummary, hypnogram, rollupSeries, type DailySummary } from "../../health/health-derive";
|
import { dailySummary, dailyHypnogram, rollupSeries, type DailySummary } from "../../health/health-derive";
|
||||||
import {
|
import {
|
||||||
drawGlancePage,
|
drawGlancePage,
|
||||||
GLANCE_PAGES,
|
GLANCE_PAGES,
|
||||||
@@ -114,8 +114,7 @@ class HealthLayer implements Layer {
|
|||||||
});
|
});
|
||||||
}
|
}
|
||||||
this.hourly = hourly;
|
this.hourly = hourly;
|
||||||
const night = sessions.find((session) => session.dayStartMs === today);
|
this.stageBands = dailyHypnogram(sessions, today);
|
||||||
this.stageBands = night ? hypnogram(night) : [];
|
|
||||||
this.fixture = isFixtureData();
|
this.fixture = isFixtureData();
|
||||||
} catch (error) {
|
} catch (error) {
|
||||||
console.warn("health glance reload failed", error);
|
console.warn("health glance reload failed", error);
|
||||||
|
|||||||
@@ -165,9 +165,7 @@ export function dailySummary(
|
|||||||
const inDay = samples.filter(
|
const inDay = samples.filter(
|
||||||
(sample) => sample.startMs >= dayStartMs && sample.startMs < dayEndMs,
|
(sample) => sample.startMs >= dayStartMs && sample.startMs < dayEndMs,
|
||||||
);
|
);
|
||||||
const night = sleepSessions
|
const nights = sleepSessions.filter((session) => session.dayStartMs === dayStartMs);
|
||||||
.filter((session) => session.dayStartMs === dayStartMs)
|
|
||||||
.sort((a, b) => b.totalSec - a.totalSec)[0];
|
|
||||||
return {
|
return {
|
||||||
dayStartMs,
|
dayStartMs,
|
||||||
steps: Math.round(sumOf(inDay, "steps")),
|
steps: Math.round(sumOf(inDay, "steps")),
|
||||||
@@ -175,7 +173,7 @@ export function dailySummary(
|
|||||||
heartRate: summarise(inDay, "heartRate"),
|
heartRate: summarise(inDay, "heartRate"),
|
||||||
spo2: summarise(inDay, "spo2"),
|
spo2: summarise(inDay, "spo2"),
|
||||||
hrv: summarise(inDay, "hrv"),
|
hrv: summarise(inDay, "hrv"),
|
||||||
sleep: night ? sleepSummary(night) : null,
|
sleep: combinedSleepSummary(nights),
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -250,6 +248,21 @@ export function sleepSummary(session: SleepSession): SleepSummary {
|
|||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Every recorded block attributed to the day contributes to its headline. */
|
||||||
|
export function combinedSleepSummary(sessions: readonly SleepSession[]): SleepSummary | null {
|
||||||
|
if (sessions.length === 0) return null;
|
||||||
|
const combined: SleepSession = {
|
||||||
|
...sessions[0], totalSec: 0, wakeSec: 0, remSec: 0, lightSec: 0, deepSec: 0,
|
||||||
|
timeResolved: sessions.every((session) => session.timeResolved),
|
||||||
|
};
|
||||||
|
for (const session of sessions) {
|
||||||
|
for (const field of ["totalSec", "wakeSec", "remSec", "lightSec", "deepSec"] as const) {
|
||||||
|
combined[field] += Math.max(0, session[field]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return sleepSummary(combined);
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* One stage's seconds, from the summary's own bands.
|
* One stage's seconds, from the summary's own bands.
|
||||||
*
|
*
|
||||||
@@ -272,11 +285,7 @@ export function stageSeconds(stage: SleepStageName, summary: SleepSummary): numb
|
|||||||
* night with no record comes back as `hasData: false` at its real position
|
* night with no record comes back as `hasData: false` at its real position
|
||||||
* rather than shifting every later night one column left.
|
* rather than shifting every later night one column left.
|
||||||
*
|
*
|
||||||
* Two sessions attributed to the same day are SUMMED rather than the longest
|
* Sessions attributed to the same day are summed, as in `dailySummary`.
|
||||||
* winning. That differs from `dailySummary`, which picks the longest because it
|
|
||||||
* is answering "how did you sleep last night" with one headline number; here
|
|
||||||
* the column is the day's total time in each stage, and dropping a nap would
|
|
||||||
* make the bar disagree with the sleep total shown beside it.
|
|
||||||
*/
|
*/
|
||||||
export function sleepNights(
|
export function sleepNights(
|
||||||
sessions: readonly SleepSession[],
|
sessions: readonly SleepSession[],
|
||||||
@@ -336,6 +345,28 @@ export function hypnogram(session: SleepSession): { stage: SleepStageName | null
|
|||||||
}));
|
}));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/** Chronological blocks, with unrecorded intervals left as unknown gaps. */
|
||||||
|
export function dailyHypnogram(sessions: readonly SleepSession[], dayStartMs: number): ReturnType<typeof hypnogram> {
|
||||||
|
const result: ReturnType<typeof hypnogram> = [];
|
||||||
|
let previousEnd: number | null = null;
|
||||||
|
for (const session of sessions.filter((s) => s.dayStartMs === dayStartMs)
|
||||||
|
.sort((a, b) => a.startMs - b.startMs)) {
|
||||||
|
if (previousEnd !== null && session.timeResolved && session.startMs > previousEnd) {
|
||||||
|
result.push({ stage: null, seconds: (session.startMs - previousEnd) / 1000 });
|
||||||
|
}
|
||||||
|
const bands = hypnogram(session);
|
||||||
|
result.push(...bands);
|
||||||
|
// A session without stage data still occupies its recorded interval.
|
||||||
|
const covered = bands.reduce((total, band) => total + band.seconds, 0);
|
||||||
|
const duration = session.timeResolved
|
||||||
|
? Math.max(0, (session.endMs - session.startMs) / 1000)
|
||||||
|
: session.totalSec + session.wakeSec;
|
||||||
|
if (duration > covered) result.push({ stage: null, seconds: duration - covered });
|
||||||
|
previousEnd = session.timeResolved ? Math.max(previousEnd ?? 0, session.endMs) : null;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Date formatting, done by hand.
|
* Date formatting, done by hand.
|
||||||
*
|
*
|
||||||
|
|||||||
+10
-54
@@ -77,66 +77,22 @@ function activeCommunicator(): any {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The ring timestamps in a frame 4 hours ahead of real time, and that is our
|
* Legacy compensation for the incorrect extra timezone shift sent by the
|
||||||
* own doing: the handshake sets its clock to `now + 14400s`, because that is
|
* handshake. This is not a ring protocol requirement. Fresh HR timestamps on
|
||||||
* what a real Even write carries (verified against six of them). Even's app
|
* the PDT test ring run seven hours ahead, but older values and daily anchors
|
||||||
* evidently subtracts the same offset on the way back out. We were not, so
|
* do not share that shift. Keep this paired with the existing handshake until
|
||||||
* every hourly sample landed 4 hours in the future.
|
* a controlled UTC migration; do not apply it retrospectively to raw history.
|
||||||
*
|
* See notes/ring-health-live-validation.md.
|
||||||
* MEASURED, not theorised. Stored samples read 09:00/10:00/11:00 local while
|
|
||||||
* the actual time was 07:15; minus four hours gives 05:00/06:00/07:00, which
|
|
||||||
* is exactly right for a ring that had just reported the current hour.
|
|
||||||
*
|
|
||||||
* ⚠ This value is PAIRED with the offset in `sendRingHandshake()`. They must
|
|
||||||
* move together.
|
|
||||||
*
|
|
||||||
* Both were hardcoded to 14400. As of 2026-09-12 both COMPUTE it: 14400 was
|
|
||||||
* only ever right because every capture behind this work was taken in EDT,
|
|
||||||
* where 14400s is the magnitude of the UTC offset. Computing it is identical
|
|
||||||
* today and survives DST.
|
|
||||||
*
|
|
||||||
* ⚠ MIND THE SIGN. The quantity is "how far AHEAD of real time the ring's clock
|
|
||||||
* runs", which is the magnitude of a west-of-UTC offset — positive 14400 in
|
|
||||||
* EDT. `getTimezoneOffset()` is already minutes WEST of UTC (+240 in EDT), so
|
|
||||||
* it is used as-is, NOT negated. Java's `TimeZone.getOffset()` uses the
|
|
||||||
* opposite convention and is negated there; the two agree on +14400.
|
|
||||||
*
|
|
||||||
* Worth recording because the first cut of this change got the sign backwards
|
|
||||||
* on both sides at once — consistently, so they stayed "paired", and still
|
|
||||||
* wrong by 8 hours. Only the handshake's own assertion log caught it.
|
|
||||||
*
|
|
||||||
* Note this direction is the OPPOSITE of the "ring stores naive local time"
|
|
||||||
* hypothesis (which predicts `epoch + utc_offset`, i.e. 4h behind). Measured
|
|
||||||
* behaviour is 4h ahead. The hypothesis is unconfirmed; the measurement rules.
|
|
||||||
*/
|
*/
|
||||||
function ringClockOffsetMs(atMs: number): number {
|
function ringClockOffsetMs(atMs: number): number {
|
||||||
return new Date(atMs).getTimezoneOffset() * 60 * 1000;
|
return new Date(atMs).getTimezoneOffset() * 60 * 1000;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Sleep timestamps need TWICE the correction the hourly samples need.
|
* Inherited sleep-specific heuristic, still unvalidated on this ring (no sleep
|
||||||
*
|
* DATA page received yet). Firmware describes UTC timestamps, not a double
|
||||||
* ⚠ EMPIRICAL, AND THE MECHANISM IS UNEXPLAINED. Do not read a story into the
|
* timezone offset. Remove alongside the controlled clock migration, then
|
||||||
* factor of 2. The last time this file invented a tidy explanation for a ring
|
* validate against a recorded night; it is not evidence of correct placement.
|
||||||
* clock quirk ("the ring stores naive local time") it was falsified the next
|
|
||||||
* day, which is why the hourly comment above ends with "the measurement rules".
|
|
||||||
* The same applies here, more so: nothing about a sleep record is known to
|
|
||||||
* differ from an hourly one in how it is stamped, and yet the correction does.
|
|
||||||
*
|
|
||||||
* The evidence, 2026-09-12, the first real sleep record off the hardware:
|
|
||||||
* `start_ts` decodes raw to 10:21:01 EDT. Chris confirmed the true window two
|
|
||||||
* independent ways - he slept "straight through from around 1:30 AM to 9:30 AM",
|
|
||||||
* and separately reported seeing only the first block with "another 4 or so
|
|
||||||
* hours after that". Under -4h the block is 06:21 -> 09:25, which puts the
|
|
||||||
* missing time BEFORE it and contradicts what the device showed. Under -8h it
|
|
||||||
* is 02:21 -> 05:25, leaving 05:25 -> 09:30 (4h05m) missing AFTER it, which is
|
|
||||||
* what he saw.
|
|
||||||
*
|
|
||||||
* Expressed as twice `ringClockOffsetMs` rather than a fresh 28800 so the
|
|
||||||
* November DST change moves the hourly correction and this one together. Like
|
|
||||||
* the hourly path it is evaluated at the RAW instant, so within ~8h of a DST
|
|
||||||
* switch it can pick the wrong side by an hour - the same caveat, deliberately
|
|
||||||
* kept identical rather than special-cased here.
|
|
||||||
*/
|
*/
|
||||||
function sleepClockOffsetMs(atMs: number): number {
|
function sleepClockOffsetMs(atMs: number): number {
|
||||||
return 2 * ringClockOffsetMs(atMs);
|
return 2 * ringClockOffsetMs(atMs);
|
||||||
|
|||||||
@@ -41,7 +41,7 @@ Faceclaw now uses the direct status while the ring link is connected, falling
|
|||||||
back to the glasses report on disconnect. This does not repair the separate
|
back to the glasses report on disconnect. This does not repair the separate
|
||||||
stock ring-to-glasses connection or its cached battery reading.
|
stock ring-to-glasses connection or its cached battery reading.
|
||||||
|
|
||||||
## Remaining clock validation
|
## Clock investigation (follow-up)
|
||||||
|
|
||||||
Successful decoding does not establish correct chart timestamps. This ring's
|
Successful decoding does not establish correct chart timestamps. This ring's
|
||||||
reported day anchor had nonzero hour/minute/second components; the inherited
|
reported day anchor had nonzero hour/minute/second components; the inherited
|
||||||
@@ -55,3 +55,66 @@ CRC-valid frames are now retained before acknowledgement in the app-private
|
|||||||
preserves evidence and permits later reprocessing; it is not yet an automatic
|
preserves evidence and permits later reprocessing; it is not yet an automatic
|
||||||
replay/import path. The earlier rejected pages were not journaled by the old
|
replay/import path. The earlier rejected pages were not journaled by the old
|
||||||
build, and re-delivery of them is not guaranteed.
|
build, and re-delivery of them is not guaranteed.
|
||||||
|
|
||||||
|
`python3 tools/ring-clock-audit.py <journal.jsonl>` reports the relevant time
|
||||||
|
fields without emitting measurement values. It reads the journal without
|
||||||
|
modifying it. All instants below are UTC, avoiding local display ambiguity.
|
||||||
|
|
||||||
|
| Field | Observed value |
|
||||||
|
| --- | --- |
|
||||||
|
| Phone reception of fresh HR page | Sep 18 04:07:28.792 |
|
||||||
|
| Latest HR timestamp in that page | Sep 18 11:07:25 |
|
||||||
|
| Difference | +25,196.208 seconds (seven hours minus 3.792 seconds) |
|
||||||
|
| Daily anchor, shared across metric pages | Sep 17 12:47:44 |
|
||||||
|
| Timezone in those pages | -420 minutes |
|
||||||
|
| Anchor's local time | 05:47:44, not midnight |
|
||||||
|
| Latest HRV / SpO2 timestamps | Sep 18 03:39:03 / 03:38:51 |
|
||||||
|
|
||||||
|
The handshake explicitly sends `phone Unix seconds - UTC offset`, or UTC +7h
|
||||||
|
in PDT. The fresh HR timestamp is consistent with that incorrect initialization.
|
||||||
|
The older HRV/SpO2 timestamps precede reception and cannot be assumed to have
|
||||||
|
the same error. The unchanged bucket index 20 and non-midnight anchor also
|
||||||
|
indicate that a clock change did not rebuild all existing daily metadata.
|
||||||
|
We cannot infer trustworthy dates for those buckets from the latest HR time.
|
||||||
|
|
||||||
|
The sibling openCFW checkout's `r1/docs/correlation/CLOCK-PRODUCTION-CORRELATION.md`
|
||||||
|
and recovered RTC evidence describe command `00:05` as UTC epoch seconds plus a
|
||||||
|
separate signed timezone offset. The clock applies that offset for local-calendar
|
||||||
|
bucketing. Command `00:0e` is a health-recording setting, not a second clock setter.
|
||||||
|
The inherited comments claiming that UTC+offset and double sleep correction were
|
||||||
|
protocol requirements have therefore been replaced with explicit migration TODOs.
|
||||||
|
|
||||||
|
**Do not silently rewind the live ring.**
|
||||||
|
`r1/docs/correlation/TIME-HEALTH-ROLLOVER-CORRELATION.md` and
|
||||||
|
`r1_health_plan_time_transition` document stock behavior: a backward jump of at
|
||||||
|
least 3,600 seconds requests health-database formatting and synchronization cursor
|
||||||
|
reset. A seven-hour correction can erase history still held only by the ring.
|
||||||
|
The local phone-store backup is `/tmp/faceclaw-health-before-clock.tar`; it
|
||||||
|
preserves received frames and derived records, not every possible unreceived page.
|
||||||
|
No clock correction or historical timestamp rewrite was performed in this follow-up.
|
||||||
|
|
||||||
|
The next controlled test is to finish a health pull, preserve its raw pages, then
|
||||||
|
set `00:05` to actual UTC seconds with the phone's offset still in its separate
|
||||||
|
field. Remove the matching display corrections for new records and keep old
|
||||||
|
ambiguous records archived separately. Verify the command response, fresh HR time
|
||||||
|
against receipt time, and a new daily anchor against local midnight. This test
|
||||||
|
requires permission for the firmware's possible history reset. Sleep clock and
|
||||||
|
duration units still require a real sleep DATA page; no sleep has been observed
|
||||||
|
on this new ring.
|
||||||
|
|
||||||
|
## Remaining initial-review fixes
|
||||||
|
|
||||||
|
- Ring connection, handshake, health waits and page ACKs now run on one dedicated
|
||||||
|
ring worker. GATT locking is per address, so the glasses sender continues while
|
||||||
|
the ring connects or waits for pages. Shutdown interrupts and joins both workers.
|
||||||
|
- Daily sleep totals include all sessions attributed to the wake-up day. The
|
||||||
|
detail view orders their stage blocks chronologically and leaves unrecorded
|
||||||
|
intervals unknown instead of counting them as sleep.
|
||||||
|
- Startup registers the share-intent handler and native user agent once.
|
||||||
|
|
||||||
|
Validation: Android build and full TypeScript check passed; focused health and
|
||||||
|
ring tests passed (36 passed, one pre-existing timezone-specific skip). Installed
|
||||||
|
on the Pixel 7a. The 21:19:58–21:20:08 local-time pull answered all five health
|
||||||
|
requests on the ring worker while the glasses sender delivered and received
|
||||||
|
ACKs for images roughly every 0.8 seconds throughout that interval. Battery
|
||||||
|
remained 85%. The historical timestamp heuristics are still unchanged.
|
||||||
+32
-2
@@ -6,13 +6,14 @@ import java.util.List;
|
|||||||
import java.util.concurrent.Executors;
|
import java.util.concurrent.Executors;
|
||||||
import java.util.concurrent.ScheduledExecutorService;
|
import java.util.concurrent.ScheduledExecutorService;
|
||||||
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.TimeUnit;
|
||||||
|
import java.util.concurrent.CountDownLatch;
|
||||||
|
|
||||||
public final class RingHealthTransferTest implements AutoCloseable {
|
public final class RingHealthTransferTest implements AutoCloseable {
|
||||||
private final Object lock = new Object();
|
private final Object lock = new Object();
|
||||||
private final ArrayDeque<byte[]> ringOutbound = new ArrayDeque<>();
|
private final ArrayDeque<byte[]> ringOutbound = new ArrayDeque<>();
|
||||||
private final ScheduledExecutorService callbacks = Executors.newSingleThreadScheduledExecutor();
|
private final ScheduledExecutorService callbacks = Executors.newSingleThreadScheduledExecutor();
|
||||||
private final List<String> writes = new ArrayList<>();
|
private final List<String> writes = new ArrayList<>();
|
||||||
private boolean running = true;
|
private volatile boolean running = true;
|
||||||
private boolean ringConnected = true;
|
private boolean ringConnected = true;
|
||||||
private boolean ringNotificationsReady = true;
|
private boolean ringNotificationsReady = true;
|
||||||
private boolean ringHealthRspSeen;
|
private boolean ringHealthRspSeen;
|
||||||
@@ -21,6 +22,20 @@ public final class RingHealthTransferTest implements AutoCloseable {
|
|||||||
private boolean failAck;
|
private boolean failAck;
|
||||||
private boolean answer = true;
|
private boolean answer = true;
|
||||||
private boolean delayRsp;
|
private boolean delayRsp;
|
||||||
|
private boolean pullRequested = true;
|
||||||
|
private final CountDownLatch requestStarted = new CountDownLatch(1);
|
||||||
|
private final String ringAddress = "ring";
|
||||||
|
private long ringReconnectAfterMs;
|
||||||
|
private static class ConnectionOptions { static final int RING_RECONNECT_DELAY_MS = 1000; }
|
||||||
|
private static class BleManager { void disconnect(String address) {} }
|
||||||
|
private final BleManager bleManager = new BleManager();
|
||||||
|
private static String safeMessage(Throwable t) { return t.getMessage(); }
|
||||||
|
private boolean shouldAttemptRingConnect() { return false; }
|
||||||
|
private void tryConnectRing(String reason) { throw new AssertionError("unexpected connect"); }
|
||||||
|
private void runRequestedRingHealthPull() {
|
||||||
|
if (pullRequested) { pullRequested = false; requestRingHealth(); }
|
||||||
|
}
|
||||||
|
private void resumeAbortedRingHealthPull() {}
|
||||||
private static final long RING_HEALTH_RSP_TIMEOUT_MS = 500;
|
private static final long RING_HEALTH_RSP_TIMEOUT_MS = 500;
|
||||||
private static final long RING_HEALTH_DATA_IDLE_MS = 100;
|
private static final long RING_HEALTH_DATA_IDLE_MS = 100;
|
||||||
private static final int[] RING_DEVICE_PING_CMD_LO = {10, 1, 2, 11};
|
private static final int[] RING_DEVICE_PING_CMD_LO = {10, 1, 2, 11};
|
||||||
@@ -53,6 +68,7 @@ public final class RingHealthTransferTest implements AutoCloseable {
|
|||||||
try { Thread.sleep(130); } catch (InterruptedException e) { throw new AssertionError(e); }
|
try { Thread.sleep(130); } catch (InterruptedException e) { throw new AssertionError(e); }
|
||||||
if (pageId % 10 == 1) callbacks.schedule(() -> page(pageId + 1), 5, TimeUnit.MILLISECONDS);
|
if (pageId % 10 == 1) callbacks.schedule(() -> page(pageId + 1), 5, TimeUnit.MILLISECONDS);
|
||||||
} else {
|
} else {
|
||||||
|
requestStarted.countDown();
|
||||||
int command = RingProtocol.parse(frame).cmdHi;
|
int command = RingProtocol.parse(frame).cmdHi;
|
||||||
writes.add("req:" + command);
|
writes.add("req:" + command);
|
||||||
if (answer) {
|
if (answer) {
|
||||||
@@ -73,7 +89,21 @@ public final class RingHealthTransferTest implements AutoCloseable {
|
|||||||
|
|
||||||
@Override public void close() { callbacks.shutdownNow(); }
|
@Override public void close() { callbacks.shutdownNow(); }
|
||||||
|
|
||||||
public static void main(String[] args) {
|
public static void main(String[] args) throws Exception {
|
||||||
|
try (RingHealthTransferTest transfer = new RingHealthTransferTest()) {
|
||||||
|
transfer.answer = false;
|
||||||
|
Thread worker = new Thread(transfer::runRingWorker);
|
||||||
|
worker.start();
|
||||||
|
if (!transfer.requestStarted.await(1, TimeUnit.SECONDS)) throw new AssertionError("no request");
|
||||||
|
// The glasses sender can still take the session lock while the
|
||||||
|
// ring is waiting on its RSP. Shutdown must cancel that wait too.
|
||||||
|
long start = SystemClock.elapsedRealtime();
|
||||||
|
synchronized (transfer.lock) { transfer.running = false; transfer.lock.notifyAll(); }
|
||||||
|
worker.interrupt();
|
||||||
|
worker.join(300);
|
||||||
|
if (worker.isAlive()) throw new AssertionError("ring worker did not stop");
|
||||||
|
if (SystemClock.elapsedRealtime() - start >= 300) throw new AssertionError("session lock blocked");
|
||||||
|
}
|
||||||
try (RingHealthTransferTest transfer = new RingHealthTransferTest()) {
|
try (RingHealthTransferTest transfer = new RingHealthTransferTest()) {
|
||||||
transfer.delayRsp = true;
|
transfer.delayRsp = true;
|
||||||
if (!transfer.requestRingHealth()) throw new AssertionError("pull failed");
|
if (!transfer.requestRingHealth()) throw new AssertionError("pull failed");
|
||||||
|
|||||||
@@ -22,6 +22,7 @@ const assert = require("node:assert/strict");
|
|||||||
const { buildFixtures } = require("../.test-build/app/health/health-fixtures.js");
|
const { buildFixtures } = require("../.test-build/app/health/health-fixtures.js");
|
||||||
const {
|
const {
|
||||||
dailySummary,
|
dailySummary,
|
||||||
|
dailyHypnogram,
|
||||||
sleepNights,
|
sleepNights,
|
||||||
sleepSummary,
|
sleepSummary,
|
||||||
stageSeconds,
|
stageSeconds,
|
||||||
@@ -103,6 +104,32 @@ test("two sessions on one day are summed, not deduped to the longest", () => {
|
|||||||
Math.abs(nights[0].lightSec - (3600 + 1800) * 0.6) < 1e-6,
|
Math.abs(nights[0].lightSec - (3600 + 1800) * 0.6) < 1e-6,
|
||||||
"stage totals add across both sessions",
|
"stage totals add across both sessions",
|
||||||
);
|
);
|
||||||
|
const summary = dailySummary([], [night(3600, 300), night(1800, 60)], today).sleep;
|
||||||
|
assert.equal(summary.totalSec, 5400);
|
||||||
|
assert.equal(summary.wakeSec, 360);
|
||||||
|
assert.equal(summary.efficiencyPercent, 5400 / 5760 * 100);
|
||||||
|
assert.equal(dailySummary([], [], today).sleep, null);
|
||||||
|
});
|
||||||
|
|
||||||
|
test("split-night detail includes both blocks and leaves the gap unknown", () => {
|
||||||
|
const today = startOfLocalDay(Date.now());
|
||||||
|
const block = (hour, stageId) => ({
|
||||||
|
dayStartMs: today, startMs: today + hour * 3600000,
|
||||||
|
endMs: today + (hour + 1) * 3600000,
|
||||||
|
totalSec: 3600, wakeSec: 0, remSec: 0, lightSec: 3600, deepSec: 0,
|
||||||
|
segments: [{ stageId, halfMinutes: 120 }], timeResolved: true,
|
||||||
|
});
|
||||||
|
const first = block(1, 1), second = block(3, 2);
|
||||||
|
const bands = dailyHypnogram([second, first, { ...block(1, 3), dayStartMs: today - DAY_MS }], today);
|
||||||
|
assert.equal(bands.length, 3);
|
||||||
|
assert.deepEqual(bands[1], { stage: null, seconds: 3600 });
|
||||||
|
assert.equal(bands[0].seconds, 3600);
|
||||||
|
assert.equal(bands[2].seconds, 3600);
|
||||||
|
assert.notEqual(bands[0].stage, bands[2].stage);
|
||||||
|
assert.equal(dailySummary([], [first, second], today).sleep.totalSec, 7200,
|
||||||
|
"an unrecorded gap is not counted as sleep");
|
||||||
|
assert.deepEqual(dailyHypnogram([{ ...first, segments: [] }], today),
|
||||||
|
[{ stage: null, seconds: 3600 }]);
|
||||||
});
|
});
|
||||||
|
|
||||||
test("a stage's lane duration comes from the named totals", () => {
|
test("a stage's lane duration comes from the named totals", () => {
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
const test = require("node:test");
|
const test = require("node:test");
|
||||||
|
const assert = require("node:assert/strict");
|
||||||
const fs = require("node:fs");
|
const fs = require("node:fs");
|
||||||
const os = require("node:os");
|
const os = require("node:os");
|
||||||
const path = require("node:path");
|
const path = require("node:path");
|
||||||
@@ -11,12 +12,19 @@ test("ring health drains ACK-paced pages before advancing and aborts on write fa
|
|||||||
"../App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.java"), "utf8");
|
"../App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.java"), "utf8");
|
||||||
// Compile the actual worker methods with a fake GATT transport. This keeps
|
// Compile the actual worker methods with a fake GATT transport. This keeps
|
||||||
// Android out of the JVM test without copying the transfer implementation.
|
// Android out of the JVM test without copying the transfer implementation.
|
||||||
const methods = ["requestRingHealth", "awaitRingHealthRsp", "awaitRingHealthDataIdle", "flushRingOutbound"]
|
const methods = ["requestRingHealth", "awaitRingHealthRsp", "awaitRingHealthDataIdle", "flushRingOutbound", "runRingWorker"]
|
||||||
.map((name) => {
|
.map((name) => {
|
||||||
const match = source.match(new RegExp(` private (?:boolean|int|void) ${name}\\([^]*?^ }`, "m"));
|
const match = source.match(new RegExp(` private (?:boolean|int|void) ${name}\\([^]*?^ }`, "m"));
|
||||||
if (!match) throw new Error(`Missing production method: ${name}`);
|
if (!match) throw new Error(`Missing production method: ${name}`);
|
||||||
return match[0];
|
return match[0];
|
||||||
}).join("\n");
|
}).join("\n");
|
||||||
|
for (const signature of ["@Override public void run()", "private void connectLoopOnce()"]) {
|
||||||
|
const start = source.indexOf(signature);
|
||||||
|
assert.ok(start >= 0);
|
||||||
|
const body = source.slice(start, source.indexOf("\n }", start));
|
||||||
|
assert.doesNotMatch(body, /tryConnectRing\(|requestRingHealth\(|flushRingOutbound\(|runRequestedRingHealthPull\(/,
|
||||||
|
"the glasses sender must not call blocking ring operations");
|
||||||
|
}
|
||||||
const fixture = fs.readFileSync(path.join(__dirname, "fixtures/RingHealthTransferTest.java"), "utf8");
|
const fixture = fs.readFileSync(path.join(__dirname, "fixtures/RingHealthTransferTest.java"), "utf8");
|
||||||
const harness = path.join(directory, "RingHealthTransferTest.java");
|
const harness = path.join(directory, "RingHealthTransferTest.java");
|
||||||
fs.writeFileSync(harness, fixture.replace("// TRANSFER_METHODS", methods));
|
fs.writeFileSync(harness, fixture.replace("// TRANSFER_METHODS", methods));
|
||||||
|
|||||||
@@ -0,0 +1,69 @@
|
|||||||
|
#!/usr/bin/env python3
|
||||||
|
"""Inspect timestamps in an app-private ring-frames.jsonl export (read-only).
|
||||||
|
|
||||||
|
Prints clock metadata, never measurement values. A latest timestamp may be old;
|
||||||
|
its age is not by itself a clock measurement. Repeated *future* HR timestamps
|
||||||
|
tracking receipt time are stronger evidence. All output instants are UTC.
|
||||||
|
"""
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import datetime
|
||||||
|
import json
|
||||||
|
import struct
|
||||||
|
|
||||||
|
|
||||||
|
def utc(seconds):
|
||||||
|
return datetime.datetime.fromtimestamp(seconds, datetime.timezone.utc).isoformat()
|
||||||
|
|
||||||
|
|
||||||
|
def audit(record):
|
||||||
|
raw = bytes.fromhex(record["raw"])
|
||||||
|
if len(raw) < 24 or raw[5:8] != b"\x64\x02\x64" or raw[10] != 2 or raw[12] != 1:
|
||||||
|
return None
|
||||||
|
if int.from_bytes(raw[13:15], "little") != len(raw) - 5:
|
||||||
|
return None
|
||||||
|
command = raw[11]
|
||||||
|
metric = {1: "heart_rate", 2: "spo2", 4: "hrv", 5: "steps"}.get(command)
|
||||||
|
if metric is None:
|
||||||
|
return None
|
||||||
|
payload = raw[15:]
|
||||||
|
count, offset, anchor = struct.unpack_from("<BhI", payload, 2)
|
||||||
|
width = 2 if command == 4 else 1
|
||||||
|
stride = 7 if command == 5 else 1 + 3 * width
|
||||||
|
header = len(payload) - count * stride
|
||||||
|
if header not in ((9,) if command == 5 else (9, 13 + width)):
|
||||||
|
return None
|
||||||
|
received = record["receivedAtMs"] / 1000
|
||||||
|
result = {
|
||||||
|
"received_utc": utc(received),
|
||||||
|
"metric": metric,
|
||||||
|
"timezone_minutes": offset,
|
||||||
|
"anchor_utc": utc(anchor),
|
||||||
|
"anchor_local_seconds_after_midnight": (anchor + offset * 60) % 86400,
|
||||||
|
"bucket_indices": list(payload[header::stride]),
|
||||||
|
}
|
||||||
|
if command != 5 and header != 9:
|
||||||
|
latest = struct.unpack_from("<I", payload, 9)[0]
|
||||||
|
result["latest_utc"] = utc(latest)
|
||||||
|
result["latest_minus_received_seconds"] = round(latest - received, 3)
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__)
|
||||||
|
parser.add_argument("journal")
|
||||||
|
args = parser.parse_args()
|
||||||
|
with open(args.journal, encoding="utf-8") as journal:
|
||||||
|
for number, line in enumerate(journal, 1):
|
||||||
|
if not line.strip():
|
||||||
|
continue
|
||||||
|
try:
|
||||||
|
result = audit(json.loads(line))
|
||||||
|
except (ValueError, KeyError, TypeError, struct.error) as error:
|
||||||
|
raise SystemExit(f"Invalid journal line {number}: {error}") from error
|
||||||
|
if result is not None:
|
||||||
|
print(json.dumps(result))
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
Reference in new issue
Block a user