CPU usage optimizations

This commit is contained in:
James Babcock committed 2026-09-27 16:33:43 -07:00
1 parent 95b2ca8afa
commit 3601a998a3
17 files changed
+494 -94

No files matched your search

@@ -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"
}
}
@@ -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()
}
}
@@ -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<WebView> = ArrayList()
private var ticking = false
private val ticker: Runnable = object : Runnable {
private val tickers: MutableMap<WebView, Ticker> = 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()
}
+67 -26
View File
@@ -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;
};
})();
`;
+1 -10
View File
@@ -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);
+33 -5
View File
@@ -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<number, number>();
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;
}
/**
+3 -3
View File
@@ -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<T>(url: string): Promise<T> {
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<T>();
}
function parseTreatments(treatments: NightscoutTreatmentResponse[], nowMs: number): {
+52
View File
@@ -16,6 +16,58 @@ export function fetchWithUserAgent(url: string, init?: RequestInit): Promise<Res
return fetch(url, { ...init, headers: withUserAgent(init?.headers) });
}
/** The parts of a fetch() Response that fetchTextWithUserAgent provides. */
export interface TextResponse {
ok: boolean;
status: number;
text(): Promise<string>;
json<T = unknown>(): Promise<T>;
}
/**
* 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<TextResponse> {
// 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<string, string> {
const merged: Record<string, string> = {};
@@ -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<HashMap<String, SimpleDateFormat>>() {
override fun initialValue() = HashMap<String, SimpleDateFormat>()
}
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) {
@@ -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<SurfaceCompositor.ScreenDraw>? = 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
@@ -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) {
@@ -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) {
@@ -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<Layer>, val selections: List<RetainedDrawing> = 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<RetainedDrawing> = 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<RetainedDrawing> = 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<ByteArray> {
val calls = ArrayList<ByteArray>(); var rowId = 0
val now = drawAnimationTimeMs()
@@ -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)
+77
View File
@@ -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']);
});
@@ -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))))
+2 -2
View File
@@ -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 () => [] };