diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubChromeClient.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubChromeClient.kt new file mode 100644 index 00000000..0b03f8d9 --- /dev/null +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubChromeClient.kt @@ -0,0 +1,22 @@ +package com.faceclaw.app + +import android.util.Log +import android.webkit.ConsoleMessage +import android.webkit.WebChromeClient + +/** + * Surfaces a hosted EvenHub app's console in logcat (tag FaceclawEvenHubConsole). + * Native rather than a NativeScript-extended WebChromeClient: chatty apps log + * many lines a second, and each one used to cost a Java->JS callback plus three + * JS->Java calls back to read the message, all on the main thread. + */ +class FaceclawEvenHubChromeClient : WebChromeClient() { + override fun onConsoleMessage(message: ConsoleMessage): Boolean { + Log.i(TAG, "${message.message()} (${message.sourceId()}:${message.lineNumber()})") + return true + } + + private companion object { + const val TAG = "FaceclawEvenHubConsole" + } +} diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubJsBridge.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubJsBridge.kt index 90c8c1e7..d099d419 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubJsBridge.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubJsBridge.kt @@ -23,4 +23,10 @@ class FaceclawEvenHubJsBridge(private val listener: FaceclawEvenHubListener) { listener.onEvenAppMessage(handlerName, argsJson, callId) } } + + /** The page's timer shim has work due before the host's next tick. */ + @JavascriptInterface + fun wakeTimers() { + FaceclawEvenHubWebViewHost.getInstance().wakeTimers() + } } diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubWebViewHost.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubWebViewHost.kt index bee8e1da..19d5a5a0 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubWebViewHost.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawEvenHubWebViewHost.kt @@ -11,6 +11,7 @@ import android.webkit.WebView import android.widget.FrameLayout import java.util.ArrayList +import java.util.HashMap /** * Keeps EvenHub app WebViews alive and rendering while the phone shows the @@ -39,9 +40,11 @@ import java.util.ArrayList * crawl even though the renderer is still alive. Host-initiated * evaluateJavascript is NOT subject to that throttle, so we drive the app's * timers ourselves: a document-start shim replaces setTimeout/setInterval (and - * requestAnimationFrame) with JS queues fired by window.__fcTimerTick() / - * __fcRafTick(), and this host ticks those on the main thread at a fixed rate - * regardless of screen state. The main Looper keeps running under the + * requestAnimationFrame) with JS queues fired by window.__fcTick(), and this + * host ticks those on the main thread regardless of screen state. The tick + * returns when the page next has work, so an idle page isn't evaluated at + * 60Hz; work scheduled between ticks wakes the host through + * FaceclawEvenHubJsBridge.wakeTimers. The main Looper keeps running under the * foreground service, so the tick survives the screen turning off. (Matches the * official Even app's approach.) * @@ -73,23 +76,69 @@ class FaceclawEvenHubWebViewHost { private val mainHandler = Handler(Looper.getMainLooper()) private val webViews: MutableList = ArrayList() - private var ticking = false - private val ticker: Runnable = object : Runnable { + private val tickers: MutableMap = HashMap() + + /** + * Drives one page's timer/rAF queues (window.__fcTick). Each tick's result + * says when the page next has work; the ticker sleeps until then, or until + * the page wakes it. It also re-ticks after IDLE_POLL_MS regardless, so a + * lost evaluateJavascript callback (e.g. mid-navigation) or a page whose + * wake didn't reach us stalls its timers for at most that long. + */ + private inner class Ticker(private val web: WebView) : Runnable { + private var inFlight = false + private var wakePending = false + private var stopped = false + override fun run() { - for (i in 0 until webViews.size) { - webViews[i].evaluateJavascript( - "window.__fcTimerTick&&__fcTimerTick();window.__fcRafTick&&__fcRafTick()", null) + if (stopped) return + inFlight = true + web.evaluateJavascript(TICK_JS) { result -> onTicked(result) } + schedule(IDLE_POLL_MS) + } + + private fun onTicked(result: String?) { + inFlight = false + if (stopped) return + // -1 (nothing pending) and null (shim not installed yet) both leave + // only the idle poll; the page wakes us when it schedules work. + val next = result?.toDoubleOrNull()?.toLong() ?: -1L + val delay = when { + wakePending -> 0L + next < 0 -> IDLE_POLL_MS + else -> next.coerceIn(TICK_MS, IDLE_POLL_MS) } - if (ticking) mainHandler.postDelayed(this, TICK_MS) + wakePending = false + schedule(delay) + } + + fun wake() { + if (stopped) return + if (inFlight) wakePending = true else schedule(0) + } + + fun stop() { + stopped = true + mainHandler.removeCallbacks(this) + } + + private fun schedule(delayMs: Long) { + mainHandler.removeCallbacks(this) + mainHandler.postDelayed(this, delayMs) } } companion object { private var instance: FaceclawEvenHubWebViewHost? = null - /** How often the host fires the JS timer queue. 60Hz keeps games smooth. */ + /** Shortest interval between ticks. 60Hz keeps games smooth. */ private const val TICK_MS = 16L + /** Longest a page goes without a tick, as a backstop for missed wakes. */ + private const val IDLE_POLL_MS = 1000L + + private const val TICK_JS = "window.__fcTick?__fcTick():null" + @JvmStatic @Synchronized fun getInstance(): FaceclawEvenHubWebViewHost { @@ -148,12 +197,24 @@ class FaceclawEvenHubWebViewHost { web.setRendererPriorityPolicy(WebView.RENDERER_PRIORITY_IMPORTANT, false) } if (!webViews.contains(web)) webViews.add(web) - if (!ticking) { - ticking = true + if (!tickers.containsKey(web)) { + val ticker = Ticker(web) + tickers[web] = ticker mainHandler.postDelayed(ticker, TICK_MS) } } + /** + * A page scheduled a timer or animation frame due before its next tick. + * Called from the JavaBridge thread; which page asked doesn't matter, as + * an extra tick for another page is harmless. + */ + fun wakeTimers() { + mainHandler.post { + for (ticker in tickers.values) ticker.wake() + } + } + /** Bring an app's WebView to the front of [activity] so it is visible on the phone. */ fun showOnPhone(activity: Activity?, web: WebView) { val o = if (activity != null) ensureOverlay(activity) else overlay ?: return @@ -180,10 +241,7 @@ class FaceclawEvenHubWebViewHost { /** Remove and destroy a WebView (its app is closing). */ fun detach(web: WebView) { webViews.remove(web) - if (webViews.isEmpty() && ticking) { - ticking = false - mainHandler.removeCallbacks(ticker) - } + tickers.remove(web)?.stop() overlay?.removeView(web) web.destroy() } diff --git a/app/apps/evenhub/session.ts b/app/apps/evenhub/session.ts index 74ea59f9..19bb344c 100644 --- a/app/apps/evenhub/session.ts +++ b/app/apps/evenhub/session.ts @@ -110,30 +110,61 @@ export const EVENHUB_BRIDGE_INJECT_SCRIPT = ` }; })(); (function () { - // Host-driven timers. Chromium heavily throttles a page's own - // setTimeout/setInterval when the phone screen is off, which slows - // timer-driven apps to a crawl. Replace them with a queue fired by - // window.__fcTimerTick(), which the native host calls at ~60Hz regardless of + // Host-driven timers and requestAnimationFrame. Chromium heavily throttles a + // page's own setTimeout/setInterval when the phone screen is off, and pauses + // or throttles a hidden page's rAF, which slows timer-driven apps to a crawl + // and stalls canvas apps that render on a rAF loop. Replace them with queues + // fired by window.__fcTick(), which the native host calls regardless of // screen state (host-initiated evaluateJavascript escapes the throttle). - if (window.__fcTimerTick) return; + // (The glasses render via BLE, not the phone's display, so vsync alignment + // doesn't matter — a steady frame rate does.) + // + // __fcTick returns how many ms until it next has work (-1: none), and the + // host sleeps until then instead of evaluating JS at 60Hz for an idle page. + // Work added outside a tick that is due before the host's next tick wakes it + // through the bridge. + if (window.__fcTick) return; + var FRAME_MS = 16; var timers = new Map(); var nextId = 1; + var rafs = new Map(); + var nextRafId = 1; + var inTick = false; + // When the host will next call __fcTick; Infinity while it is idle. + var hostNextTickAt = Infinity; + function needTickBy(due) { + if (inTick || due >= hostNextTickAt) return; + hostNextTickAt = Date.now(); + var bridge = window.__faceclawEvenHub; + if (bridge && bridge.wakeTimers) bridge.wakeTimers(); + } window.setTimeout = function (cb, delay) { var args = Array.prototype.slice.call(arguments, 2); var id = nextId++; - timers.set(id, { cb: cb, args: args, due: Date.now() + (+delay || 0), interval: 0 }); + var due = Date.now() + (+delay || 0); + timers.set(id, { cb: cb, args: args, due: due, interval: 0 }); + needTickBy(due); return id; }; window.setInterval = function (cb, delay) { var args = Array.prototype.slice.call(arguments, 2); var id = nextId++; var d = +delay || 0; - timers.set(id, { cb: cb, args: args, due: Date.now() + d, interval: d }); + var due = Date.now() + d; + timers.set(id, { cb: cb, args: args, due: due, interval: d }); + needTickBy(due); return id; }; window.clearTimeout = function (id) { timers.delete(id); }; window.clearInterval = function (id) { timers.delete(id); }; - window.__fcTimerTick = function () { + window.requestAnimationFrame = function (cb) { + var id = nextRafId++; + rafs.set(id, cb); + needTickBy(Date.now() + FRAME_MS); + return id; + }; + window.cancelAnimationFrame = function (id) { rafs.delete(id); }; + function runTimers() { var now = Date.now(); var dueIds = []; timers.forEach(function (entry, id) { if (entry.due <= now) dueIds.push(id); }); @@ -151,24 +182,8 @@ export const EVENHUB_BRIDGE_INJECT_SCRIPT = ` } try { entry.cb.apply(null, entry.args); } catch (e) { if (window.console) console.error(e); } } - }; -})(); -(function () { - // Host-driven requestAnimationFrame, same idea as the timers above: a hidden - // page's rAF is paused/throttled with the screen off, stalling canvas apps - // that render on a rAF loop. Drive it from window.__fcRafTick(), called by the - // native ticker each frame. (The glasses render via BLE, not the phone's - // display, so vsync alignment doesn't matter — a steady frame rate does.) - if (window.__fcRafTick) return; - var rafs = new Map(); - var nextRafId = 1; - window.requestAnimationFrame = function (cb) { - var id = nextRafId++; - rafs.set(id, cb); - return id; - }; - window.cancelAnimationFrame = function (id) { rafs.delete(id); }; - window.__fcRafTick = function () { + } + function runRafs() { if (rafs.size === 0) return; var ts = window.performance && performance.now ? performance.now() : Date.now(); // Snapshot and clear: callbacks that re-request during this frame run on @@ -178,6 +193,32 @@ export const EVENHUB_BRIDGE_INJECT_SCRIPT = ` current.forEach(function (cb) { try { cb(ts); } catch (e) { if (window.console) console.error(e); } }); + } + function inTickDo(fn) { + inTick = true; + try { fn(); } finally { inTick = false; } + } + // Fixed-rate entry points for hosts that don't use __fcTick's schedule (the + // iOS host calls both every frame). + window.__fcTimerTick = function () { inTickDo(runTimers); }; + window.__fcRafTick = function () { inTickDo(runRafs); }; + window.__fcTick = function () { + inTick = true; + try { + runTimers(); + runRafs(); + } finally { + inTick = false; + } + var now = Date.now(); + var delay = rafs.size ? FRAME_MS : -1; + timers.forEach(function (entry) { + var d = entry.due - now; + if (delay < 0 || d < delay) delay = d; + }); + if (delay >= 0) delay = Math.max(FRAME_MS, Math.ceil(delay)); + hostNextTickAt = delay < 0 ? Infinity : now + delay; + return delay; }; })(); `; diff --git a/app/apps/evenhub/webview.ts b/app/apps/evenhub/webview.ts index 686682a1..06c0f0d3 100644 --- a/app/apps/evenhub/webview.ts +++ b/app/apps/evenhub/webview.ts @@ -96,16 +96,7 @@ export function createEvenHubWebView(session: EvenHubSession): EvenHubWebView { webView.addJavascriptInterface(new com.faceclaw.app.FaceclawEvenHubJsBridge(listener), "__faceclawEvenHub"); // Surface the app's console in logcat (tag FaceclawEvenHubConsole). - const ChromeClient = (android.webkit.WebChromeClient as any).extend({ - onConsoleMessage: (message: any): boolean => { - android.util.Log.i( - "FaceclawEvenHubConsole", - `${message.message()} (${message.sourceId()}:${message.lineNumber()})`, - ); - return true; - }, - }); - webView.setWebChromeClient(new ChromeClient()); + webView.setWebChromeClient(new com.faceclaw.app.FaceclawEvenHubChromeClient()); const nativeHost = com.faceclaw.app.FaceclawEvenHubWebViewHost.getInstance(); nativeHost.attach(activity, webView); diff --git a/app/graphics/evenhub-font.ts b/app/graphics/evenhub-font.ts index 61e5025a..737715ed 100644 --- a/app/graphics/evenhub-font.ts +++ b/app/graphics/evenhub-font.ts @@ -95,6 +95,34 @@ function inMode15UncertainRange(cp: number): boolean { return false; } +/** + * advanceOf's result per (codePoint, nextCodePoint) pair. Pretext's metrics + * are static data, so this never goes stale; it saves wrap/draw three + * getTextWidth calls (each splitting strings and walking the font chain) for + * every character of every repaint. + */ +const kernedAdvances = new Map(); + +function kernedAdvance(codePoint: number, nextCodePoint: number): number { + // Codepoints are < 0x110000, so this key is unique and exact as a double. + const key = codePoint * 0x110000 + nextCodePoint; + let advance = kernedAdvances.get(key); + if (advance === undefined) { + const a = String.fromCodePoint(codePoint); + if (!nextCodePoint) { + advance = getTextWidth(a); + } else { + const b = String.fromCodePoint(nextCodePoint); + advance = getTextWidth(a + b) - getTextWidth(b); + } + // Pairs are bounded by the text actually shown, but CJK-heavy apps could + // still accumulate a lot of them; start over rather than grow forever. + if (kernedAdvances.size >= 65536) kernedAdvances.clear(); + kernedAdvances.set(key, advance); + } + return advance; +} + /** The 4bpp level an 8-bit value packs to (BmpUtil's GRAY_TO_NIBBLE). */ const quantNibble = grayToNibble; @@ -178,15 +206,15 @@ export class EvenHubFont implements FwTextFont { * exactly: width(a+b) - width(b) isolates a's kerned advance. */ advanceOf(codePoint: number, nextCodePoint = 0): number { - const a = String.fromCodePoint(codePoint); - if (!nextCodePoint) return getTextWidth(a); - const b = String.fromCodePoint(nextCodePoint); - return getTextWidth(a + b) - getTextWidth(b); + return kernedAdvance(codePoint, nextCodePoint); } /** Single-line pixel width including kerning (pretext-exact). */ measureLine(text: string): number { - return getTextWidth(text); + const cps = Array.from(text, (c) => c.codePointAt(0)!); + let width = 0; + for (let i = 0; i < cps.length; i++) width += kernedAdvance(cps[i]!, cps[i + 1] ?? 0); + return width; } /** diff --git a/app/native/nightscout-bridge.ts b/app/native/nightscout-bridge.ts index 646b6622..de0856dc 100644 --- a/app/native/nightscout-bridge.ts +++ b/app/native/nightscout-bridge.ts @@ -1,5 +1,5 @@ import { nightscoutApiTokenSetting, nightscoutSiteUrlSetting } from "../ui/dashboard-settings"; -import { fetchWithUserAgent } from "../util/http"; +import { fetchTextWithUserAgent } from "../util/http"; export type NightscoutPoint = { timestampMs: number; @@ -305,11 +305,11 @@ export class NightscoutBridge { } async function fetchJson(url: string): Promise { - const response = await fetchWithUserAgent(url); + const response = await fetchTextWithUserAgent(url); if (!response.ok) { throw new Error(`HTTP ${response.status}`); } - return (await response.json()) as T; + return response.json(); } function parseTreatments(treatments: NightscoutTreatmentResponse[], nowMs: number): { diff --git a/app/util/http.ts b/app/util/http.ts index 9e0a087b..598fc9ef 100644 --- a/app/util/http.ts +++ b/app/util/http.ts @@ -16,6 +16,58 @@ export function fetchWithUserAgent(url: string, init?: RequestInit): Promise; + json(): Promise; +} + +/** + * fetchWithUserAgent for text/JSON bodies, decoded on the Java side. + * NativeScript's fetch() polyfill reads every body as a blob, and on Android + * that copies it from the Java byte[] into JS one bridge call per byte + * (Uint8Array.from in http-request's toArrayBuffer): ~160ms of main thread + * for one Nightscout refresh. Here the body crosses once, as a string. + */ +export async function fetchTextWithUserAgent( + url: string, + init?: { method?: string; headers?: HeadersInit; body?: string }, +): Promise { + // Required lazily so the Node test harness can load this module (via + // fetchWithUserAgent's users) without mocking @nativescript/core. Only the + // http module: the @nativescript/core barrel would pull the UI classes + // (Frame's FragmentClass etc.) into the app workers that import this file, + // and their duplicate extends break the static binding generator. + const { request } = require("@nativescript/core/http") as typeof import("@nativescript/core/http"); + const response = await request({ + url, + method: init?.method ?? "GET", + headers: withUserAgent(init?.headers), + content: init?.body, + }); + const status = response.statusCode; + let body: string | undefined; + const read = (): string => { + if (body === undefined) { + const content = response.content as any; + if (!content) body = ""; + // HttpResponseEncoding.UTF8 is 0, so content.toString() can't ask for + // UTF-8 explicitly on Android; decode the raw ByteArrayOutputStream. + else if (global.isAndroid) body = String(content.raw.toString("UTF-8")); + else body = content.toString(); + } + return body!; + }; + return { + ok: status >= 200 && status < 300, + status, + text: async () => read(), + json: async () => JSON.parse(read()), + }; +} + /** Copies headers into a plain record, adding our User-Agent if absent. */ export function withUserAgent(headers?: HeadersInit): Record { const merged: Record = {}; diff --git a/native/kotlin/shared/src/androidMain/kotlin/com/faceclaw/app/PlatformUtil.android.kt b/native/kotlin/shared/src/androidMain/kotlin/com/faceclaw/app/PlatformUtil.android.kt index fa5bb6a0..1af070c1 100644 --- a/native/kotlin/shared/src/androidMain/kotlin/com/faceclaw/app/PlatformUtil.android.kt +++ b/native/kotlin/shared/src/androidMain/kotlin/com/faceclaw/app/PlatformUtil.android.kt @@ -15,8 +15,18 @@ actual class Sha256Digest actual constructor() { actual fun currentTimeMillis(): Long = System.currentTimeMillis() -actual fun formatLocalTime(epochMs: Long, pattern: String): String = - SimpleDateFormat(pattern, Locale.US).format(Date(epochMs)) +// SimpleDateFormat is costly to build (pattern parse, Calendar, locale data) and not thread-safe, +// so keep one per thread per pattern; the send loop formats a timestamp for every image it logs. +private val localTimeFormats = object : ThreadLocal>() { + override fun initialValue() = HashMap() +} + +actual fun formatLocalTime(epochMs: Long, pattern: String): String { + val format = localTimeFormats.get()!!.getOrPut(pattern) { SimpleDateFormat(pattern, Locale.US) } + // Re-read the default zone each call, as a fresh instance would. + format.timeZone = java.util.TimeZone.getDefault() + return format.format(Date(epochMs)) +} actual object PlatformLog { actual fun i(tag: String, message: String) { 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 b35ed9a1..12eb9a7b 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 @@ -274,15 +274,17 @@ class GlassesSessionCore( internal val desiredTilesLock: ProtocolLock = platform.createLock() internal var desiredFingerprint = "" - // Headerless packed 4bpp frame (see BmpUtil.pack4bppFromGray8) plus its - // pixel dimensions. - internal var desiredPacked: ByteArray? = ByteArray(0) + // Composited 8bpp frame plus its pixel dimensions. The send loop packs it to + // the headerless 4bpp wire format (BmpUtil.pack4bppFromGray8) when it picks + // the frame up, so frames superseded before sending are never packed and + // the packing stays off the submitting (main) thread. + internal var desiredGray: ByteArray? = ByteArray(0) internal var desiredWidth = 0 internal var desiredHeight = 0 internal var desiredPaintMs = 0 internal var desiredFrameId = 0 // Screen-space deferred draws (glyphs + images) whose pixels are baked - // into desiredPacked; the resource-cache planner may replay them as + // into desiredGray; the resource-cache planner may replay them as // on-glasses cached draws. internal var desiredDraws: Array? = arrayOf() // (frame, reason) of the last "waiting to send" line, so a frame that @@ -943,9 +945,7 @@ class GlassesSessionCore( val frameId = frameTimings.startFrame( "compositor:visible $id=$visible") compositor.setSurfaceVisible(id, visible) - val composite = compositor.composite() - val packed = BmpUtil.pack4bppFromGray8(composite.screenGray, composite.width, composite.height) - storeDesiredComposite(composite, packed, 0, frameId) + storeDesiredComposite(compositor.composite(), 0, frameId) } /** @@ -957,9 +957,7 @@ class GlassesSessionCore( val frameId = frameTimings.startFrame( "compositor:" + (if (blanked) "blank" else "unblank")) compositor.setBlanked(blanked) - val composite = compositor.composite() - val packed = BmpUtil.pack4bppFromGray8(composite.screenGray, composite.width, composite.height) - storeDesiredComposite(composite, packed, 0, frameId) + storeDesiredComposite(compositor.composite(), 0, frameId) } /** @@ -979,7 +977,7 @@ class GlassesSessionCore( fun submitShellScene(bytes: ByteReader, paintMs: Int, frameId: Int) { compositor.setShellScene(bytes) val composite = compositor.composite() - storeDesiredComposite(composite, BmpUtil.pack4bppFromGray8(composite.screenGray, composite.width, composite.height), paintMs, frameId) + storeDesiredComposite(composite, paintMs, frameId) } /** Legacy compositor dimming for callers without a shell scene. */ @@ -1016,17 +1014,11 @@ class GlassesSessionCore( val composite = compositor.applyAndComposite( surfaceId, pixels8bpp, rectX, rectY, rectWidth, rectHeight, contentFingerprint, glyphs) frameTimings.spanEnd(frameId, "composite") - // Pack the composited 8bpp buffer down to the headerless 4bpp frame - // format the wire planners consume; BMP framing is added later only for - // the uncompressed fallback. - frameTimings.spanStart(frameId, "pack-4bpp") - val packed = BmpUtil.pack4bppFromGray8(composite.screenGray, composite.width, composite.height) - frameTimings.spanEnd(frameId, "pack-4bpp") - storeDesiredComposite(composite, packed, paintMs, frameId) + storeDesiredComposite(composite, paintMs, frameId) } /** Store a composite as the desired frame unless a newer one won the race. */ - internal fun storeDesiredComposite(composite: SurfaceCompositor.Composite, packed: ByteArray, paintMs: Int, frameId: Int) { + internal fun storeDesiredComposite(composite: SurfaceCompositor.Composite, paintMs: Int, frameId: Int) { var supersededFrameId = 0 var stale = false desiredTilesLock.locked { @@ -1037,7 +1029,7 @@ class GlassesSessionCore( } else { lastStoredCompositeSeq = composite.seq supersededFrameId = desiredFrameId - desiredPacked = packed + desiredGray = composite.screenGray desiredWidth = composite.width desiredHeight = composite.height desiredFingerprint = composite.fingerprint diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt index d116a71e..ba36b747 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/g2protocol/session/GlassesSessionSend.kt @@ -711,7 +711,7 @@ internal fun GlassesSessionCore.enqueueAmbientLightControlLocked(payload: ByteAr internal fun GlassesSessionCore.enqueueDesiredImageLocked() { val fingerprint: String - val packedSnapshot: ByteArray? + val graySnapshot: ByteArray? val width: Int val height: Int val paintMs: Int @@ -720,7 +720,7 @@ internal fun GlassesSessionCore.enqueueDesiredImageLocked() { val scene: ShellScene desiredTilesLock.locked { fingerprint = desiredFingerprint - packedSnapshot = desiredPacked + graySnapshot = desiredGray width = desiredWidth height = desiredHeight paintMs = desiredPaintMs @@ -729,7 +729,13 @@ internal fun GlassesSessionCore.enqueueDesiredImageLocked() { scene = desiredShellScene desiredFrameId = 0 } - val packedFrame: ByteArray = packedSnapshot ?: ByteArray(0) + // Pack here rather than at submit: a frame superseded before the send loop + // gets to it is never packed, and the main thread doesn't pay for it. + frameTimings.spanStart(frameId, "pack-4bpp") + val packedFrame: ByteArray = + if (graySnapshot == null || graySnapshot.isEmpty()) ByteArray(0) + else BmpUtil.pack4bppFromGray8(graySnapshot, width, height) + frameTimings.spanEnd(frameId, "pack-4bpp") // Visibility belongs to this immutable composite, not the latest UI request. enqueueBrightnessLocked(!fingerprint.startsWith("blanked:")) if (customFirmwareDetected && packedFrame.size > 0) { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/DisplayListRenderer.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/DisplayListRenderer.kt index 692f9bcf..85f86753 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/DisplayListRenderer.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/DisplayListRenderer.kt @@ -298,11 +298,78 @@ class DisplayListRenderer( } require(width > 0 && height > 0 && x + width <= source.width && y + height <= source.height) // Mirrors the firmware's overflow guard before the depth shift. - if (walk.apply && dx in -65536..65536) { - // Snapshot the rectangle so overlapping copies have memmove semantics. - val copy = IntArray(width * height) { source.get(x + it % width, y + it / width) } - for (i in copy.indices) target.put(dx + i % width, dy + i / width, copy[i]) + if (!walk.apply || dx !in -65536..65536) return + // Clip the destination to the writable area, in shifted target pixels. + // The source is read unshifted, like Target.get. + val originX = dx + target.shiftX + var left = maxOf(originX, 0) + var right = minOf(originX + width, target.width) + var top = maxOf(dy, 0) + var bottom = minOf(dy.toLong() + height, target.height.toLong()).toInt() + target.clip?.let { clip -> + left = maxOf(left, clip[0]); top = maxOf(top, clip[1]) + right = minOf(right, clip[2]); bottom = minOf(bottom, clip[3]) } + if (left >= right || top >= bottom) return + val count = right - left + val rows = bottom - top + var sourceX = x + (left - originX) + var sourceBytes = source.bytes + var sourceStride = source.stride + var sourceRow = source.offset + (y + (top - dy)) * sourceStride + if (sourceBytes === target.bytes) { + // Snapshot the packed source span so overlapping copies have memmove semantics. + val first = sourceX / 2 + val span = (sourceX + count - 1) / 2 - first + 1 + val snapshot = ByteArray(span * rows) + for (row in 0 until rows) { + val start = sourceRow + row * sourceStride + first + sourceBytes.copyInto(snapshot, row * span, start, start + span) + } + sourceBytes = snapshot + sourceStride = span + sourceRow = 0 + sourceX = sourceX and 1 + } + for (row in 0 until rows) { + copyPixels(sourceBytes, sourceRow + row * sourceStride, sourceX, + target.bytes, target.offset + (top + row) * target.stride, left, count) + } + } + + /** Copy [count] packed 4bpp pixels between rows that must not overlap. */ + private fun copyPixels(source: ByteArray, sourceRow: Int, sourceX: Int, + destination: ByteArray, destinationRow: Int, destinationX: Int, count: Int) { + var sx = sourceX + var dx = destinationX + var remaining = count + if (dx and 1 != 0) { + putPixel(destination, destinationRow, dx++, getPixel(source, sourceRow, sx++)) + remaining-- + } + val pairs = remaining / 2 + var si = sourceRow + sx / 2 + var di = destinationRow + dx / 2 + if (sx and 1 == 0) { + source.copyInto(destination, di, si, si + pairs) + } else { + // Misaligned: each destination byte straddles two source bytes. + repeat(pairs) { + destination[di++] = ((source[si].toInt() shl 4) or ((source[++si].toInt() and 255) ushr 4)).toByte() + } + } + if (remaining and 1 != 0) { + putPixel(destination, destinationRow, dx + pairs * 2, getPixel(source, sourceRow, sx + pairs * 2)) + } + } + + private fun getPixel(bytes: ByteArray, row: Int, x: Int): Int = + (bytes[row + x / 2].toInt() ushr (if (x and 1 == 0) 4 else 0)) and 15 + + private fun putPixel(bytes: ByteArray, row: Int, x: Int, value: Int) { + val index = row + x / 2 + val old = bytes[index].toInt() + bytes[index] = if (x and 1 == 0) ((old and 15) or (value shl 4)).toByte() else ((old and 240) or value).toByte() } private fun drawStockText(reader: DrawReader, target: Target, walk: Walk) { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt index 304cb75d..fa0c46ed 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/ShellScene.kt @@ -2,11 +2,17 @@ package com.faceclaw.app /** Immutable shell snapshot. Keys identify writable surfaces across repaints, not their pixels. */ class ShellScene(val layers: List, val selections: List = emptyList(), val screenDepth: Int = 0) { - class Layer(val key: Int, val x: Int, val y: Int, val width: Int, val height: Int, val dim: Int, val packed: ByteArray, val selections: List = emptyList(), val depth: Int = 0) + class Layer(val key: Int, val x: Int, val y: Int, val width: Int, val height: Int, val dim: Int, val packed: ByteArray, val selections: List = emptyList(), val depth: Int = 0) { + // Layers are reused by every composite until the shell repaints, and hashing packed + // byte-by-byte on each one was a measurable share of the compositor's time. + internal val fingerprint: String by lazy { + "$key,$x,$y,$width,$height,$dim,$depth,${CachedResource(packed).hash},${selections.joinToString { row -> row.fingerprint }}" + } + } val allSelections = selections + layers.flatMap { it.selections } val retainedResources = allSelections.flatMap { it.resources } init { require(retainedResources.size + layers.size < 511 && screenDepth in -128..127) } - val fingerprint: String = layers.joinToString(";") { "${it.key},${it.x},${it.y},${it.width},${it.height},${it.dim},${it.depth},${CachedResource(it.packed).hash},${it.selections.joinToString { row -> row.fingerprint }}" } + selections.joinToString { it.fingerprint } + "|depth:$screenDepth" + val fingerprint: String = layers.joinToString(";") { it.fingerprint } + selections.joinToString { it.fingerprint } + "|depth:$screenDepth" fun calls(width: Int, height: Int, surfaces: IntArray, selected: IntArray): List { val calls = ArrayList(); var rowId = 0 val now = drawAnimationTimeMs() diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt index 14e4e728..58d3c3bf 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/graphics/SurfaceCompositor.kt @@ -582,7 +582,11 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr expectedBytes) ) } - run { + if (rectX == 0 && rectWidth == surface.width) { + // Full-width rect (every current submitter): one bulk read. Per-row reads from a + // direct ByteBuffer each cross into native code, which showed up in profiles. + pixels.get(surface.pixels, rectY * surface.width, expectedBytes) + } else run { var row: Int = 0 while ((row < rectHeight)) { var dstOffset: Int = (((rectY + row) * surface.width) + rectX) diff --git a/tests/evenhub-timer-shim.test.cjs b/tests/evenhub-timer-shim.test.cjs new file mode 100644 index 00000000..68ac7bee --- /dev/null +++ b/tests/evenhub-timer-shim.test.cjs @@ -0,0 +1,77 @@ +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const path = require('node:path'); +const vm = require('node:vm'); + +const source = fs.readFileSync(path.join(__dirname, '../app/apps/evenhub/session.ts'), 'utf8'); +const shim = source.match(/export const EVENHUB_BRIDGE_INJECT_SCRIPT = `([\s\S]*?)`;/)[1]; + +function page() { + const state = { now: 1000, wakes: 0, log: [] }; + const win = { + Date: { now: () => state.now }, console, Map, Array, Math, + __faceclawEvenHub: { postMessage() {}, wakeTimers() { state.wakes++; } }, + }; + win.window = win; + win.performance = { now: () => state.now }; + vm.createContext(win); + vm.runInContext(shim, win); + state.win = win; + state.tick = () => vm.runInContext('__fcTick()', win); + return state; +} + +test('an idle page asks for no ticks, and its first timer wakes the host once', () => { + const p = page(); + assert.equal(p.tick(), -1); + p.win.setTimeout(() => p.log.push('a'), 100); + p.win.setTimeout(() => p.log.push('b'), 200); + assert.equal(p.wakes, 1); + p.now += 5; + assert.equal(p.tick(), 95); + p.now += 95; + assert.equal(p.tick(), 100); + assert.deepEqual(p.log, ['a']); + p.now += 100; + assert.equal(p.tick(), -1); + assert.deepEqual(p.log, ['a', 'b']); +}); + +test('work due before the scheduled tick wakes the host; work added during a tick does not', () => { + const p = page(); + p.win.setTimeout(() => {}, 500); + p.tick(); + const wakes = p.wakes; + p.win.setTimeout(() => { p.win.setTimeout(() => p.log.push('inner'), 0); }, 10); + assert.equal(p.wakes, wakes + 1); + p.now += 10; + assert.equal(p.tick(), 16, 'the inner zero-delay timer runs next frame'); + assert.equal(p.wakes, wakes + 1); + p.now += 16; + p.tick(); + assert.deepEqual(p.log, ['inner']); +}); + +test('an animation-frame loop keeps the host at frame rate until it stops', () => { + const p = page(); + let frames = 0; + const loop = () => { if (++frames < 3) p.win.requestAnimationFrame(loop); }; + p.win.requestAnimationFrame(loop); + p.now += 16; assert.equal(p.tick(), 16); + p.now += 16; assert.equal(p.tick(), 16); + p.now += 16; assert.equal(p.tick(), -1); + assert.equal(frames, 3); +}); + +test('intervals keep cadence and the fixed-rate entry points still work', () => { + const p = page(); + const id = p.win.setInterval(() => p.log.push('iv'), 50); + p.now += 50; assert.equal(p.tick(), 50); + p.now += 50; p.tick(); + p.win.clearInterval(id); + assert.equal(p.tick(), -1); + p.win.setTimeout(() => p.log.push('legacy'), 0); + vm.runInContext('__fcTimerTick(); __fcRafTick()', p.win); + assert.deepEqual(p.log, ['iv', 'iv', 'legacy']); +}); diff --git a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt index 3bd56ef9..db3110a1 100644 --- a/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt +++ b/tests/kotlin/src/commonTest/kotlin/com/faceclaw/app/DisplayListTest.kt @@ -36,6 +36,46 @@ class DisplayListTest { renderer.render(DrawProtocol.SCREEN, DisplayListRenderer.Target(source,640,480), DisplayListRenderer.Target(destination,640,480)) assertContentEquals(source, destination) } + @Test fun rectCopyMatchesPerPixelReferenceWithShiftsClipsAndAliasing() { + val random = Random(7) + repeat(4000) { case -> + val width = random.nextInt(1, 20); val height = random.nextInt(1, 6) + val offset = random.nextInt(3); val shift = random.nextInt(-4, 5) + val clip = if (random.nextBoolean()) null else { + val left = random.nextInt(-3, width + 1); val top = random.nextInt(-2, height + 1) + intArrayOf(left, top, left + random.nextInt(0, width + 3), top + random.nextInt(0, height + 2)) + } + // Screen as a separate array, the target's own array at another offset, or the target itself. + val mode = random.nextInt(3) + val screenWidth = random.nextInt(1, 20); val screenHeight = random.nextInt(1, 6) + val screenOffset = random.nextInt(3) + val targetSize = offset + (width + 1) / 2 * height + val screenSize = screenOffset + (screenWidth + 1) / 2 * screenHeight + val bytes = random.nextBytes(maxOf(targetSize, if (mode == 1) screenSize else 0) + 2) + val screenBytes = if (mode == 0) random.nextBytes(screenSize + 1) else bytes + val sourceId = if (mode == 2) DrawProtocol.CURRENT else DrawProtocol.SCREEN + val sourceWidth = if (mode == 2) width else screenWidth + val sourceHeight = if (mode == 2) height else screenHeight + val w = random.nextInt(1, sourceWidth + 1); val h = random.nextInt(1, sourceHeight + 1) + val x = random.nextInt(sourceWidth - w + 1); val y = random.nextInt(sourceHeight - h + 1) + val dx = random.nextInt(-w - 5, width + 5); val dy = random.nextInt(-h - 2, height + 2) + + val expected = bytes.copyOf() + val expectedScreen = if (mode == 0) screenBytes.copyOf() else expected + val referenceTarget = DisplayListRenderer.Target(expected, width, height, offset, shift, clip) + val referenceSource = if (mode == 2) referenceTarget + else DisplayListRenderer.Target(expectedScreen, screenWidth, screenHeight, screenOffset) + val snapshot = IntArray(w * h) { referenceSource.get(x + it % w, y + it / w) } + for (i in snapshot.indices) referenceTarget.put(dx + i % w, dy + i / w, snapshot[i]) + + val target = DisplayListRenderer.Target(bytes, width, height, offset, shift, clip) + val screen = if (mode == 2) target else DisplayListRenderer.Target(screenBytes, screenWidth, screenHeight, screenOffset) + DisplayListRenderer(emptyMap()).execute( + DrawProtocol.sequence(listOf(DrawProtocol.rectCopy(sourceId, x, y, w, h, dx, dy))), target, screen) + assertContentEquals(expected, bytes, "case $case") + if (mode == 0) assertContentEquals(expectedScreen, screenBytes, "case $case screen") + } + } @Test fun invalidGraphDoesNotCopyScreenIntoComposition() { val screen = hex("12345678"); val composition = hex("9abcdef0") val resources = mapOf(1 to DrawProtocol.displayList(listOf(byteArrayOf(99,0)))) diff --git a/tests/nightscout.test.cjs b/tests/nightscout.test.cjs index 9251c491..38e892f3 100644 --- a/tests/nightscout.test.cjs +++ b/tests/nightscout.test.cjs @@ -206,7 +206,7 @@ test('bridge exposes numeric measurements and treats absent values as unknown', let pump = { reservoir: '10.5', battery: { voltage: '1.15' } }; const module = load('app/native/nightscout-bridge.ts', { '../ui/dashboard-settings': { nightscoutSiteUrlSetting: { get: () => 'https://example.test' }, nightscoutApiTokenSetting: { get: () => 'test' } }, - '../util/http': { async fetchWithUserAgent(url) { + '../util/http': { async fetchTextWithUserAgent(url) { const body = url.includes('/entries.') ? [{ date: now, sgv: 100 }] : url.includes('/devicestatus.') ? [{ pump, openaps: { suggested: { mills: now - 60_000 } } }] : url.includes('/status.') ? {} : []; return { ok: true, json: async () => body }; } }, @@ -231,7 +231,7 @@ test('polling starts once and stops even while the initial HTTP request is pendi const timers = new Map(); const module = load('app/native/nightscout-bridge.ts', { '../ui/dashboard-settings': { nightscoutSiteUrlSetting: { get: () => 'https://example.test' }, nightscoutApiTokenSetting: { get: () => 'test' } }, - '../util/http': { async fetchWithUserAgent() { + '../util/http': { async fetchTextWithUserAgent() { calls++; await pending; return { ok: true, json: async () => [] };