diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt index c5b6d52e..89448026 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt @@ -269,6 +269,13 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun setGlassesRingLink(action: String, fallbackAddress: String?, fallbackName: String?): Boolean = core.setGlassesRingLink(action, fallbackAddress, fallbackName) + /** See [GlassesSessionCore.sendRingConfigCommand]. */ + fun sendRingConfigCommand(action: String, fallbackAddress: String?, fallbackName: String?): String = + core.sendRingConfigCommand(action, fallbackAddress, fallbackName) + + /** See [GlassesSessionCore.setDirectRingRole]. */ + fun setDirectRingRole(role: String?) = core.setDirectRingRole(role) + fun addImuListener(listener: FaceclawImuListener?) = core.addImuListener(listener) fun removeImuListener(listener: FaceclawImuListener?) = core.removeImuListener(listener) diff --git a/app/apps/developer/ring-status.ts b/app/apps/developer/ring-status.ts index f20cbb3e..2b8aac97 100644 --- a/app/apps/developer/ring-status.ts +++ b/app/apps/developer/ring-status.ts @@ -3,13 +3,17 @@ import { GrayImage } from "../../graphics/image"; import { type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; import { shell } from "../../ui/shell/shell"; -import { ringConnectionModeSetting } from "../../ui/dashboard-settings"; +import { MenuLayer, type MenuItem } from "../../ui/menu"; +import { ringConnectionModeSetting, ringDirectRoleSetting } from "../../ui/dashboard-settings"; import { loadDeviceAddresses } from "../../g2/device-addresses"; import { getRingSessionStatus, getRingSystemBluetoothState, + sendRingConfigCommand, + setDirectRingRole, setGlassesRingLink, type GlassesRingLinkAction, + type RingConfigAction, type RingSessionStatus, type RingSystemBluetoothState, } from "../../native/ring-status"; @@ -20,26 +24,46 @@ const VALUE_X = 130; const BUTTON_GAP = 8; type Row = { label: string; value: string; dim?: boolean }; -type Button = { label: string; action: GlassesRingLinkAction | "mode" }; +type Button = "glasses" | "ring" | "mode" | "role"; -const BUTTONS: readonly Button[] = [ - { label: "Disconnect", action: "disconnect" }, - { label: "Release", action: "release" }, - { label: "Reconnect", action: "connect" }, - { label: "Mode", action: "mode" }, +const BUTTONS: readonly Button[] = ["glasses", "ring", "mode", "role"]; + +/** Glasses-side commands (sid 0x80 pair manager). */ +const GLASSES_ACTIONS: readonly { label: string; action: GlassesRingLinkAction }[] = [ + { label: "Disconnect ring", action: "disconnect" }, + { label: "Release ring", action: "release" }, + { label: "Unpair ring", action: "unpair" }, + { label: "Connect ring", action: "connect" }, ]; +/** Ring-side commands over the direct link, and the combined flows. */ +const RING_ACTIONS: readonly { label: string; action: RingConfigAction }[] = [ + { label: "Bind to these glasses", action: "bind" }, + { label: "Unbind from glasses", action: "unbind" }, + { label: "Targets: these glasses", action: "targets-glasses" }, + { label: "Targets: clear (any)", action: "targets-clear" }, + { label: "Remove ring notify", action: "remove-ring" }, + { label: "Touch source on", action: "touch-on" }, + { label: "Touch source off", action: "touch-off" }, + { label: "Pair auth (phone role)", action: "pair-auth" }, +]; + +const ACTION_MENU_LAYOUT = { x: "center" as const, y: 8, width: 300, dimUnderneath: 0.35 }; + /** * Where R1 ring input is coming from: the phone's own Bluetooth link to the * ring, the direct-link session state, and when input last arrived directly - * versus relayed by the glasses. A ring connected to the glasses does not - * also report gestures to a phone that connects to it directly, so the two - * "input" rows are the quickest way to see which path is live. + * versus relayed by the glasses. The ring sends gestures only to whichever + * link holds its glasses role, so the two "input" rows are the quickest way + * to see which path is live. * - * The buttons are EXPERIMENTAL glasses-side ring link commands (sid 0x80, - * see GlassesSessionRing.kt): Disconnect / Release ask the glasses to let go - * of the ring, Reconnect hands it back, and Mode flips the Developer "Ring - * connection" setting, which applies on the next glasses connection. + * Everything below is EXPERIMENTAL (see GlassesSessionRing.kt and + * notes/ring-link-control.md). "Glasses..." sends sid 0x80 ring-link commands + * to the glasses; "Ring..." sends binding commands to the ring over the + * direct link (Mode must be direct and the link up), including Bind/Unbind, + * which do both halves in the official app's order. Mode flips the Developer + * "Ring connection" setting (applies on the next glasses connection); Role + * cycles which ring role the direct link claims and applies immediately. */ export class RingStatusLayer implements Layer { private session: RingSessionStatus | null = null; @@ -101,9 +125,7 @@ export class RingStatusLayer implements Layer { const selected = index === this.selected; if (selected) image.fillRoundedRect(x, buttonTop, buttonWidth, buttonHeight, 40, 4); image.drawRoundedRect(x, buttonTop, buttonWidth, buttonHeight, selected ? 200 : 70, 4); - const text = button.action === "mode" - ? (ringConnectionModeSetting.get() === "direct" ? "Mode: direct" : "Mode: glasses") - : button.label; + const text = buttonLabel(button); image.drawText(font, x + Math.max(0, Math.floor((buttonWidth - font.measureText(text)) / 2)), buttonTop + 4, text, selected ? 255 : 170); }); @@ -132,11 +154,17 @@ export class RingStatusLayer implements Layer { : "not connected"; const since = s.directStateAgeMs >= 0 ? ` ${formatAge(s.directStateAgeMs)}` : ""; const battery = s.directBattery >= 0 ? `, ${s.directBattery}%` : ""; - rows.push({ label: "Direct link", value: `${state}${since}, ${s.directConnectCount} connects${battery}` }); + rows.push({ + label: "Direct link", + value: `${state}${since}, role ${s.directRole}, ${s.directConnectCount} connects${battery}`, + }); } rows.push({ label: "Direct input", value: describeInput(s.lastDirectInputAgeMs, s.lastDirectInput) }); if (s.directEnabled) { rows.push({ label: "Direct pkts", value: describeAge(s.lastDirectNotifyAgeMs) }); + if (s.lastDirectRaw) { + rows.push({ label: "Direct raw", value: `${formatAge(s.lastDirectRawAgeMs)} ago: ${s.lastDirectRaw}` }); + } } rows.push({ label: "Glasses input", value: describeInput(s.lastGlassesInputAgeMs, s.lastGlassesInput) }); rows.push({ @@ -148,27 +176,66 @@ export class RingStatusLayer implements Layer { if (s.lastGlassesReport) { rows.push({ label: "Glasses said", value: `${s.lastGlassesReport} (${formatAge(s.lastGlassesReportAgeMs)} ago)` }); } + if (s.lastRingCommand) { + rows.push({ + label: "Ring cmd", + value: `${s.lastRingCommand} ${formatAge(s.lastRingCommandAgeMs)} ago: ${s.lastRingCommandResult}`, + }); + } if (s.lastCommand) { - rows.push({ label: "Sent", value: `${s.lastCommand} ${formatAge(s.lastCommandAgeMs)} ago` }); - rows.push({ label: "Result", value: `R ${s.lastCommandResultR}; L ${s.lastCommandResultL}` }); + rows.push({ label: "Glasses cmd", value: `${s.lastCommand} ${formatAge(s.lastCommandAgeMs)} ago` }); + rows.push({ label: "Glasses ack", value: `R ${s.lastCommandResultR}; L ${s.lastCommandResultL}` }); } if (s.lastDirectError) rows.push({ label: "Direct error", value: s.lastDirectError, dim: true }); return rows; } - private activate(): void { - const button = BUTTONS[this.selected]!; - if (button.action === "mode") { - const next = ringConnectionModeSetting.get() === "direct" ? "glasses" : "direct"; - ringConnectionModeSetting.set(next); - this.notice = `Ring connection set to ${ringConnectionModeSetting.displayValue(next)}; applies on next glasses connection`; - return; + private activate(ctx: LayerContext): void { + switch (BUTTONS[this.selected]!) { + case "glasses": + ctx.stack.push(this.actionMenu("Glasses ring link", GLASSES_ACTIONS.map(({ label, action }) => ({ + label, + onSelect: (menuCtx) => { + this.runGlassesAction(label, action); + menuCtx.stack.pop(); + }, + })))); + return; + case "ring": + ctx.stack.push(this.actionMenu("Ring binding", RING_ACTIONS.map(({ label, action }) => ({ + label, + onSelect: (menuCtx) => { + this.notice = `${label}: ${sendRingConfigCommand(action, this.ringAddress(), this.system?.name ?? "")}`; + this.poll(); + menuCtx.stack.pop(); + }, + })))); + return; + case "mode": { + const next = ringConnectionModeSetting.get() === "direct" ? "glasses" : "direct"; + ringConnectionModeSetting.set(next); + this.notice = `Ring connection set to ${ringConnectionModeSetting.displayValue(next)}; applies on next glasses connection`; + return; + } + case "role": { + const next = ringDirectRoleSetting.set(ringDirectRoleSetting.next()); + setDirectRingRole(next); + this.notice = this.session?.directEnabled + ? `Direct ring role: ${ringDirectRoleSetting.displayValue(next)}; reconnecting the direct link` + : `Direct ring role: ${ringDirectRoleSetting.displayValue(next)}; used once Mode is direct`; + return; + } } - const address = this.ringAddress(); - const name = this.system?.name ?? ""; - this.notice = setGlassesRingLink(button.action, address, name) - ? `${button.label} sent (experimental)` - : `${button.label} not sent (no session or no ring address)`; + } + + private actionMenu(title: string, items: MenuItem[]): MenuLayer { + return new MenuLayer(title, items, ACTION_MENU_LAYOUT); + } + + private runGlassesAction(label: string, action: GlassesRingLinkAction): void { + this.notice = setGlassesRingLink(action, this.ringAddress(), this.system?.name ?? "") + ? `${label} sent (experimental)` + : `${label} not sent (no session or no ring address)`; this.poll(); } @@ -181,7 +248,7 @@ export class RingStatusLayer implements Layer { this.selected = (this.selected + 1) % BUTTONS.length; return; case "click": - this.activate(); + this.activate(ctx); return; case "double-click": ctx.stack.pop(); @@ -192,6 +259,19 @@ export class RingStatusLayer implements Layer { } } +function buttonLabel(button: Button): string { + switch (button) { + case "glasses": + return "Glasses..."; + case "ring": + return "Ring..."; + case "mode": + return ringConnectionModeSetting.get() === "direct" ? "Mode: direct" : "Mode: glasses"; + case "role": + return `Role: ${ringDirectRoleSetting.get()}`; + } +} + function describeSystem(sys: RingSystemBluetoothState | null): string { if (!sys) return "unknown"; if (sys.error) return `error: ${sys.error}`; diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index bfde6f13..65b3fcb9 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -72,7 +72,7 @@ import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-a import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type WindowHeightMode } from "../ui/shell/geometry"; import { type LayerActions, type TextSettingsEditToggle } from "../ui/layers"; import { type KeyboardInputSession } from "../ui/shell/keyboard-input"; -import { appSwitcherPositionSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayModeSetting, navigateDisplayModeSetting, navigateVerticalPositionSetting, terminalDisplayModeSetting, terminalVerticalPositionSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; +import { appSwitcherPositionSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayModeSetting, navigateDisplayModeSetting, navigateVerticalPositionSetting, terminalDisplayModeSetting, terminalVerticalPositionSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, ringDirectRoleSetting, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, verticalPositionSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization"; import { getInstalledEvenHubAppById, @@ -1446,6 +1446,7 @@ class DashboardController { right: addresses.right, left: addresses.left, ring: ringAddress, + ringRole: ringDirectRoleSetting.get(), }); this.communicator = communicator; // Size the compositor before anything else is awaited: windows opened diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index 9bb7ed63..aa5a9408 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -199,7 +199,7 @@ export class FaceclawCommunicatorBridge { private microphoneWork: Promise = Promise.resolve(); private microphoneToken = 0; - constructor(addresses: { right: string; left: string; ring?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { this.communicator = FaceclawKitIosGlassesSession.alloc().initWithRightAddressLeftAddressRingAddress( String(addresses.right ?? "").toUpperCase(), String(addresses.left ?? "").toUpperCase(), @@ -207,6 +207,10 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevisionRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + // Guarded: an older framework build may not export it yet. + if (addresses.ringRole && typeof this.communicator.setDirectRingRoleRole === "function") { + this.communicator.setDirectRingRoleRole(addresses.ringRole); + } this.listenerProxy = SessionListener.new() as SessionListener; this.listenerProxy.bridge = this; this.communicator.setListenerListener(this.listenerProxy); diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index c469d2c2..1e1ffeec 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -161,7 +161,7 @@ export class FaceclawCommunicatorBridge { private readonly firmwareInfoListeners = new Set<(info: FirmwareInfo) => void>(); private readonly previewAnimationListeners = new Set<() => void>(); - constructor(addresses: { right: string; left: string; ring?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { const context = Utils.android.getApplicationContext(); if (!context) throw new Error("Android application context unavailable"); @@ -173,6 +173,8 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + // Which R1 role the direct ring link claims; only matters with a ring address. + if (addresses.ringRole) this.communicator.setDirectRingRole(addresses.ringRole); this.listenerProxy = new com.faceclaw.app.FaceclawBleCommunicatorListener({ onStateChange: (phase: string, status: string) => { const state = { diff --git a/app/native/ring-status.ts b/app/native/ring-status.ts index 81d6257a..73334a6f 100644 --- a/app/native/ring-status.ts +++ b/app/native/ring-status.ts @@ -37,14 +37,38 @@ export type RingSessionStatus = { lastCommandAgeMs: number; lastCommandResultR: string; lastCommandResultL: string; + /** Which ring role the direct link claims: "both", "phone" or "glasses". */ + directRole: string; + lastRingCommand: string; + lastRingCommandAgeMs: number; + lastRingCommandResult: string; + /** Last direct-link notification nothing decoded: characteristic prefix and hex. */ + lastDirectRaw: string; + lastDirectRawAgeMs: number; }; /** * EXPERIMENTAL glasses-side ring link control (sid 0x80 pair manager): * "disconnect" drops the glasses' ring link, "release" also clears their - * connect mode (may hold off auto-reconnect), "connect" hands the ring back. + * connect mode (may hold off auto-reconnect), "unpair" makes them forget the + * ring, "connect" hands the ring back. */ -export type GlassesRingLinkAction = "disconnect" | "release" | "connect"; +export type GlassesRingLinkAction = "disconnect" | "release" | "unpair" | "connect"; + +/** + * EXPERIMENTAL ring-side binding commands over the direct link (see + * GlassesSessionCore.sendRingConfigCommand). "bind" and "unbind" combine the + * ring and glasses halves in the official app's order. + */ +export type RingConfigAction = + | "bind" + | "unbind" + | "pair-auth" + | "targets-glasses" + | "targets-clear" + | "touch-on" + | "touch-off" + | "remove-ring"; export type RingSystemBluetoothState = { address: string; @@ -100,3 +124,26 @@ export function setGlassesRingLink(action: GlassesRingLinkAction, fallbackAddres return false; } } + +/** A one-line outcome for the UI. */ +export function sendRingConfigCommand(action: RingConfigAction, fallbackAddress: string, fallbackName: string): string { + const active = activeCommunicator(); + if (!active) return "not sent: no glasses session"; + try { + return String(active.sendRingConfigCommand(action, fallbackAddress, fallbackName)); + } catch (error) { + console.warn(`sendRingConfigCommand failed: ${error}`); + return `failed: ${error}`; + } +} + +/** Apply a direct ring role to the running session (reconnects the direct link if it is up). */ +export function setDirectRingRole(role: string): void { + const active = activeCommunicator(); + if (!active) return; + try { + active.setDirectRingRole(role); + } catch (error) { + console.warn(`setDirectRingRole failed: ${error}`); + } +} diff --git a/app/ui/dashboard-settings.ts b/app/ui/dashboard-settings.ts index a8fb4300..c68a1094 100644 --- a/app/ui/dashboard-settings.ts +++ b/app/ui/dashboard-settings.ts @@ -715,6 +715,20 @@ export const ringConnectionModeSetting = new ConfigSettingEnum({ + id: "ring-direct-role", + label: "Direct ring role", + storageKey: "developer.ringDirectRole", + defaultValue: "both", + values: ["both", "phone", "glasses"], + formatValue: (value) => (value === "phone" ? "Phone" : value === "glasses" ? "Glasses" : "Both"), + description: + "EXPERIMENTAL, only used when Ring connection is Direct. The ring has a phone role (health sync) and a glasses role (gestures). Phone: claim only the phone role, like Even's app. Glasses: claim the glasses role so ring gestures come straight to the phone; works only while the glasses are not holding the ring, and disables ring health sync. Both: the old behavior, which asks for both roles on one link.", +}); + // "whisper" (no "onboard-" prefix) is OpenAI's CLOUD realtime model // (gpt-realtime-whisper); "onboard-whisper" is the on-device sherpa-onnx // Whisper backend. Same underlying model family, two different places it diff --git a/app/ui/dashboard/settings-menus.ts b/app/ui/dashboard/settings-menus.ts index 99dc6a6d..2d652554 100644 --- a/app/ui/dashboard/settings-menus.ts +++ b/app/ui/dashboard/settings-menus.ts @@ -57,6 +57,7 @@ import { previewColorSetting, phoneRotationSetting, ringConnectionModeSetting, + ringDirectRoleSetting, sonioxApiKeySetting, screenFadeSetting, enumSettingMenuItem, @@ -184,6 +185,7 @@ function settingsSections(): SettingsSection[] { // Whether the phone opens its own BLE link to the R1 ring; the // glasses relay ring gestures either way. Applied at connect time. enumSettingMenuItem(ringConnectionModeSetting), + enumSettingMenuItem(ringDirectRoleSetting), toggleSettingMenuItem(saveVoiceRecordingsSetting), toggleSettingMenuItem(firmwareDebugFlagsSetting), toggleSettingMenuItem(suspendEvenHubWhenScreenOffSetting), diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt index 33b91e54..28ee4a32 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/BleProtocol.kt @@ -69,6 +69,7 @@ class BleProtocol { // hardware-verified. private const val DEV_CFG_RING_CONNECT_INFO_CMD: Int = 6 private const val DEV_CFG_DISCONNECT_INFO_CMD: Int = 8 + private const val DEV_CFG_UNPAIR_INFO_CMD: Int = 9 /** sid 0x91 RingDataPackage: glasses-side ring events (g2.ring). */ const val SID_RING_DATA: Int = 0x91 @@ -195,6 +196,12 @@ class BleProtocol { const val EVENT_HEAD_UP: Int = 12 + /** Faceclaw/18: R1 touch-down, before the gesture is known (R1 2.3.0+, wire type 10). */ + const val EVENT_RING_PRESS: Int = 14 + + /** CFW's SysEvent for an R1 wire type it has no mapping for; diagnostics only. */ + const val EVENT_RING_UNKNOWN: Int = 127 + const val EVENT_SOURCE_GLASSES_R: Int = 1 const val EVENT_SOURCE_RING: Int = 2 @@ -533,6 +540,26 @@ class BleProtocol { ) } + /** + * UNPAIR_INFO(9) with UnpairInfo{dev=RING(0), ringMac}: the glasses forget their stored ring + * pairing. Never dev=RING_GLASSES(2): openCFW's decompilation shows that also enters OTA + * mode and unpairs the phone from the glasses. The handler uses the MAC only when it is + * exactly 6 bytes; whether it compares it against the stored ring is unknown. + */ + @JvmStatic + fun buildRingUnpairRequest(magic: Int, ringMac: ByteArray): ByteArray { + return concat( + CollectionUtils.listOf( + encodeVarintField(1, DEV_CFG_UNPAIR_INFO_CMD), + encodeVarintField(2, magic), + encodeMessageField(8, concat(CollectionUtils.listOf( + encodeVarintField(1, 0), + encodeBytesField(2, ringMac), + ))), + ) + ) + } + /** * RING_CONNECT_INFO(6) with RingInfo{connectRing, ringMac, ringName}. connectRing is * declared `bytes` but read by the firmware as one byte. Every call overwrites the glasses' diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/FaceclawRingEventDecoder.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/FaceclawRingEventDecoder.kt index 651f18a9..5e086a7c 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/FaceclawRingEventDecoder.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/FaceclawRingEventDecoder.kt @@ -10,57 +10,50 @@ class FaceclawRingEventDecoder { if (((raw == null) || (raw.size == 0))) { return null } - var chargerGesture: DirectRingEvent? = decodeChargerGesture(raw) - if ((chargerGesture != null)) { - return chargerGesture + var report: DirectRingEvent? = decodeRingReport(raw) + if ((report != null)) { + return report } return decodeDirectGesture(raw) } - private fun decodeChargerGesture(raw: ByteArray): DirectRingEvent? { - if ((raw.size != 11)) { + /** + * The R1's standard input report, `00 09 61 00 TYPE AUX SPEED TICK_LE32`: the same + * 11 bytes the ring sends the glasses, which CFW's gesture_fwd.c forwards as an EvenHub + * SysEvent. TYPE maps exactly as CFW maps it, and the raw fields ride along as ring + * metadata, so direct and glasses-relayed input look the same to the TypeScript side + * (including RingInputFilter's 100-tick suppression). Unmapped types become + * EVENT_RING_UNKNOWN, which is kept for diagnostics but never routed as a gesture. + */ + private fun decodeRingReport(raw: ByteArray): DirectRingEvent? { + if (raw.size != 11 || u8(raw[0]) != 0x00 || u8(raw[1]) != 0x09 || + u8(raw[2]) != 0x61 || u8(raw[3]) != 0x00) { return null } - if ( - ((((u8(raw[0]) != 0x00) || (u8(raw[1]) != 0x09)) || (u8(raw[2]) != 0x61)) || - (u8(raw[3]) != 0x00)) - ) { - return null + val type = u8(raw[4]) + val aux = u8(raw[5]) + val speed = u8(raw[6]) + val tick = (u8(raw[7]) or (u8(raw[8]) shl 8) or (u8(raw[9]) shl 16) or (u8(raw[10]) shl 24)) + .toLong() and 0xffffffffL + val label = ringReportTypeName(type) + val eventType = when (type) { + 0x00 -> BleProtocol.EVENT_RING_LONG_PRESS + 0x01 -> BleProtocol.EVENT_CLICK + 0x02 -> BleProtocol.EVENT_DOUBLE_CLICK + 0x04 -> BleProtocol.EVENT_SCROLL_TOP + 0x05 -> BleProtocol.EVENT_SCROLL_BOTTOM + 0x08 -> BleProtocol.EVENT_RING_LONG_PRESS_RELEASE + 0x09 -> BleProtocol.EVENT_SHORT_THEN_LONG_PRESS + 0x0a -> BleProtocol.EVENT_RING_PRESS + else -> BleProtocol.EVENT_RING_UNKNOWN } - var code: Int = u8(raw[4]) - var param: Int = (u8(raw[5]) or (u8(raw[6]) shl 8)) - var tick: Long = - ((((u8(raw[7]) or (u8(raw[8]) shl 8)) or (u8(raw[9]) shl 16)) or - (u8(raw[10]) shl 24)) - .toLong() and 0xffffffffL) - var detail: String = - "code=0x${code.toString(16).padStart(2, '0')}(${chargerCodeName(code)}) param=0x${param.toString(16).padStart(4, '0')} tick=$tick" - when (code) { - 0x00 -> { - return event(BleProtocol.EVENT_RING_LONG_PRESS, "LONG_PRESS", detail) - } - 0x01 -> { - return event(BleProtocol.EVENT_CLICK, "TAP", detail) - } - 0x02 -> { - return event(BleProtocol.EVENT_DOUBLE_CLICK, "DOUBLE_TAP", detail) - } - 0x04 -> { - return event(BleProtocol.EVENT_SCROLL_TOP, "SWIPE_UP", detail) - } - 0x05 -> { - return event(BleProtocol.EVENT_SCROLL_BOTTOM, "SWIPE_DOWN", detail) - } - 0x08 -> { - return event( - BleProtocol.EVENT_RING_LONG_PRESS_RELEASE, - "LONG_PRESS_RELEASE", - detail, - ) - } - else -> { - return null - } + val detail = "type=0x${type.toString(16).padStart(2, '0')}($label) " + + "aux=0x${aux.toString(16).padStart(2, '0')} speed=0x${speed.toString(16).padStart(2, '0')} tick=$tick" + return event(eventType, label, detail).also { + it.event.ringTick = tick + it.event.ringType = type + it.event.ringAux = aux + it.event.ringSpeed = speed } } @@ -96,29 +89,17 @@ class FaceclawRingEventDecoder { return DirectRingEvent(event, label, detail) } - private fun chargerCodeName(code: Int): String { - when (code) { - 0x00 -> { - return "LONG_PRESS" - } - 0x01 -> { - return "TAP" - } - 0x02 -> { - return "DOUBLE_TAP" - } - 0x04 -> { - return "SWIPE_UP" - } - 0x05 -> { - return "SWIPE_DOWN" - } - 0x08 -> { - return "LONG_PRESS_RELEASE" - } - else -> { - return "unknown" - } + private fun ringReportTypeName(type: Int): String { + return when (type) { + 0x00 -> "LONG_PRESS" + 0x01 -> "TAP" + 0x02 -> "DOUBLE_TAP" + 0x04 -> "SWIPE_UP" + 0x05 -> "SWIPE_DOWN" + 0x08 -> "LONG_PRESS_RELEASE" + 0x09 -> "TAP_THEN_HOLD" + 0x0a -> "TOUCH_DOWN" + else -> "UNKNOWN" } } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/RingProtocol.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/RingProtocol.kt index 89354ff0..3d692261 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/RingProtocol.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/RingProtocol.kt @@ -73,6 +73,21 @@ class RingProtocol private constructor() { const val CMD_HI_DEVICE: Int = 0x00 const val CMD_LO_PAGE_ACK: Int = 0x7E + /** + * System-channel (00:xx) commands that configure the ring's binding. + * Subcommand numbers and handler behavior are from openCFW's R1 + * decompilation (r1/src/r1_dispatch.c, r1/docs/correlation/ + * CONNECTION-CONTROL-CORRELATION.md); g2-kit-unofficial's ring.ts names + * the same table. Only pairAuth and advStart have been seen in a capture + * of Even's app. + */ + const val CMD_LO_TOUCH_SWITCH: Int = 0x07 + const val CMD_LO_PAIR_AUTH: Int = 0x08 + const val CMD_LO_ADV_START: Int = 0x0A + const val CMD_LO_REMOVE_RING_NOTIFY: Int = 0x82 + /** touchSwitch selector for the glasses touch source; selector 1 (phone) is diagnostic-only. */ + const val TOUCH_SWITCH_SELECTOR_GLASSES: Int = 2 + /** * The five health pulls, in the order Even's own app issues them: * heart rate, HRV, SpO2, sleep, steps. That order is identical in all four @@ -202,6 +217,100 @@ class RingProtocol private constructor() { return buildFrame(CHAN_DEVICE, KIND_ACK, CMD_HI_DEVICE, CMD_LO_PAGE_ACK, seq, payload) } + /** + * The ring's phone-direction model checksum: the two bytes that sit + * where [buildFrame]'s callers put a "nonce". It is a CRC-16 (Nordic + * crc16_compute, init 0xFFFF) over header bytes 5-8 and 10-14 (skipping + * the high byte of the 16-bit serial) and then the arguments. Verified + * against five captured Even-app frames; see GlassesRingLinkTest. + * + * Most of our frames still carry a counter there instead and the ring + * answers them anyway, so the ring does not seem to enforce it; the + * binding commands below compute it so they do not depend on that. + */ + @JvmStatic + fun phoneChecksum(chan: Int, seq: Int, kind: Int, cmdHi: Int, cmdLo: Int, args: ByteArray): Int { + val plen = HEADER_LEN + 2 + args.size - 5 + val header = byteArrayOf( + MAGIC.toByte(), chan.toByte(), MAGIC.toByte(), seq.toByte(), + kind.toByte(), cmdHi.toByte(), cmdLo.toByte(), plen.toByte(), (plen ushr 8).toByte(), + ) + var crc = 0xffff + for (b in header + args) { + crc = ((crc ushr 8) or (crc shl 8)) and 0xffff + crc = crc xor (b.toInt() and 0xff) + crc = crc xor ((crc and 0xff) ushr 4) + crc = crc xor ((crc shl 12) and 0xffff) + crc = crc xor (((crc and 0xff) shl 5) and 0xffff) + } + return crc + } + + /** A frame whose two leading payload bytes are the [phoneChecksum] of `args`. */ + @JvmStatic + fun buildCheckedFrame(chan: Int, kind: Int, cmdHi: Int, cmdLo: Int, seq: Int, args: ByteArray): ByteArray { + val crc = phoneChecksum(chan, seq, kind, cmdHi, cmdLo, args) + return buildFrame(chan, kind, cmdHi, cmdLo, seq, nonceBytes(crc) + args) + } + + /** + * pairAuth (00:08) with role byte 1: claims the ring's phone role, after + * which the ring asks for link security (bonding) and starts answering + * requests. For seq 1 this is byte-identical to Even's captured frame. + */ + @JvmStatic + fun buildPairAuth(seq: Int): ByteArray = + buildCheckedFrame(CHAN_DEVICE, KIND_REQ, CMD_HI_DEVICE, CMD_LO_PAIR_AUTH, seq, byteArrayOf(0x01)) + + /** + * advStart (00:0A): the two glasses addresses the ring will accept as + * its glasses peer, each in wire order (least-significant byte first). + * The ring persists them, disconnects a connected glasses peer that + * matches neither (after ~20 s), and treats a slot of all 00 or all FF + * as unset; with both unset it accepts any glasses peer. Sent with the + * REQ status byte because that is what Even's captured frames use. + */ + @JvmStatic + fun buildAdvStart(seq: Int, first: ByteArray, second: ByteArray): ByteArray { + require(first.size == 6 && second.size == 6) { "advStart targets must be 6 bytes each" } + return buildCheckedFrame(CHAN_DEVICE, KIND_REQ, CMD_HI_DEVICE, CMD_LO_ADV_START, seq, first + second) + } + + /** + * touchSwitch (00:07) SET: [selector, value]. Selector 2 opens (value 1) + * or closes (value 0) the glasses touch source; the phone selector does + * nothing in the decompiled handler. + */ + @JvmStatic + fun buildTouchSwitch(seq: Int, selector: Int, on: Boolean): ByteArray = + buildCheckedFrame(CHAN_DEVICE, KIND_DATA, CMD_HI_DEVICE, CMD_LO_TOUCH_SWITCH, seq, + byteArrayOf(selector.toByte(), if (on) 1 else 0)) + + /** + * removeRingNotify (00:82) SET, one byte: the ring clears its + * glasses-connected flag and erases both advStart targets. The retail + * handler acts on any nonempty payload; 1 is our choice. + */ + @JvmStatic + fun buildRemoveRingNotify(seq: Int): ByteArray = + buildCheckedFrame(CHAN_DEVICE, KIND_DATA, CMD_HI_DEVICE, CMD_LO_REMOVE_RING_NOTIFY, seq, byteArrayOf(0x01)) + + /** + * The outcome a ring response's status byte carries: `0x03 | code << 2` + * with code 0 ok, 1 error, 2 refused, 3 unsupported. Null when `kind` is + * not a response. + */ + @JvmStatic + fun responseResult(kind: Int): String? { + if ((kind and 0x03) != KIND_RSP) return null + return when ((kind ushr 2) and 0x03) { + 0 -> "ok" + 1 -> "error" + 2 -> "refused" + else -> "unsupported" + } + } + private fun nonceBytes(nonce: Int): ByteArray { return byteArrayOf((nonce and 0xff).toByte(), ((nonce ushr 8) and 0xff).toByte()) } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt index e5586a06..a86d0c44 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionCore.kt @@ -353,6 +353,20 @@ class GlassesSessionCore( internal var lastRingLinkCommandAtMs = 0L internal var lastRingLinkResultR = "" internal var lastRingLinkResultL = "" + // Which of the ring's two roles the direct link claims; see setDirectRingRole. + internal var directRingRole = DIRECT_RING_ROLE_BOTH + internal var ringRoleReconnectPending = false + // Ring-side binding commands (system channel) waiting for the ring worker, + // the one written and not yet answered, and the last one's outcome. + internal val ringConfigQueue = ArrayDeque() + internal var ringConfigAwaiting: RingConfigCommand? = null + internal var lastRingConfigCommand = "" + internal var lastRingConfigCommandAtMs = 0L + internal var lastRingConfigResult = "" + // Last direct-link notification nothing decoded (e.g. legacy-channel + // frames while claiming the glasses role). + internal var lastDirectRingRaw = "" + internal var lastDirectRingRawAtMs = 0L // Silent mode: 1 = on, 0 = off, -1 = not yet known. See updateSilentModeLocked. internal var silentMode = -1 internal var wearState = -1 @@ -995,14 +1009,90 @@ class GlassesSessionCore( status["lastCommandAgeMs"] = age(lastRingLinkCommandAtMs) status["lastCommandResultR"] = lastRingLinkResultR status["lastCommandResultL"] = lastRingLinkResultL + status["directRole"] = directRingRole + status["lastRingCommand"] = lastRingConfigCommand + status["lastRingCommandAgeMs"] = age(lastRingConfigCommandAtMs) + status["lastRingCommandResult"] = lastRingConfigResult + status["lastDirectRaw"] = lastDirectRingRaw + status["lastDirectRawAgeMs"] = age(lastDirectRingRawAtMs) return try { Json.write(status) } catch (e: Exception) { "{}" } } } /** - * EXPERIMENTAL: ask the glasses to drop or re-establish their own link to - * the ring, so the phone can take the ring over directly and later hand - * it back. `action` is "disconnect", "release" or "connect"; see + * Which ring role the direct link claims. The R1 holds one phone role and + * one glasses role at a time and sends gestures only to the glasses role + * (openCFW R1 decompilation): + * - "phone": pairAuth on the system channel, health sync; only the data + * CCCD (what Even's app does). + * - "glasses": enable the legacy-channel CCCD, which appears to be what + * assigns a link the glasses role, and skip pairAuth and health. Only works while the + * glasses themselves do not hold that role. + * - "both": the long-standing default, both CCCDs plus pairAuth. If the + * glasses role is free this probably asks for both roles on one link; + * the decompiled stock role setter hits a fatal assertion on that. + * A change while the direct link is up reconnects it. + */ + fun setDirectRingRole(role: String?) { + val normalized = when (role) { + DIRECT_RING_ROLE_PHONE -> DIRECT_RING_ROLE_PHONE + DIRECT_RING_ROLE_GLASSES -> DIRECT_RING_ROLE_GLASSES + else -> DIRECT_RING_ROLE_BOTH + } + monitor.withLock { + if (normalized == directRingRole) return + directRingRole = normalized + if (ringConnected || ringNotificationsReady) { + ringRoleReconnectPending = true + monitor.signalAll() + } + } + logLine("direct ring role set to $normalized") + } + + /** + * EXPERIMENTAL: ring-side binding commands over the direct link, plus the + * two combined flows. Returns a one-line outcome for the UI. Actions: + * "pair-auth", "targets-glasses", "targets-clear", "touch-on", + * "touch-off", "remove-ring" (see [queueRingConfigCommandLocked]); + * "bind" = advStart(our glasses), then after the ring answers the glasses + * RING_CONNECT_INFO connect=1 (the official app's order); "unbind" = the + * glasses' UNPAIR_INFO, then removeRingNotify to the ring. + * `fallbackAddress`/`fallbackName` are the ring's, for the glasses side. + */ + fun sendRingConfigCommand(action: String, fallbackAddress: String?, fallbackName: String?): String { + val outcome = monitor.withLock { + if (!running || !sessionReady) return "not sent: no glasses session" + val directReady = ringNotificationsReady + when (action) { + "bind" -> { + if (!directReady) return "not sent: direct ring link not ready" + queueRingConfigCommandLocked("targets-glasses", "connect", fallbackAddress ?: "", fallbackName ?: "") + } + "unbind" -> { + val glasses = queueGlassesRingLinkCommandLocked("unpair", fallbackAddress ?: "", fallbackName ?: "") + val ring = directReady && queueRingConfigCommandLocked("remove-ring", null, "", "") == null + when { + glasses && ring -> null + glasses -> "glasses unpair sent; ring part skipped (direct link not ready)" + ring -> "ring part sent; glasses unpair skipped (no ring address)" + else -> "not sent: no ring address and no direct link" + } + } + else -> { + if (!directReady) return "not sent: direct ring link not ready" + queueRingConfigCommandLocked(action, null, "", "") + } + } + } + interruptibleSleep.interrupt() + return outcome ?: "sent" + } + + /** + * EXPERIMENTAL: ask the glasses to drop, forget or re-establish their own + * link to the ring, so the phone can take the ring over directly and later + * hand it back. `action` is "disconnect", "release", "unpair" or "connect"; see * [queueGlassesRingLinkCommandLocked]. `fallbackAddress` ("AA:BB:..") and * `fallbackName` are used only when the glasses have not reported their * ring target this session. False when no session is up. @@ -1922,6 +2012,10 @@ class GlassesSessionCore( } val decoded = FaceclawRingEventDecoder.decode(data) if (decoded == null) { + monitor.withLock { + lastDirectRingRaw = characteristicUuid.take(8) + " " + hex(data.copyOf(minOf(data.size, 24))) + lastDirectRingRawAtMs = now() + } logDebug("direct ring notify ignored: characteristicUuid=" + characteristicUuid + " raw=" + hex(data)) return } @@ -1979,6 +2073,7 @@ class GlassesSessionCore( // link; the sequence counter restarts on the next connect. ringReassembler.reset() ringOutbound.clear() + dropRingConfigCommandsLocked("direct link dropped") directRingBattery = -1 directRingCharging = -1 emitBatteryState(headsetBattery, headsetCharging) @@ -2259,7 +2354,16 @@ class GlassesSessionCore( // channel is plausibly what carries ring-as-remote gesture events, // which are a daily-driver feature; matching Even byte-for-byte here // buys nothing and risks breaking them. - val phoneNotify = enableRingNotification(BleProtocol.R1_PHONE_NOTIFY_CHAR_UUID) + // + // Per openCFW's R1 decompilation, the "phone-notify" characteristic + // (bae80011) is really the legacy channel the glasses use. Enabling its + // CCCD appears to be what assigns a link the ring's glasses role (BAE8 + // service events 6/7), and the ring sends gestures (00 09 61 00 ...) + // only to that role. The direct ring + // role setting decides which CCCDs we enable; see setDirectRingRole. + val role = monitor.withLock { directRingRole } + val phoneNotify = role != DIRECT_RING_ROLE_PHONE + && enableRingNotification(BleProtocol.R1_PHONE_NOTIFY_CHAR_UUID) val dataNotify = enableRingNotification(BleProtocol.R1_NOTIFY_CHAR_UUID) if (!phoneNotify && !dataNotify) { throw IllegalStateException("no R1 notify characteristic subscribed") @@ -2278,9 +2382,11 @@ class GlassesSessionCore( ringWriteFailures = 0 ringConnectFailures = 0 } - logLine("direct ring ready phoneNotify=$phoneNotify dataNotify=$dataNotify") + logLine("direct ring ready role=$role phoneNotify=$phoneNotify dataNotify=$dataNotify") - if (dataNotify && host.supportsRingHealth()) { + // Claiming the glasses role means no pairAuth (it would ask for the + // phone role on the same link) and therefore no health sync. + if (dataNotify && host.supportsRingHealth() && role != DIRECT_RING_ROLE_GLASSES) { onRingDataChannelReady() } } diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt index f4a3879f..6e147ba5 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionRing.kt @@ -93,20 +93,23 @@ private const val RING_WRITE_BACKOFF_MAX_MS = 15_000L /** * Device-channel commands Even's real app fires in the gaps between - * health requests - identity (0x0a), battery (0x01), firmware version - * (0x02), device id (0x0b) - found by extracting the literal wire order - * of a real successful sync (same capture as ringHealthRspTimeoutMs; two + * health requests - battery (0x01), firmware version (0x02), device id + * (0x0b) - found by extracting the literal wire order of a real + * successful sync (same capture as ringHealthRspTimeoutMs; two * independent syncs in it agree). Rotated one-per-health-type here rather * than replicated exactly (Even's real cadence isn't perfectly regular * either - compare the two syncs in the capture), since which of these, * if any, is actually load-bearing for the ring answering has never * been isolated. This is matching cadence, not a confirmed protocol * requirement. + * + * Even's sync also sends 0x0a, which used to be replayed here with the + * capture's "opaque blob". 0x0a is advStart: the blob was the capturing + * phone's two glasses MACs, which the ring persists as the only glasses it + * accepts. It is now sent only on request (queueRingConfigCommandLocked), + * with our own glasses' addresses. */ -private val RING_DEVICE_PING_CMD_LO = intArrayOf(0x0a, 0x01, 0x02, 0x0b) - -/** The opaque blob Even sends with every device-channel 0x0a request (f8f53d235ac4ceaa073885cc). */ -private val RING_IDENTITY_BLOB: ByteArray = "f8f53d235ac4ceaa073885cc".chunked(2).map { it.toInt(16).toByte() }.toByteArray() +private val RING_DEVICE_PING_CMD_LO = intArrayOf(0x01, 0x02, 0x0b) /** * A snapshot of the health buffer together with the watermark identifying @@ -127,8 +130,10 @@ class RingHealthBatch internal constructor( internal fun GlassesSessionCore.runRingWorker() { while (running) { try { + restartRingLinkForRoleChange() if (shouldAttemptRingConnect()) tryConnectRing("ring worker") if (!running) break + flushRingConfigCommands() flushRingOutbound() runRequestedRingHealthPull() resumeAbortedRingHealthPull() @@ -221,6 +226,7 @@ internal fun GlassesSessionCore.handleRingHealthNotification(characteristicUuid: } logLine("direct ring battery " + status.battery + "% charging=" + status.charging) } + recordRingConfigResponse(frame) logDebug("ring device frame " + frame.describe()) return true } @@ -386,7 +392,7 @@ internal fun GlassesSessionCore.resumeAbortedRingHealthPull() { if (ringHealthAbortedRetries == 0) { return } - if (!ringConnected || !ringNotificationsReady) { + if (!ringConnected || !ringNotificationsReady || directRingRole == DIRECT_RING_ROLE_GLASSES) { return } if (now - ringHealthLastRequestedAtMs < RING_HEALTH_ABORTED_RETRY_GAP_MS) { @@ -410,6 +416,10 @@ internal fun GlassesSessionCore.runRequestedRingHealthPull() { logLine("ring health: on-demand pull skipped, ring not ready") return } + if (directRingRole == DIRECT_RING_ROLE_GLASSES) { + logLine("ring health: on-demand pull skipped, direct link holds the glasses role") + return + } if (ringHealthLastRequestedAtMs != 0L && now - ringHealthLastRequestedAtMs < RING_HEALTH_ON_DEMAND_MIN_INTERVAL_MS) { logLine("ring health: on-demand pull skipped, last one was " @@ -446,37 +456,29 @@ internal fun GlassesSessionCore.sendRingHandshake() { + " (tz " + localTimeZoneId() + ")") val clock = le32(liveClockSeconds) - val seqs = IntArray(7) - val nonces = IntArray(7) + val seqs = IntArray(6) + val nonces = IntArray(6) monitor.withLock { - for (i in 0 until 7) { + for (i in 0 until 6) { seqs[i] = nextRingSeqLocked() nonces[i] = nextRingNonceLocked() } } val frames = arrayOf( - RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_REQ, 0x00, 0x08, seqs[0], - // NO nonce prefix on this one frame - payload is exactly the - // three bytes 3f 01 01. Every other request on both channels - // starts with the 2-byte nonce; 00:08 does not, and the ring - // silently drops the whole frame if you add one, then ignores - // everything that follows on the connection. - // - // Measured 2026-09-11 across all four btsnoop captures, 46 - // real 00:08 writes, zero exceptions: - // payload 3f0101 (3 bytes) -> 3 writes, ALL answered (12-21 notifications each) - // payload 01003f0101 (5 bytes) -> 43 writes, ALL silent (zero notifications) - // The 5-byte form is the more common one in the captures only - // because it is ours, failing and retrying all night. Do not - // "fix" this back to the nonce form by pattern-matching the - // other frames or by counting which variant appears more. - // - // This also explains 2026-09-10: the handshake worked when it - // was raw bytes replayed from the capture, and stopped working - // the moment it was rebuilt "properly" through buildFrame(), - // which is what introduced the nonce prefix. - byteArrayOf(0x3f, 0x01, 0x01)), + // pairAuth. Its bytes after the header must be exactly 3f 01 01: + // measured 2026-09-11 across all four btsnoop captures, 46 real + // 00:08 writes, zero exceptions: + // 3f0101 (3 bytes) -> 3 writes, ALL answered (12-21 notifications each) + // 01003f0101 (5 bytes) -> 43 writes, ALL silent (zero notifications) + // The 5-byte form was ours, failing and retrying all night. The + // first two bytes are not a nonce: they are the frame's phone + // checksum (3f01 is its value at seq 1), and the role byte 01 must + // follow it directly. A nonce in front shifted the role byte, so the + // ring never assigned us the phone role and ignored everything after. + // buildPairAuth computes the checksum; at seq 1 it is the captured + // frame byte for byte (see GlassesRingLinkTest). + RingProtocol.buildPairAuth(seqs[0]), RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_DATA, 0x00, 0x0e, seqs[1], le16(nonces[1]) + clock + byteArrayOf(0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)), RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_DATA, 0x00, 0x05, seqs[2], @@ -489,8 +491,8 @@ internal fun GlassesSessionCore.sendRingHandshake() { le16(nonces[4])), RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_REQ, 0x00, 0x0b, seqs[5], le16(nonces[5])), - RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_REQ, 0x00, 0x0a, seqs[6], - le16(nonces[6]) + RING_IDENTITY_BLOB), + // Even's handshake ends with advStart (00:0A) naming its glasses; it is + // not replayed here (see RING_DEVICE_PING_CMD_LO). ) for (frame in frames) { if (!writeRingFrame(frame, "handshake")) { @@ -679,18 +681,7 @@ internal fun GlassesSessionCore.awaitRingHealthDataIdle(idleMs: Long): Boolean { */ internal fun GlassesSessionCore.sendRingDevicePing(cmdLo: Int) { val frame = monitor.withLock { - val seq = nextRingSeqLocked() - val nonce = nextRingNonceLocked() - if (cmdLo == 0x0a) { - // The only one of these four that isn't a bare nonce - it - // carries the same opaque constant blob as the handshake's - // own 0x0a frame (confirmed byte-identical across two - // different nights, see sendRingHandshake()'s comments). - RingProtocol.buildFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_REQ, 0x00, 0x0a, seq, - le16(nonce) + RING_IDENTITY_BLOB) - } else { - RingProtocol.buildRequest(RingProtocol.CHAN_DEVICE, 0x00, cmdLo, seq, nonce) - } + RingProtocol.buildRequest(RingProtocol.CHAN_DEVICE, 0x00, cmdLo, nextRingSeqLocked(), nextRingNonceLocked()) } writeRingFrame(frame, "device ping 0x" + cmdLo.toString(16)) } @@ -777,19 +768,21 @@ internal fun GlassesSessionCore.nextRingNonceLocked(): Int { // The glasses' own link to the ring (sid 0x80 pair-manager commands) // // While the glasses hold the ring, it reports gestures only to them, so a -// direct phone link sees nothing. These ask the glasses to let go of it and -// to take it back. Shapes and handler behavior come from g2-kit-unofficial's -// protos and openCFW's decompilation of pb_service_pair_mgr.c; none of it has -// been captured from the Even app or verified on hardware. Deliberately no -// UNPAIR_INFO: that wipes the glasses' stored ring pairing. +// direct phone link sees nothing. These ask the glasses to let go of it, to +// forget it, and to take it back. Shapes and handler behavior come from +// g2-kit-unofficial's protos and openCFW's decompilation of +// pb_service_pair_mgr.c; the connect form also matches the official app's +// decompiled builder. None of it has been verified on hardware. UNPAIR_INFO +// wipes the glasses' stored ring pairing; the Even app can re-pair. /** - * Parse "AA:BB:CC:DD:EE:FF" into wire order, least-significant byte first. - * Inferred, not verified: the one captured glasses-sent ring MAC - * (even-g2-protocol's "Device Identity", b1:6a:9f:2f:43:dc on sid 0x91) is - * only a valid random static address (top two bits set) read backwards. + * Parse "AA:BB:CC:DD:EE:FF" into wire order, least-significant byte first, + * for both ring and glasses addresses. The official app's + * StringExt.macToBytes reverses the same way for RING_CONNECT_INFO, and the + * R1 (a Nordic part) compares advStart targets against its little-endian + * peer addresses. */ -internal fun ringMacWireBytes(address: String): ByteArray? { +internal fun macWireBytes(address: String): ByteArray? { val parts = address.trim().split(':') if (parts.size != 6) return null val bytes = ByteArray(6) @@ -809,6 +802,8 @@ internal fun ringMacWireBytes(address: String): ByteArray? { * - "release": RING_CONNECT_INFO connect=0. Also cancels pending connect * timeouts and clears the connect mode, so it may hold off auto-reconnect. * - "connect": RING_CONNECT_INFO connect=1 with the ring's MAC and name. + * - "unpair": UNPAIR_INFO dev=RING. The glasses forget the ring, so they + * stop reconnecting to it until something sends "connect" again. * Both RING_CONNECT_INFO forms overwrite the stored target, so they echo the * target the glasses reported when there is one. */ @@ -816,7 +811,7 @@ internal fun GlassesSessionCore.queueGlassesRingLinkCommandLocked( action: String, fallbackAddress: String, fallbackName: String, ): Boolean { val reported = glassesRingMac - val mac = reported ?: ringMacWireBytes(fallbackAddress) + val mac = reported ?: macWireBytes(fallbackAddress) if (mac == null) { logLine("glasses ring $action skipped: no ring address") return false @@ -832,6 +827,7 @@ internal fun GlassesSessionCore.queueGlassesRingLinkCommandLocked( val message = messageBuilder.ringLinkCommand("glasses ring $action", leftArm) { magic -> when (action) { "disconnect" -> BleProtocol.buildRingDisconnectRequest(magic, mac) + "unpair" -> BleProtocol.buildRingUnpairRequest(magic, mac) "release" -> BleProtocol.buildRingConnectRequest(magic, false, mac, name) else -> BleProtocol.buildRingConnectRequest(magic, true, mac, name) } @@ -875,3 +871,175 @@ internal fun GlassesSessionCore.recordGlassesRingReportLocked(frame: BleProtocol } logLine("glasses ring report: $lastGlassesRingReport") } + +// --------------------------------------------------------------------------- +// The ring's own binding state (system-channel commands over the direct link) +// +// The R1 keeps one phone role and one glasses role, and a pair of glasses +// addresses (advStart targets) it will accept in the glasses role; gestures go +// only to the glasses role. Behavior is from openCFW's R1 decompilation +// (r1/docs/correlation/CONNECTION-CONTROL-CORRELATION.md and +// ADV-START-TOUCH-SWITCH-HANDLERS-CORRELATION.md); the official app's order +// (advStart, then RING_CONNECT_INFO to the glasses) is from its decompiled +// EvConnect.startRingAdvForCurrentGlasses. Not verified on hardware. + +internal const val DIRECT_RING_ROLE_BOTH = "both" +internal const val DIRECT_RING_ROLE_PHONE = "phone" +internal const val DIRECT_RING_ROLE_GLASSES = "glasses" + +/** How long a command with a follow-up waits for the ring's answer before running it anyway. */ +private const val RING_CONFIG_RESPONSE_TIMEOUT_MS = 3_000L + +/** Six 0xFF bytes: an unset advStart target, the value removeRingNotify writes. */ +private val RING_TARGET_UNSET = ByteArray(6) { 0xff.toByte() } + +/** + * One queued ring command. `followUp` is a glasses ring-link action (see + * [queueGlassesRingLinkCommandLocked]) to queue once the ring has answered. + */ +internal class RingConfigCommand( + val label: String, + val frame: ByteArray, + val cmdLo: Int, + val followUp: String?, + val followUpAddress: String, + val followUpName: String, +) + +/** + * Queue one ring-side command for the ring worker. Actions: + * - "pair-auth": pairAuth, claiming the phone role (the handshake already does). + * - "targets-glasses": advStart with this session's right and left arms. + * - "targets-clear": advStart with both targets unset (any glasses accepted). + * - "touch-on" / "touch-off": touchSwitch on the glasses touch source. + * - "remove-ring": removeRingNotify (clears both targets and the + * glasses-connected flag). + * Returns null when queued, else why not. + */ +internal fun GlassesSessionCore.queueRingConfigCommandLocked( + action: String, followUp: String?, followUpAddress: String, followUpName: String, +): String? { + val seq = nextRingSeqLocked() + val label: String + val frame: ByteArray + when (action) { + "pair-auth" -> { + label = "pairAuth" + frame = RingProtocol.buildPairAuth(seq) + } + "targets-glasses" -> { + val right = macWireBytes(rightAddress) + val left = macWireBytes(leftAddress) + if (right == null || left == null) return "not sent: glasses addresses unparseable" + label = "advStart R=$rightAddress L=$leftAddress" + frame = RingProtocol.buildAdvStart(seq, right, left) + } + "targets-clear" -> { + label = "advStart cleared" + frame = RingProtocol.buildAdvStart(seq, RING_TARGET_UNSET, RING_TARGET_UNSET) + } + "touch-on", "touch-off" -> { + label = "touchSwitch glasses " + (if (action == "touch-on") "on" else "off") + frame = RingProtocol.buildTouchSwitch(seq, RingProtocol.TOUCH_SWITCH_SELECTOR_GLASSES, action == "touch-on") + } + "remove-ring" -> { + label = "removeRingNotify" + frame = RingProtocol.buildRemoveRingNotify(seq) + } + else -> return "not sent: unknown ring action $action" + } + val cmdLo = frame[12].toInt() and 0xff + ringConfigQueue.addLast(RingConfigCommand(label, frame, cmdLo, followUp, followUpAddress, followUpName)) + lastRingConfigCommand = label + (if (followUp != null) " then glasses $followUp" else "") + lastRingConfigCommandAtMs = now() + lastRingConfigResult = "queued" + logLine("queue ring command $label seq=$seq" + (if (followUp != null) " then glasses $followUp" else "")) + monitor.signalAll() + return null +} + +/** The direct link went away: queued commands (and their follow-ups) are not sent. */ +internal fun GlassesSessionCore.dropRingConfigCommandsLocked(reason: String) { + lastRingConfigResult = when { + ringConfigQueue.isNotEmpty() -> "dropped: $reason" + ringConfigAwaiting != null -> "no answer: $reason" + else -> return + } + ringConfigQueue.clear() + ringConfigAwaiting = null + monitor.signalAll() +} + +/** + * Write queued ring commands. Ring worker only. A command with a follow-up + * waits for the ring's answer (or a timeout), then queues the glasses half. + * A failed write leaves the command queued for the next tick. + */ +internal fun GlassesSessionCore.flushRingConfigCommands() { + while (true) { + val command = monitor.withLock { + if (!ringNotificationsReady) return + ringConfigQueue.firstOrNull() ?: return + } + if (!writeRingFrame(command.frame, command.label)) return + monitor.withLock { + val index = ringConfigQueue.indexOfFirst { it === command } + if (index >= 0) ringConfigQueue.removeAt(index) + ringConfigAwaiting = command + lastRingConfigResult = "sent, awaiting ring" + } + logLine("ring command ${command.label} written: " + GlassesSessionCore.hex(command.frame)) + val followUp = command.followUp ?: continue + val answered = awaitRingConfigResponse(command) + val queued = monitor.withLock { + if (!running || !sessionReady) false + else queueGlassesRingLinkCommandLocked(followUp, command.followUpAddress, command.followUpName) + } + logLine("ring command ${command.label}: " + (if (answered) "answered" else "no answer") + + "; glasses $followUp " + (if (queued) "queued" else "not sent")) + interruptibleSleep.interrupt() + } +} + +private fun GlassesSessionCore.awaitRingConfigResponse(command: RingConfigCommand): Boolean { + val deadline = now() + RING_CONFIG_RESPONSE_TIMEOUT_MS + monitor.withLock { + while (running && ringConfigAwaiting === command) { + val remaining = deadline - now() + if (remaining <= 0) break + monitor.awaitMs(remaining) + } + return ringConfigAwaiting !== command + } +} + +/** Match a system-channel response to the command awaiting one. GATT callback thread. */ +internal fun GlassesSessionCore.recordRingConfigResponse(frame: RingProtocol.Frame) { + if (frame.cmdHi != RingProtocol.CMD_HI_DEVICE) return + val result = RingProtocol.responseResult(frame.kind) ?: return + val label = monitor.withLock { + val awaiting = ringConfigAwaiting + if (awaiting == null || awaiting.cmdLo != frame.cmdLo) return + ringConfigAwaiting = null + lastRingConfigResult = result + " (status " + RingProtocol.hex2(frame.kind) + ")" + monitor.signalAll() + awaiting.label + } + logLine("ring command $label answered: $result " + frame.describe()) +} + +/** Apply a [GlassesSessionCore.setDirectRingRole] change by reconnecting the direct link. Ring worker only. */ +internal fun GlassesSessionCore.restartRingLinkForRoleChange() { + val role = monitor.withLock { + if (!ringRoleReconnectPending) return + ringRoleReconnectPending = false + ringConnected = false + ringNotificationsReady = false + ringReconnectAfterMs = 0 + ringOutbound.clear() + dropRingConfigCommandsLocked("role change") + directRingRole + } + logLine("direct ring: reconnecting to take the $role role") + link.disconnect(ringAddress) +} diff --git a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt index e18b9844..9734d040 100644 --- a/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt +++ b/native/kotlin/shared/src/iosMain/kotlin/com/faceclaw/app/ble/IosGlassesSession.kt @@ -166,6 +166,9 @@ class IosGlassesSession internal constructor( fun getRingStatus(): String = core.getRingStatus() fun setGlassesRingLink(action: String, fallbackAddress: String?, fallbackName: String?): Boolean = core.setGlassesRingLink(action, fallbackAddress, fallbackName) + fun sendRingConfigCommand(action: String, fallbackAddress: String?, fallbackName: String?): String = + core.sendRingConfigCommand(action, fallbackAddress, fallbackName) + fun setDirectRingRole(role: String?) = core.setDirectRingRole(role) fun addImuListener(listener: FaceclawImuListener?) = core.addImuListener(listener) diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesRingLinkTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesRingLinkTest.kt index 313b06af..bb24ea5e 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesRingLinkTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/GlassesRingLinkTest.kt @@ -7,11 +7,11 @@ class GlassesRingLinkTest { private fun toHex(bytes: ByteArray) = bytes.joinToString("") { (it.toInt() and 0xff).toString(16).padStart(2, '0') } private val mac = hex("b16a9f2f43dc") - @Test fun ringMacWireBytesAreLeastSignificantFirst() { - assertEquals("b16a9f2f43dc", toHex(assertNotNull(ringMacWireBytes("DC:43:2F:9F:6A:B1")))) - assertNull(ringMacWireBytes("")) - assertNull(ringMacWireBytes("DC:43:2F:9F:6A")) - assertNull(ringMacWireBytes("DC:43:2F:9F:6A:ZZ")) + @Test fun macWireBytesAreLeastSignificantFirst() { + assertEquals("b16a9f2f43dc", toHex(assertNotNull(macWireBytes("DC:43:2F:9F:6A:B1")))) + assertNull(macWireBytes("")) + assertNull(macWireBytes("DC:43:2F:9F:6A")) + assertNull(macWireBytes("DC:43:2F:9F:6A:ZZ")) } @Test fun disconnectRequestWireShape() { @@ -44,4 +44,64 @@ class GlassesRingLinkTest { assertNull(BleProtocol.parseRingConnectInfo(BleProtocol.buildAuthenticationRequest(3))) } + + @Test fun unpairRequestWireShape() { + // commandId=9 magic=0x21 unpairInfo(8){dev=RING(0), ringMac} + assertEquals("0809" + "1021" + "420a" + "0800" + "1206b16a9f2f43dc", toHex(BleProtocol.buildRingUnpairRequest(0x21, mac))) + } + + @Test fun ringChecksumMatchesCapturedEvenFrames() { + // Frames from HCI snoops of Even's app (g2-kit-unofficial examples/ring-direct.ts). + assertEquals("00971953f964016401000000080d003f0101", toHex(RingProtocol.buildPairAuth(1))) + assertEquals("00f979f7b164016404000000020c001b64", + toHex(RingProtocol.buildCheckedFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_REQ, 0x00, 0x02, 4, ByteArray(0)))) + assertEquals("002d946c0164026405000001010c002ac6", + toHex(RingProtocol.buildCheckedFrame(RingProtocol.CHAN_HEALTH, RingProtocol.KIND_REQ, 0x01, 0x01, 5, ByteArray(0)))) + assertEquals("00d4c9ba7064016403000200051200807710ff3348bb69", + toHex(RingProtocol.buildCheckedFrame(RingProtocol.CHAN_DEVICE, RingProtocol.KIND_DATA, 0x00, 0x05, 3, hex("10ff3348bb69")))) + } + + @Test fun advStartCarriesBothTargetsLeastSignificantFirst() { + val right = assertNotNull(macWireBytes("EC:D7:82:69:3C:CB")) + val left = assertNotNull(macWireBytes("C4:5A:23:3D:F5:F8")) + val frame = RingProtocol.buildAdvStart(9, right, left) + assertValidRingFrame(frame) + assertEquals("00" + "000a", toHex(frame.copyOfRange(10, 13))) + assertEquals("cb3c6982d7ec" + "f8f53d235ac4", toHex(frame.copyOfRange(17, frame.size))) + assertEquals("ffffffffffff".repeat(2), + toHex(RingProtocol.buildAdvStart(9, ByteArray(6) { 0xff.toByte() }, ByteArray(6) { 0xff.toByte() }).copyOfRange(17, 29))) + } + + @Test fun touchSwitchAndRemoveRingAreSets() { + val on = RingProtocol.buildTouchSwitch(2, RingProtocol.TOUCH_SWITCH_SELECTOR_GLASSES, true) + assertValidRingFrame(on) + assertEquals("02" + "0007", toHex(on.copyOfRange(10, 13))) + assertEquals("0201", toHex(on.copyOfRange(17, on.size))) + assertEquals("0200", toHex(RingProtocol.buildTouchSwitch(2, 2, false).copyOfRange(17, 19))) + + val remove = RingProtocol.buildRemoveRingNotify(3) + assertValidRingFrame(remove) + assertEquals("02" + "0082" + "01", toHex(remove.copyOfRange(10, 13)) + toHex(remove.copyOfRange(17, remove.size))) + } + + @Test fun ringResponseStatusDecodes() { + assertEquals("ok", RingProtocol.responseResult(0x03)) + assertEquals("error", RingProtocol.responseResult(0x07)) + assertEquals("refused", RingProtocol.responseResult(0x0b)) + assertEquals("unsupported", RingProtocol.responseResult(0x0f)) + assertNull(RingProtocol.responseResult(0x00)) + assertNull(RingProtocol.responseResult(0x02)) + } + + /** Outer CRC-32C and inner phone checksum both match the bytes. */ + private fun assertValidRingFrame(frame: ByteArray) { + val crc32 = (frame[1].toInt() and 0xff) or ((frame[2].toInt() and 0xff) shl 8) or + ((frame[3].toInt() and 0xff) shl 16) or ((frame[4].toInt() and 0xff) shl 24) + assertEquals(RingProtocol.crc32(frame, 5, frame.size), crc32) + val args = frame.copyOfRange(17, frame.size) + val checksum = RingProtocol.phoneChecksum(frame[6].toInt(), frame[8].toInt() and 0xff, + frame[10].toInt(), frame[11].toInt(), frame[12].toInt() and 0xff, args) + assertEquals(checksum, (frame[15].toInt() and 0xff) or ((frame[16].toInt() and 0xff) shl 8)) + assertEquals(frame.size - 5, (frame[13].toInt() and 0xff) or ((frame[14].toInt() and 0xff) shl 8)) + } } diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RingInputTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RingInputTest.kt index 866dc018..687fd151 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RingInputTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/RingInputTest.kt @@ -22,6 +22,34 @@ class RingInputTest { assertEquals(decoded.ringTick, native.ringTick) } + @Test fun directReportsMapLikeTheGlassesRelay() { + // Frames captured on the direct link (bae80011), 2026-10-06. + val down = assertNotNull(FaceclawRingEventDecoder.decode(hex("000961000a000013cb0000"))).event + assertEquals(BleProtocol.EVENT_RING_PRESS, down.eventType) + assertEquals(BleProtocol.EVENT_SOURCE_RING, down.eventSource) + assertEquals(10, down.ringType) + assertEquals(0xcb13L, down.ringTick) + + val tapHold = assertNotNull(FaceclawRingEventDecoder.decode(hex("0009610009020055d60200"))).event + assertEquals(BleProtocol.EVENT_SHORT_THEN_LONG_PRESS, tapHold.eventType) + assertEquals(2, tapHold.ringAux) + assertEquals(0x02d655L, tapHold.ringTick) + + val swipe = assertNotNull(FaceclawRingEventDecoder.decode(hex("0009610004350009cc0000"))).event + assertEquals(BleProtocol.EVENT_SCROLL_TOP, swipe.eventType) + assertEquals(0x35, swipe.ringAux) + assertEquals(0x00, swipe.ringSpeed) + + // Same mapping as the CFW relay for every wire type (gesture_fwd.c). + val relayed = mapOf(0 to 9, 1 to 0, 2 to 3, 4 to 1, 5 to 2, 8 to 10, 9 to 11, 10 to 14, 3 to 127, 0xff to 127) + for ((wire, sysEvent) in relayed) { + val frame = hex("0009610000abcdefcdab89").also { it[4] = wire.toByte() } + val event = assertNotNull(FaceclawRingEventDecoder.decode(frame)).event + assertEquals(sysEvent, event.eventType, "wire type $wire") + assertEquals(0x89abcdefL, event.ringTick) + } + } + @Test fun legacyAndInvalidExtensionsNeverInventATimestamp() { assertEquals(-1L, assertNotNull(G2Event.decodePayload(224, hex("08026a041a02080e"))).ringTick) for (offset in listOf(9,13,14,15,16,20)) {