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

+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> = {};