Merge branch 'main' into microphone-fixes

This commit is contained in:
James Babcock committed 2026-09-27 23:19:03 -07:00
commit 10865fc0cb
32 files changed
+832 -160

No files matched your search

@@ -353,6 +353,9 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre
contentFingerprint, paintMs, frameId, if (glyphs == null) null else AndroidByteReader(glyphs))
}
/** Whether submitting this full-surface content would change nothing (see [GlassesSessionCore.isSurfaceCurrent]). */
fun isSurfaceCurrent(surfaceId: String, fingerprint: String): Boolean = core.isSurfaceCurrent(surfaceId, fingerprint)
/** Play a tone sequence via CFW load_image_z mode 5 kind 4 (payload built on the TS side). */
fun playBuzzerSequence(payload: java.nio.ByteBuffer?) {
val bytes = ByteArray(if (payload == null) 0 else payload.remaining())
@@ -1,14 +1,24 @@
package com.faceclaw.app
import android.app.Activity
import android.content.Context
import android.content.MutableContextWrapper
import android.graphics.Color
import android.graphics.Typeface
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.text.TextUtils
import android.util.TypedValue
import android.view.Gravity
import android.view.View
import android.view.ViewGroup
import android.webkit.WebView
import android.widget.FrameLayout
import android.widget.LinearLayout
import android.widget.TextView
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import java.util.ArrayList
import java.util.HashMap
@@ -34,6 +44,12 @@ import java.util.HashMap
* the chosen WebView to the top of the overlay); hiding sends it back behind.
* All view work happens on the main thread (callers are on the NS/JS thread).
*
* Layout: the activity is edge-to-edge, so the overlay tracks the window
* insets itself. A top bar (the shown app's name and a close button) sits
* under the status bar, and the WebViews fill the area between it and the
* navigation bar / keyboard. That area is the same whether or not the overlay
* is shown, so showing an app doesn't resize (and re-lay-out) its page.
*
* Timer keep-alive: when the phone screen turns off, Chromium heavily throttles
* the page's own setTimeout/setInterval (intensive background throttling clamps
* them to ~1/sec), so timer-driven apps (e.g. snake's game loop) slow to a
@@ -71,8 +87,13 @@ import java.util.HashMap
*/
class FaceclawEvenHubWebViewHost {
private var overlay: FrameLayout? = null
/** Holds the WebViews, inside [overlay] below the top bar. */
private var stack: FrameLayout? = null
private var titleView: TextView? = null
private var overlayActivity: Activity? = null
private var shown = false
private var shownTitle = ""
private var onClose: Runnable? = null
private val mainHandler = Handler(Looper.getMainLooper())
private val webViews: MutableList<WebView> = ArrayList()
@@ -139,6 +160,12 @@ class FaceclawEvenHubWebViewHost {
private const val TICK_JS = "window.__fcTick?__fcTick():null"
/** Top bar height, below the status bar (Material toolbar height). */
private const val BAR_HEIGHT_DP = 56f
/** Matches the NativeScript ActionBar (NativeScriptToolbarStyle). */
private val BAR_COLOR = Color.parseColor("#424242")
@JvmStatic
@Synchronized
fun getInstance(): FaceclawEvenHubWebViewHost {
@@ -152,36 +179,112 @@ class FaceclawEvenHubWebViewHost {
val existing = overlay
if (existing != null && overlayActivity === activity && existing.parent != null) return existing
val content = activity.findViewById<ViewGroup>(android.R.id.content)
(existing?.parent as ViewGroup?)?.removeView(existing)
val created = FrameLayout(activity)
if (existing != null) {
(existing.parent as ViewGroup?)?.removeView(existing)
for (web in webViews) {
existing.removeView(web)
rebaseContext(web, activity)
created.addView(web, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
}
created.setBackgroundColor(Color.BLACK)
val createdStack = FrameLayout(activity)
created.addView(createdStack, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
val bar = buildTopBar(activity)
created.addView(bar, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.TOP))
for (web in webViews) {
(web.parent as ViewGroup?)?.removeView(web)
rebaseContext(web, activity)
createdStack.addView(web, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
}
// Insets are passed on unconsumed: before API 30 a consuming child
// would starve its later siblings (the NativeScript UI) of them.
ViewCompat.setOnApplyWindowInsetsListener(created) { _, insets ->
applyInsets(bar, createdStack, insets)
insets
}
overlay = created
stack = createdStack
overlayActivity = activity
// index 0 = behind the NativeScript content view (raised again below if shown).
content.addView(created, 0, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
ViewCompat.requestApplyInsets(created)
if (shown) created.bringToFront()
return created
}
/** The bar across the top of a shown app: the app's name, then a close button. */
private fun buildTopBar(activity: Activity): LinearLayout {
val bar = LinearLayout(activity)
bar.orientation = LinearLayout.HORIZONTAL
bar.gravity = Gravity.CENTER_VERTICAL
bar.setBackgroundColor(BAR_COLOR)
// Swallow touches so they don't fall through to the WebViews.
bar.isClickable = true
val title = TextView(activity)
title.text = shownTitle
title.setTextColor(Color.WHITE)
title.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20f)
title.typeface = Typeface.create("sans-serif-medium", Typeface.NORMAL)
title.maxLines = 1
title.ellipsize = TextUtils.TruncateAt.END
bar.addView(title, LinearLayout.LayoutParams(0, ViewGroup.LayoutParams.WRAP_CONTENT, 1f).apply {
marginStart = dp(activity, 16f)
marginEnd = dp(activity, 12f)
})
val close = TextView(activity)
close.text = "\u2715"
close.setTextColor(Color.WHITE)
close.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20f)
close.gravity = Gravity.CENTER
close.contentDescription = "Close"
val ripple = TypedValue()
if (activity.theme.resolveAttribute(android.R.attr.selectableItemBackgroundBorderless, ripple, true)) {
close.setBackgroundResource(ripple.resourceId)
}
close.setOnClickListener { onClose?.run() }
val closeSize = dp(activity, 48f)
bar.addView(close, LinearLayout.LayoutParams(closeSize, closeSize).apply {
marginEnd = dp(activity, 4f)
})
titleView = title
return bar
}
/**
* Put the bar under the status bar (its background filling in behind it)
* and the WebViews between the bar and the navigation bar or keyboard.
*/
private fun applyInsets(bar: View, webStack: View, insets: WindowInsetsCompat) {
val bars = insets.getInsets(
WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
val ime = insets.getInsets(WindowInsetsCompat.Type.ime())
val barHeight = dp(bar.context, BAR_HEIGHT_DP)
bar.setPadding(bars.left, bars.top, bars.right, 0)
bar.layoutParams = (bar.layoutParams as FrameLayout.LayoutParams).apply {
height = bars.top + barHeight
}
webStack.layoutParams = (webStack.layoutParams as FrameLayout.LayoutParams).apply {
setMargins(bars.left, bars.top + barHeight, bars.right, maxOf(bars.bottom, ime.bottom))
}
}
private fun dp(context: Context, value: Float): Int {
return TypedValue.applyDimension(
TypedValue.COMPLEX_UNIT_DIP, value, context.resources.displayMetrics).toInt()
}
private fun rebaseContext(web: WebView, activity: Activity) {
(web.context as? MutableContextWrapper)?.baseContext = activity
}
/** Add a WebView to the host, full-size and rendering, hidden behind the UI. */
fun attach(activity: Activity, web: WebView) {
val o = ensureOverlay(activity)
ensureOverlay(activity)
rebaseContext(web, activity)
web.visibility = View.VISIBLE
if (web.parent == null) {
o.addView(web, FrameLayout.LayoutParams(
stack!!.addView(web, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
}
// resumeTimers() is process-global; make sure nothing left timers paused.
@@ -215,9 +318,15 @@ class FaceclawEvenHubWebViewHost {
}
}
/** Bring an app's WebView to the front of [activity] so it is visible on the phone. */
fun showOnPhone(activity: Activity?, web: WebView) {
/**
* Bring an app's WebView to the front of [activity] so it is visible on the
* phone, titled [title]. The top bar's close button runs [onClose].
*/
fun showOnPhone(activity: Activity?, web: WebView, title: String, onClose: Runnable) {
val o = if (activity != null) ensureOverlay(activity) else overlay ?: return
shownTitle = title
this.onClose = onClose
titleView?.text = title
web.bringToFront()
o.bringToFront()
shown = true
@@ -226,6 +335,7 @@ class FaceclawEvenHubWebViewHost {
/** Send the overlay back behind the NativeScript UI. */
fun hideOnPhone() {
shown = false
onClose = null
val o = overlay ?: return
val content = o.parent as ViewGroup?
if (content != null) {
@@ -242,7 +352,7 @@ class FaceclawEvenHubWebViewHost {
fun detach(web: WebView) {
webViews.remove(web)
tickers.remove(web)?.stop()
overlay?.removeView(web)
stack?.removeView(web)
web.destroy()
}
}
@@ -23,6 +23,8 @@ import java.nio.charset.StandardCharsets
import java.util.ArrayDeque
import java.util.ArrayList
import java.util.Collections
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
/**
* Phone side of the Wear OS integration: the single place that talks to the
@@ -114,6 +116,16 @@ class FaceclawWearBridge private constructor(context: Context) {
private val pending = ArrayDeque<PendingMessage>()
private val watchNodes: MutableList<Node> = ArrayList()
private var lastPublishedState: String? = null
/** Latest state waiting for [publishExecutor]; null when none is queued. Guarded by [lock]. */
private var queuedState: String? = null
/**
* Serializing a DataMap and handing it to Play services costs ~10-25ms per
* publish, and the switcher publishes on every foreground change, so it
* runs here instead of on the main thread.
*/
private val publishExecutor: ExecutorService = Executors.newSingleThreadExecutor { runnable ->
Thread(runnable, "FaceclawWearPublish").apply { isDaemon = true }
}
private class PendingMessage(
val path: String,
@@ -210,12 +222,28 @@ class FaceclawWearBridge private constructor(context: Context) {
publishState(json, false)
}
/** As [publishState]; `force` re-sends an unchanged state. */
/**
* As [publishState]; `force` re-sends an unchanged state. The put happens
* on [publishExecutor]; states that arrive while one is still waiting
* replace it, since only the latest matters to the watch.
*/
fun publishState(json: String?, force: Boolean) {
if (!available || json == null) return
synchronized(lock) {
if (!force && json == lastPublishedState) return
lastPublishedState = json
val alreadyQueued = queuedState != null
queuedState = json
if (alreadyQueued) return
}
publishExecutor.execute { publishQueuedState() }
}
private fun publishQueuedState() {
val json: String
synchronized(lock) {
json = queuedState ?: return
queuedState = null
}
try {
val request = PutDataMapRequest.create(PATH_STATE)
@@ -30,5 +30,23 @@ class PreviewBitmapUtil private constructor() {
val colors = PreviewPalette.expand(bytes, 0, width * height, brightenGamma, green)
return Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888)
}
/**
* A white-on-transparent bitmap of an 8bpp glasses icon (gray becomes
* alpha; black, which the glasses show as unlit, is transparent), for
* showing glasses artwork on the phone's dark action bar.
*/
@JvmStatic
fun whiteIconFromGray(gray: ByteBuffer?, width: Int, height: Int): Bitmap {
if (gray == null || width <= 0 || height <= 0 || gray.remaining() < width * height) {
throw IllegalArgumentException("invalid gray icon buffer")
}
val bytes = ByteArray(width * height)
gray.get(bytes)
val colors = IntArray(width * height) { i ->
((bytes[i].toInt() and 0xff) shl 24) or 0x00ffffff
}
return Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888)
}
}
}
+5
View File
@@ -4,6 +4,11 @@
* Add config settings to disable animation categories
* EvenHub compatibility uses menu animations and is closer to style matched
* Reduce phone CPU usage
* Fix a crash on install of larger EvenHub apps
* Fix line wrapping on EvenHub permissions dialog
* Putting on the glasses auto-wakes the screen
* Add a button to the phone screen top bar to open EvenHub app phone UI
## 0.8.0 - 2026-09-26
+13 -2
View File
@@ -16,8 +16,9 @@ ActionItem {
color: #ffffff;
}
/* The main page's custom titleView: title left, connection status and the
* warning triangle right-aligned beside the overflow menu. */
/* The main page's custom titleView: title left; the EvenHub app icon,
* connection status and the warning triangle right-aligned beside the
* overflow menu. */
.action-bar-title {
color: #ffffff;
font-size: 18;
@@ -32,6 +33,16 @@ ActionItem {
vertical-align: center;
}
/* The foreground EvenHub app's icon (opens its phone UI); the padding widens
* the tap target. */
.action-bar-app-icon {
width: 32;
height: 32;
padding: 5.5;
margin-right: 8;
vertical-align: center;
}
/* The emoji brings its own yellow; the padding widens the tap target. */
.action-bar-warning {
font-size: 18;
+10
View File
@@ -51,9 +51,19 @@ export function installedEvenHubPackageId(appId: string): string | null {
}
}
// The parsed index for the last stored value: the launcher and the watch
// state both list installed apps on every refresh, and the sort's
// localeCompare dominated the cost.
let parsedIndex: { raw: string; apps: InstalledEvenHubApp[] } | null = null;
export function getInstalledEvenHubApps(): InstalledEvenHubApp[] {
const raw = getStringSetting(STORAGE_KEY, "");
if (!raw) return [];
if (parsedIndex?.raw !== raw) parsedIndex = { raw, apps: parseInstalledIndex(raw) };
return parsedIndex.apps.map((app) => ({ ...app }));
}
function parseInstalledIndex(raw: string): InstalledEvenHubApp[] {
try {
const parsed = JSON.parse(raw);
if (!Array.isArray(parsed)) return [];
+49 -6
View File
@@ -6,11 +6,12 @@
*
* Glasses-first: launching does NOT take over the phone screen. The phone
* stays on the Faceclaw dashboard; an app's phone UI is shown on demand
* (window menu -> "Show phone UI"), overlaying the dashboard, and the Back
* button returns to it. Apps are kept alive until explicitly closed (no memory
* eviction yet).
* (window menu -> "Show phone UI", or the app-icon button in the phone's
* action bar while the app is foreground on the glasses), overlaying the
* dashboard, and the Back button or the overlay's close button returns to it.
* Apps are kept alive until explicitly closed (no memory eviction yet).
*/
import { Application } from "@nativescript/core";
import { Application, type ImageSource } from "@nativescript/core";
import { type AppContext } from "../app-definition";
import {
appFilesDirPath,
@@ -23,6 +24,8 @@ import { EvenHubSession } from "./session";
import { createEvenHubWindow } from "./evenhub-window";
import { createEvenHubWebView, type EvenHubWebView } from "./webview";
import { shell } from "../../ui/shell/shell";
import { GrayImage } from "../../graphics/image";
import { grayImageToWhiteIconSource } from "../../native/gray-image-preview";
import {
readEvenHubPackageManifest,
installedEvenHubAppId,
@@ -36,12 +39,31 @@ type RunningApp = {
packageId: string;
session: EvenHubSession;
webView: EvenHubWebView;
/** The app's icon for the phone action bar, rendered on first use. */
phoneIcon?: ImageSource | null;
};
/** The phone action bar's button for opening the foreground app's phone UI. */
export type PhoneUiButton = { windowId: string; title: string; icon: ImageSource | null };
/** Pixel size the action-bar icon is rendered at (~21dp at xxhdpi). */
const PHONE_ICON_SIZE = 63;
const running = new Map<string, RunningApp>();
let nextSerial = 1;
let phoneShownWindowId: string | null = null;
let backHandlerRegistered = false;
const phoneShownListeners = new Set<() => void>();
/** Called whenever an app's phone UI is shown or hidden. Returns an unsubscribe. */
export function onPhoneShownChanged(listener: () => void): () => void {
phoneShownListeners.add(listener);
return () => phoneShownListeners.delete(listener);
}
function notifyPhoneShownChanged(): void {
for (const listener of phoneShownListeners) listener();
}
/** Intercept Android Back while an app's phone UI is overlaying the dashboard. */
function ensureBackHandler(): void {
@@ -112,6 +134,7 @@ async function startApp(
if (phoneShownWindowId === windowId) {
webView.hideOnPhone();
phoneShownWindowId = null;
notifyPhoneShownChanged();
}
webView.destroy();
cleanup?.();
@@ -205,15 +228,35 @@ export function showOnPhone(windowId: string): void {
const app = running.get(windowId);
if (!app) return;
if (phoneShownWindowId && phoneShownWindowId !== windowId) hidePhone();
app.webView.showOnPhone();
app.webView.showOnPhone(hidePhone);
phoneShownWindowId = windowId;
notifyPhoneShownChanged();
}
/** Return the phone to the dashboard (Back, or the shown app closing). */
/** Return the phone to the dashboard (Back, the close button, or the shown app closing). */
export function hidePhone(): void {
if (!phoneShownWindowId) return;
running.get(phoneShownWindowId)?.webView.hideOnPhone();
phoneShownWindowId = null;
notifyPhoneShownChanged();
}
/**
* The foreground glasses window, when it is an EvenHub app whose phone UI
* isn't showing: the phone action bar then offers a button to show it.
*/
export function phoneUiButton(): PhoneUiButton | null {
const window = shell.foregroundWindow();
const app = window ? running.get(window.windowId) : undefined;
if (!window || !app || phoneShownWindowId === app.windowId) return null;
if (app.phoneIcon === undefined) {
// The same artwork as the glasses sidebar (installed icon, else the
// generic package icon), drawn white.
const image = new GrayImage(PHONE_ICON_SIZE, PHONE_ICON_SIZE, 0);
window.drawIcon(image, 0, 0, PHONE_ICON_SIZE);
app.phoneIcon = grayImageToWhiteIconSource(image);
}
return { windowId: app.windowId, title: window.title, icon: app.phoneIcon };
}
export function runningAppCount(): number {
+27 -20
View File
@@ -1,6 +1,6 @@
import { getDefaultSmallFont } from "../../graphics/ui-fonts";
import { GrayImage } from "../../graphics/image";
import { truncateText } from "../../graphics/textwrap";
import { truncateText, wrapText } from "../../graphics/textwrap";
import { type InputEvent } from "../../ui/gestures";
import { Layer, type LayerContext, type PaintBelow } from "../../ui/layers";
import { drawListScrollbar, drawSelectionHighlight } from "../../ui/menu";
@@ -8,9 +8,9 @@ import { permissionDetail, permissionLabel, type EvenHubPermission } from "./per
import { openPrivacyPolicyOnPhone } from "./privacy-policy";
import { lineStep, listRowHeight } from "../../ui/metrics";
const DIALOG_X = 8;
const DIALOG_Y = 8;
const DIALOG_WIDTH = 272;
/** Minimum gap between the dialog and the edges of the window it's centered in. */
const DIALOG_MARGIN = 8;
const DIALOG_WIDTH = 320;
const PADDING = 10;
const PERM_GAP = 4;
@@ -27,6 +27,8 @@ const PERM_GAP = 4;
* list on screen.
*/
export class EvenHubPermissionDialogLayer implements Layer {
/** Floats in front of the window content, like the context menus. */
readonly depth = 2;
/** Starts on Allow; the optional privacy-policy action is inserted after it. */
private selectedIndex = 0;
/** First content row drawn; rows above it are scrolled off. */
@@ -50,10 +52,12 @@ export class EvenHubPermissionDialogLayer implements Layer {
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
const font = getDefaultSmallFont();
const { height: viewportHeight } = ctx.stack.getBaseSize();
const { width: viewportWidth, height: viewportHeight } = ctx.stack.getBaseSize();
const image = paintBelow();
const textWidth = DIALOG_WIDTH - 2 * PADDING - 4;
const left = DIALOG_X + PADDING + 2;
const dialogWidth = Math.min(DIALOG_WIDTH, viewportWidth - 2 * DIALOG_MARGIN);
const dialogX = ((viewportWidth - dialogWidth) / 2) | 0;
const textWidth = dialogWidth - 2 * PADDING - 4;
const left = dialogX + PADDING + 2;
const headerStep = lineStep(font) + 2;
const permLabelStep = lineStep(font) + 1;
@@ -80,15 +84,17 @@ export class EvenHubPermissionDialogLayer implements Layer {
for (let index = 0; index < this.permissions.length; index++) {
const permission = this.permissions[index]!;
const detail = permissionDetail(permission);
// One row per wrapped line, so the explanation scrolls line by line.
const detailLines = detail ? wrapText(font, detail, textWidth - 8) : [];
const gapBelow = PERM_GAP + (index === this.permissions.length - 1 ? 2 : 0);
rows.push({
height: permLabelStep + (detail ? 0 : gapBelow),
height: permLabelStep + (detailLines.length ? 0 : gapBelow),
draw: (top) => image.drawText(font, left, top, truncateText(font, permissionLabel(permission.name), textWidth), 220),
});
if (detail) {
for (let line = 0; line < detailLines.length; line++) {
rows.push({
height: permDetailStep + gapBelow,
draw: (top) => image.drawText(font, left + 8, top, truncateText(font, detail, textWidth - 8), 140),
height: permDetailStep + (line === detailLines.length - 1 ? gapBelow : 0),
draw: (top) => image.drawText(font, left + 8, top, detailLines[line]!, 140),
});
}
}
@@ -98,15 +104,16 @@ export class EvenHubPermissionDialogLayer implements Layer {
draw: (top) => {
const selected = this.atBottom() && index === this.selectedIndex;
if (selected) {
drawSelectionHighlight(image, DIALOG_X + 12, top, DIALOG_WIDTH - 24, actionRowH - 1, focused, 8);
drawSelectionHighlight(image, dialogX + 12, top, dialogWidth - 24, actionRowH - 1, focused, 8);
}
image.drawText(font, DIALOG_X + 22, top + 3, actions[index]!, selected ? 255 : 200);
image.drawText(font, dialogX + 22, top + 3, actions[index]!, selected ? 255 : 200);
},
});
}
const contentHeight = rows.reduce((sum, row) => sum + row.height, 0);
const height = Math.min(contentHeight + 2 * PADDING, viewportHeight - 2 * DIALOG_Y);
const height = Math.min(contentHeight + 2 * PADDING, viewportHeight - 2 * DIALOG_MARGIN);
const dialogY = ((viewportHeight - height) / 2) | 0;
const visibleHeight = height - 2 * PADDING;
// The bottommost scroll position: the largest suffix of rows that fits.
@@ -120,13 +127,13 @@ export class EvenHubPermissionDialogLayer implements Layer {
this.firstRow = Math.max(0, Math.min(this.firstRow, maxFirstRow));
// Fill 1 (transparent color key is 0), outline for the dialog edge.
image.fillRoundedRect(DIALOG_X, DIALOG_Y, DIALOG_WIDTH, height, 1);
image.drawRoundedRect(DIALOG_X, DIALOG_Y, DIALOG_WIDTH, height, 72);
image.fillRoundedRect(dialogX, dialogY, dialogWidth, height, 1);
image.drawRoundedRect(dialogX, dialogY, dialogWidth, height, 72);
let y = DIALOG_Y + PADDING;
let y = dialogY + PADDING;
for (let index = this.firstRow; index < rows.length; index++) {
const row = rows[index]!;
if (y + row.height > DIALOG_Y + PADDING + visibleHeight) break;
if (y + row.height > dialogY + PADDING + visibleHeight) break;
row.draw(y);
y += row.height;
}
@@ -134,8 +141,8 @@ export class EvenHubPermissionDialogLayer implements Layer {
if (maxFirstRow > 0) {
drawListScrollbar(
image,
DIALOG_X + DIALOG_WIDTH - 7,
DIALOG_Y + PADDING,
dialogX + dialogWidth - 7,
dialogY + PADDING,
visibleHeight,
this.firstRow,
rows.length - maxFirstRow,
+10 -3
View File
@@ -22,11 +22,13 @@ import { FACECLAW_VERSION } from "../../version";
declare const android: any;
declare const com: any;
declare const java: any;
export type EvenHubWebView = {
evaluateJs: (js: string) => void;
destroy: () => void;
showOnPhone: () => void;
/** Show the app's phone UI; `onClose` runs when its top bar's close button is tapped. */
showOnPhone: (onClose: () => void) => void;
hideOnPhone: () => void;
/** The native android.webkit.WebView, for the host. */
native: unknown;
@@ -118,8 +120,13 @@ export function createEvenHubWebView(session: EvenHubSession): EvenHubWebView {
console.warn(`evenhub webview destroy failed: ${error}`);
}
},
showOnPhone: () =>
nativeHost.showOnPhone(Application.android?.foregroundActivity ?? Application.android?.startActivity ?? null, webView),
showOnPhone: (onClose: () => void) =>
nativeHost.showOnPhone(
Application.android?.foregroundActivity ?? Application.android?.startActivity ?? null,
webView,
session.manifest.name,
new java.lang.Runnable({ run: onClose }),
),
hideOnPhone: () => nativeHost.hideOnPhone(),
};
}
+49 -2
View File
@@ -78,7 +78,14 @@ import {
installedEvenHubPackageId,
uninstallEvenHubPackage,
} from "../apps/evenhub/installed-apps";
import { closeRunningPackage, launchInstalledPackage } from "../apps/evenhub/manager";
import {
closeRunningPackage,
launchInstalledPackage,
onPhoneShownChanged,
phoneUiButton,
showOnPhone as showEvenHubPhoneUi,
type PhoneUiButton,
} from "../apps/evenhub/manager";
import { openEvenHubStoreForPackage } from "../apps/evenhub";
import { isInstalledPackagePresent } from "../apps/evenhub/updates";
import { wearerVerificationOptions } from "../apps/microphones/speakers";
@@ -133,6 +140,11 @@ export type DashboardSnapshot = {
* nothing is paired, so "Disconnected" would be the wrong label.
*/
previewMode: boolean;
/**
* The foreground glasses window's EvenHub phone UI, when it can be opened
* (the action bar's app-icon button); null otherwise.
*/
evenHubPhoneUi: PhoneUiButton | null;
};
type DashboardListener = (snapshot: DashboardSnapshot) => void;
@@ -149,6 +161,9 @@ const SHELL_REFRESH_INTERVAL_MS = 60_000;
// schedules a refresh), so this just covers anything that slips through.
const PREVIEW_INTERVAL_MS = 1_000;
const SCREEN_TIMEOUT_CHECK_MS = 1_000;
// The lock screen is a short notice, not something to read at leisure; it
// ignores the screen-timeout setting (including "never").
const LOCK_SCREEN_TIMEOUT_MS = 15_000;
const EVENHUB_SCREEN_OFF_SUSPEND_DELAY_MS = 5_000;
const EVENHUB_WAKE_READY_TIMEOUT_MS = 4_500;
const FOREGROUND_NOTIFICATION_MIN_UPDATE_MS = 30_000;
@@ -358,6 +373,8 @@ class DashboardController {
launchApp: (appId) => this.launchApp(appId),
requestShellRender: () => this.requestShellRender(),
});
// The action bar's EvenHub phone-UI button hides while that UI is showing.
onPhoneShownChanged(() => this.emit());
shell.configure({
actions: {
...sharedActions,
@@ -365,7 +382,8 @@ class DashboardController {
// surface, so their repaints go through the shell render path.
requestRender: () => this.requestShellRender(),
},
getScreenTimeoutMs: () => screenTimeoutSettingToMs(screenTimeoutSetting.get()),
getScreenTimeoutMs: () =>
this.glassesLocked ? LOCK_SCREEN_TIMEOUT_MS : screenTimeoutSettingToMs(screenTimeoutSetting.get()),
requestShellRender: () => this.requestShellRender(),
prepareVoiceCapture: () => this.prepareVoiceCapture(),
onKeyboardInputChanged: (session) => {
@@ -626,6 +644,9 @@ class DashboardController {
}
private handleWearState(wearing: boolean): void {
// Only an observed OFF_HEAD -> ON_HEAD transition counts as putting the
// glasses on; the first snapshot of a session (null) is just the status.
const putOn = wearing && this.glassesWorn === false;
this.glassesWorn = wearing;
updateGlassesPresence({ worn: wearing });
this.appendLog(wearing ? "glasses wear state: ON_HEAD" : "glasses wear state: OFF_HEAD");
@@ -633,6 +654,19 @@ class DashboardController {
if (!wearing && this.phoneLocked && lockScreenEnabledSetting.get()) {
this.setGlassesLocked(true, "glasses removed while phone locked");
}
if (putOn) this.wakeForGlassesPutOn();
}
/**
* Putting the glasses on wakes the screen, like a double-tap would. While
* locked that shows the lock-screen notice (which then times out on its
* own short timer); otherwise it lands on the sidebar as a normal wake.
*/
private wakeForGlassesPutOn(): void {
if (this.phase !== "connected" || !this.communicator || shell.isScreenOn()) return;
// wake() -> onScreenStateChanged(true) dismisses a showing Glanceboard,
// runs the EvenHub wake barrier and repaints the shell.
if (shell.wake("sidebar")) this.appendLog("screen woken: glasses put on");
}
private handlePhoneLockState(locked: boolean): void {
@@ -1005,9 +1039,15 @@ class DashboardController {
fontsMissingWarningVisible: this.fontsMissingWarningVisible,
alarmReliabilityMessage: this.alarmReliabilityMessage,
previewMode: this.isPreviewDisplayActive(),
evenHubPhoneUi: phoneUiButton(),
};
}
/** Overlay an EvenHub app's phone UI (the action bar's app-icon button). */
showEvenHubPhoneUi(windowId: string): void {
showEvenHubPhoneUi(windowId);
}
/**
* Message to show in place of the display preview, or "" to show the preview.
*
@@ -2475,6 +2515,13 @@ class DashboardController {
return;
}
const fingerprint = frameTimings.span(frameId, "fingerprint", () => planesFingerprint(planes));
// An identical repaint (e.g. every in-process window re-renders when the
// switcher brings it to the foreground) would flatten, encode and
// composite only to be deduped before sending.
if (display.isSurfaceCurrent(surfaceId, fingerprint)) {
frameTimings.finishFrame(frameId, "discarded: surface unchanged");
return;
}
const { image, draws } = frameTimings.span(frameId, "flatten", () => flattenPlanesWithDraws(planes));
const buffer = frameTimings.span(frameId, "to8bpp", () => image.to8bppBuffer());
const preparedDraws = frameTimings.span(frameId, "prepareFrameDraws", () => prepareFrameDraws(draws));
+4
View File
@@ -362,9 +362,13 @@ export class IosPreviewController {
// Sample false to catch a notification missed during suspension. Do not
// sample true here: WillBecomeUnavailable precedes the property transition.
if (!UIApplication.sharedApplication.protectedDataAvailable) this.handlePhoneLockState(true)
// Putting the glasses on (an observed OFF_HEAD -> ON_HEAD transition, not
// a session's first snapshot) wakes the screen, to the lock notice if locked.
const putOn = wearing && this.glassesWorn === false
this.glassesWorn = wearing
this.logBluetooth(`Glasses wear state: ${wearing ? 'ON_HEAD' : 'OFF_HEAD'}`)
if (!wearing && this.phoneLocked && this.lockEnabled) this.setGlassesLocked(true)
if (putOn && this.runtimeRunning && !shell.isScreenOn()) shell.wake('sidebar')
}
private setGlassesLocked(locked: boolean): void {
if (locked === this.glassesLocked) return
+27 -7
View File
@@ -36,14 +36,34 @@ export type DisplayList = {
};
export type PlacedDisplayList = { displayList: DisplayList; x: number; y: number; width: number; height: number; depth: number };
/**
* Growable byte buffer. Lists are encoded on every frame that carries one, and
* twice more for its fingerprint and the preview; resources (whole menu rows,
* scroll strips) are tens of KB, so they go in with one set() rather than a
* push per byte.
*/
class Writer {
bytes: number[] = [];
u8(n: number): void { this.bytes.push(integer(n, 0, 255)); }
private buffer = new Uint8Array(256);
length = 0;
private reserve(count: number): void {
const needed = this.length + count;
if (needed <= this.buffer.length) return;
let size = this.buffer.length * 2;
while (size < needed) size *= 2;
const grown = new Uint8Array(size);
grown.set(this.buffer.subarray(0, this.length));
this.buffer = grown;
}
u8(n: number): void { integer(n, 0, 255); this.reserve(1); this.buffer[this.length++] = n; }
i8(n: number): void { this.u8(integer(n, -128, 127) & 255); }
u16(n: number): void { integer(n, 0, 65535); this.bytes.push(n & 255, n >>> 8); }
u16(n: number): void { integer(n, 0, 65535); this.reserve(2); this.buffer[this.length++] = n & 255; this.buffer[this.length++] = n >>> 8; }
i16(n: number): void { this.u16(integer(n, -32768, 32767) & 65535); }
u32(n: number): void { integer(n, 0, 4294967295); this.u16(n & 65535); this.u16(n >>> 16); }
raw(bytes: ArrayLike<number>): void { for (let i = 0; i < bytes.length; i++) this.bytes.push(bytes[i]); }
raw(bytes: ArrayLike<number>): void { this.reserve(bytes.length); this.buffer.set(bytes, this.length); this.length += bytes.length; }
/** The written bytes, in a buffer of their own. */
bytes(): Uint8Array { return this.buffer.slice(0, this.length); }
/** A view of the written bytes; valid until the next write. */
view(): Uint8Array { return this.buffer.subarray(0, this.length); }
}
/** Length-delimited bridge envelope; call operands use fixed widths except extended x/y. */
@@ -85,9 +105,9 @@ export function encodeDisplayList(placed: PlacedDisplayList, now = Date.now()):
}
}
}
if (out.bytes.length > 4 * 1024 * 1024) throw new Error('Display list exceeds bridge limit');
const header = new Writer(); header.u8(DISPLAY_LIST_RECORD); header.u32(out.bytes.length); header.raw(out.bytes);
return Uint8Array.from(header.bytes);
if (out.length > 4 * 1024 * 1024) throw new Error('Display list exceeds bridge limit');
const header = new Writer(); header.u8(DISPLAY_LIST_RECORD); header.u32(out.length); header.raw(out.view());
return header.bytes();
}
/** Replay-record sizes by tag, as in glyph-wire's frame draw buffer. */
+47 -32
View File
@@ -277,17 +277,28 @@ export class GrayImage {
const destX = dx | 0;
const destY = dy | 0;
for (let row = 0; row < copyHeight; row++) {
const sy = srcY + row;
const ty = destY + row;
if (sy < 0 || sy >= source.height || ty < 0 || ty >= this.height) continue;
for (let col = 0; col < copyWidth; col++) {
const sx = srcX + col;
const tx = destX + col;
if (sx < 0 || sx >= source.width || tx < 0 || tx >= this.width) continue;
const value = source.pixels[sy * source.width + sx] ?? 0;
// Clip once, then copy row spans: flattening a frame blits every plane,
// and per-pixel bounds checks made that a sizeable share of a paint.
const colStart = Math.max(0, -destX);
const colEnd = Math.min(copyWidth, source.width - srcX, this.width - destX);
const rowStart = Math.max(0, -destY);
const rowEnd = Math.min(copyHeight, source.height - srcY, this.height - destY);
const span = colEnd - colStart;
const src = source.pixels;
const dst = this.pixels;
// A blit within one image copies pixel by pixel, forwards, as it always has.
const bulk = !opts.transparentZero && source !== this;
for (let row = rowStart; span > 0 && row < rowEnd; row++) {
const from = (srcY + row) * source.width + srcX + colStart;
const to = (destY + row) * this.width + destX + colStart;
if (bulk) {
dst.set(src.subarray(from, from + span), to);
continue;
}
for (let i = 0; i < span; i++) {
const value = src[from + i]!;
if (opts.transparentZero && value === 0) continue;
this.pixels[ty * this.width + tx] = value;
dst[to + i] = value;
}
}
@@ -398,7 +409,7 @@ export class GrayImage {
hash = mixInt(hash, placed.source.height);
hash = mixInt(hash, placed.source.sourceContentHash32());
if (placed.presentation) { const p = placed.presentation; for (const value of [p.radius, p.background, p.border, p.depth, p.mode === "image" ? 1 : p.mode === "masked-image" ? 2 : 0]) hash = mixInt(hash, value);
if (p.displayList) for (const byte of encodeDisplayList({ displayList: p.displayList, x: 0, y: 0, width: placed.source.width, height: placed.source.height, depth: p.depth }, p.displayList.timeline?.startedAt ?? 0)) hash = mixInt(hash, byte);
if (p.displayList) hash = mixInt(hash, bytesHash32(encodeDisplayList({ displayList: p.displayList, x: 0, y: 0, width: placed.source.width, height: placed.source.height, depth: p.depth }, p.displayList.timeline?.startedAt ?? 0)));
}
} else {
hash = mixInt(hash, 0xf17e);
@@ -415,28 +426,9 @@ export class GrayImage {
return hash >>> 0;
}
/**
* FNV-1a over the raster pixels. Four bytes at a time where alignment
* allows: this runs on every frame's fingerprint, over the whole screen, on
* the thread that is about to hand the frame to the transport.
*/
/** Hash of the raster pixels; see bytesHash32. */
private pixelsHash32(): number {
const pixels = this.pixels;
let hash = 2166136261;
let i = 0;
if ((pixels.byteOffset & 3) === 0) {
const words = new Uint32Array(pixels.buffer, pixels.byteOffset, pixels.length >>> 2);
for (let w = 0; w < words.length; w++) {
hash ^= words[w]!;
hash = Math.imul(hash, 16777619);
}
i = words.length << 2;
}
for (; i < pixels.length; i++) {
hash ^= pixels[i]!;
hash = Math.imul(hash, 16777619);
}
return hash >>> 0;
return bytesHash32(this.pixels);
}
/**
@@ -744,6 +736,29 @@ function clampByte(value: number): number {
}
/** Fold a 32-bit int into an FNV-style running hash. */
/**
* FNV-1a over bytes. Four bytes at a time where alignment allows: this runs on
* every frame's fingerprint, over the whole screen, on the thread that is
* about to hand the frame to the transport.
*/
function bytesHash32(bytes: Uint8Array): number {
let hash = 2166136261;
let i = 0;
if ((bytes.byteOffset & 3) === 0) {
const words = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.length >>> 2);
for (let w = 0; w < words.length; w++) {
hash ^= words[w]!;
hash = Math.imul(hash, 16777619);
}
i = words.length << 2;
}
for (; i < bytes.length; i++) {
hash ^= bytes[i]!;
hash = Math.imul(hash, 16777619);
}
return hash >>> 0;
}
function mixInt(hash: number, value: number): number {
hash ^= value | 0;
return Math.imul(hash, 16777619);
+8
View File
@@ -536,6 +536,14 @@ export class FaceclawCommunicatorBridge {
await this.enqueueNativeCall(() => { this.communicator.setScreenBlankedBlanked(Boolean(blanked)); });
}
/**
* See the Android bridge. Not wired to the shared compositor's check on iOS
* yet, so every repaint is submitted as before.
*/
isSurfaceCurrent(_surfaceId: string, _fingerprint: string): boolean {
return false;
}
async submitSurfaceFrame(
surfaceId: string,
pixels8bpp: Uint8Array,
+23 -2
View File
@@ -133,6 +133,8 @@ export class FaceclawCommunicatorBridge {
private javaCallQueue: Promise<void> = Promise.resolve();
/** Calls waiting on javaCallQueue; 0 means enqueueJavaCall's fast path is safe. */
private queuedJavaCalls = 0;
/** Queued calls that may change what a surface holds; see isSurfaceCurrent. */
private queuedSurfaceChanges = 0;
// Reused Java-side buffers for byte payloads; passing a JS ArrayBuffer to
// Java leaks it (see java-direct-buffer.ts). Loaded inside the queued call,
// immediately before the synchronous Java call that consumes them.
@@ -267,8 +269,12 @@ export class FaceclawCommunicatorBridge {
* the frame timings), which is pure latency on a call the caller is already
* awaiting. Off by default: a call that might block for a while should keep
* yielding to the main looper first.
*
* preservesSurfaces marks a call that neither changes a surface's retained
* content nor leaves a change waiting for a later composite (it composites
* itself), so having it queued does not make isSurfaceCurrent answer false.
*/
private enqueueJavaCall<T>(operation: () => T, inlineWhenIdle = false): Promise<T> {
private enqueueJavaCall<T>(operation: () => T, inlineWhenIdle = false, preservesSurfaces = false): Promise<T> {
if (inlineWhenIdle && this.queuedJavaCalls === 0) {
try {
return Promise.resolve(operation());
@@ -277,10 +283,12 @@ export class FaceclawCommunicatorBridge {
}
}
this.queuedJavaCalls++;
if (!preservesSurfaces) this.queuedSurfaceChanges++;
const run = () =>
new Promise<T>((resolve, reject) => {
setTimeout(() => {
this.queuedJavaCalls--;
if (!preservesSurfaces) this.queuedSurfaceChanges--;
try {
resolve(operation());
} catch (error) {
@@ -549,6 +557,7 @@ export class FaceclawCommunicatorBridge {
await this.enqueueJavaCall(
() => this.communicator.submitShellScene(this.shellSceneBuffer.load(snapshot), paintMs, frameId),
true,
true,
);
}
@@ -562,7 +571,19 @@ export class FaceclawCommunicatorBridge {
async setSurfaceVisible(id: string, visible: boolean): Promise<void> {
await this.enqueueJavaCall(() => {
this.communicator.setSurfaceVisible(id, Boolean(visible));
});
}, false, true);
}
/**
* Whether submitting a full-surface frame with this fingerprint would
* change nothing: Java already holds that content for the surface, and no
* queued or not-yet-composited change is waiting on a composite. Lets a
* repaint that came out identical (a window re-rendered when it comes to
* the foreground, say) skip flattening and submitting its frame.
*/
isSurfaceCurrent(surfaceId: string, fingerprint: string): boolean {
if (this.queuedSurfaceChanges > 0) return false;
return Boolean(this.communicator.isSurfaceCurrent(surfaceId, fingerprint));
}
/**
+18
View File
@@ -27,3 +27,21 @@ export function grayImageToPreviewSource(image: GrayImage): ImageSource | null {
);
return new ImageSource(bitmap);
}
/**
* A glasses icon as a white-on-transparent phone image (gray becomes alpha),
* for the dark action bar.
*/
export function grayImageToWhiteIconSource(image: GrayImage): ImageSource | null {
if (!global.isAndroid) {
return null;
}
const baked = image.withDrawsBaked();
const bitmap = com.faceclaw.app.PreviewBitmapUtil.whiteIconFromGray(
copyToJavaByteBuffer(baked.pixels),
baked.width,
baked.height,
);
return new ImageSource(bitmap);
}
+18
View File
@@ -7,7 +7,25 @@ export type PhoneBatteryState = {
charging: boolean | null;
};
// The Android read is a sticky-broadcast binder round trip, and the top bar
// asks on every shell paint; the level moves far slower than that.
const ANDROID_CACHE_MS = 5000;
let cachedState: PhoneBatteryState | null = null;
let cachedAtMs = 0;
export function readPhoneBatteryState(): PhoneBatteryState {
if (global.isAndroid) {
const now = Date.now();
if (cachedState === null || now - cachedAtMs >= ANDROID_CACHE_MS || now < cachedAtMs) {
cachedState = readPhoneBatteryStateUncached();
cachedAtMs = now;
}
return { ...cachedState };
}
return readPhoneBatteryStateUncached();
}
function readPhoneBatteryStateUncached(): PhoneBatteryState {
if (global.isIOS) {
const device = UIDevice.currentDevice
const level = device.batteryLevel
+6
View File
@@ -18,6 +18,7 @@ export type DisplayTarget = Pick<
| "setUnderlayDim"
| "setScreenBlanked"
| "submitSurfaceFrame"
| "isSurfaceCurrent"
| "submitShellScene"
| "waitForFrameFinished"
| "getCompositePreview"
@@ -109,6 +110,11 @@ export class PreviewDisplayTarget implements DisplayTarget {
this.composited();
}
/** Never skips: preview frames are cheap and nothing is transmitted. */
isSurfaceCurrent(_surfaceId: string, _fingerprint: string): boolean {
return false;
}
async submitShellScene(bytes: Uint8Array, _paintMs = 0, _frameId = 0): Promise<void> {
this.compositor.setShellScene(bytes);
this.composited();
+6
View File
@@ -24,6 +24,7 @@ export type DisplayTarget = Pick<
| "setUnderlayDim"
| "setScreenBlanked"
| "submitSurfaceFrame"
| "isSurfaceCurrent"
| "submitShellScene"
| "waitForFrameFinished"
| "getCompositePreview"
@@ -109,6 +110,11 @@ export class PreviewDisplayTarget implements DisplayTarget {
this.compositor.setSurfaceDepth(id, Math.round(depth));
}
/** Never skips: preview frames are cheap and nothing is transmitted. */
isSurfaceCurrent(_surfaceId: string, _fingerprint: string): boolean {
return false;
}
async submitShellScene(bytes: Uint8Array, paintMs = 0, frameId = 0): Promise<void> {
this.compositor.submitShellScene(this.shellSceneBuffer.load(bytes), paintMs, frameId);
}
+81 -16
View File
@@ -8,17 +8,35 @@
import { Utils } from "@nativescript/core";
declare const com: any;
declare const android: any;
let javaInstance: any = null;
// The Java-side listener proxy must stay referenced or it gets GC'd.
let retainedListenerProxy: any = null;
const changeListeners = new Set<(key: string) => void>();
// Values already read through JNI, which cost a bridge call each and are read
// many times per paint (display mode, fonts, clock format). Only used while
// this isolate's Java listener is registered on a thread with a Looper: every
// write, from any isolate, notifies that listener, which drops the key before
// any other change listener runs. A write from another isolate is visible here
// once its notification has been dispatched (one message-loop tick), the same
// point at which change listeners hear about it.
// Strings are cached without a default (null = unset). Booleans are cached per
// default, since the Java getter cannot report "unset", except after a write
// from this isolate (defaultValue null: stored, so any default reads it).
const stringCache = new Map<string, string | null>();
const booleanCache = new Map<string, { defaultValue: boolean | null; value: boolean }>();
let cachingEnabled: boolean | null = null;
/** Release this isolate's native observer before its worker is terminated. */
export function disposeSettingsStore(): void {
changeListeners.clear();
if (retainedListenerProxy !== null) getJava().unregisterListener(retainedListenerProxy);
retainedListenerProxy = null;
cachingEnabled = false;
stringCache.clear();
booleanCache.clear();
}
function getJava(): any {
@@ -31,20 +49,80 @@ function getJava(): any {
return javaInstance;
}
function canCache(): boolean {
if (cachingEnabled === null) {
cachingEnabled = false;
try {
// FaceclawSettings dispatches notifications through the registering
// thread's Looper; without one this isolate would never hear of writes.
if (android.os.Looper.myLooper() !== null) {
ensureJavaListener();
cachingEnabled = true;
}
} catch {
cachingEnabled = false;
}
}
return cachingEnabled;
}
export function getStringSetting(key: string, defaultValue: string): string {
return String(getJava().getString(key, defaultValue));
if (!canCache()) return String(getJava().getString(key, defaultValue));
let value = stringCache.get(key);
if (value === undefined) {
const raw = getJava().getString(key, null);
value = raw === null || raw === undefined ? null : String(raw);
stringCache.set(key, value);
}
return value ?? defaultValue;
}
export function setStringSetting(key: string, value: string): void {
getJava().setString(key, value);
if (cachingEnabled) stringCache.set(key, value === null || value === undefined ? null : String(value));
}
export function getBooleanSetting(key: string, defaultValue: boolean): boolean {
return Boolean(getJava().getBoolean(key, defaultValue));
if (!canCache()) return Boolean(getJava().getBoolean(key, defaultValue));
const cached = booleanCache.get(key);
if (cached !== undefined && (cached.defaultValue === null || cached.defaultValue === defaultValue)) {
return cached.value;
}
const value = Boolean(getJava().getBoolean(key, defaultValue));
booleanCache.set(key, { defaultValue, value });
return value;
}
export function setBooleanSetting(key: string, value: boolean): void {
getJava().setBoolean(key, value);
if (cachingEnabled) booleanCache.set(key, { defaultValue: null, value: Boolean(value) });
}
function forgetCachedSetting(key: string | null | undefined): void {
if (key === null || key === undefined) {
stringCache.clear();
booleanCache.clear();
return;
}
stringCache.delete(key);
booleanCache.delete(key);
}
function ensureJavaListener(): void {
if (retainedListenerProxy !== null) return;
retainedListenerProxy = new com.faceclaw.app.FaceclawSettingsListener({
onSettingChanged: (key: string) => {
forgetCachedSetting(key === null || key === undefined ? key : String(key));
for (const registered of Array.from(changeListeners)) {
try {
registered(String(key));
} catch (error) {
console.warn("settings change listener failed", error);
}
}
},
});
getJava().registerListener(retainedListenerProxy);
}
/**
@@ -53,20 +131,7 @@ export function setBooleanSetting(key: string, value: boolean): void {
* change.
*/
export function onSettingsStoreChanged(listener: (key: string) => void): () => void {
if (retainedListenerProxy === null) {
retainedListenerProxy = new com.faceclaw.app.FaceclawSettingsListener({
onSettingChanged: (key: string) => {
for (const registered of Array.from(changeListeners)) {
try {
registered(String(key));
} catch (error) {
console.warn("settings change listener failed", error);
}
}
},
});
getJava().registerListener(retainedListenerProxy);
}
ensureJavaListener();
changeListeners.add(listener);
return () => {
changeListeners.delete(listener);
+7 -5
View File
@@ -1,11 +1,13 @@
<Page xmlns="http://schemas.nativescript.org/tns.xsd" xmlns:rc="phone-ui" navigatingTo="navigatingTo" loaded="loaded" unloaded="unloaded">
<ActionBar>
<!-- Custom titleView: app title on the left; connection status and the
warning-triangle indicator right-aligned beside the overflow menu. -->
<GridLayout columns="auto,*,auto,auto" width="100%" verticalAlignment="center">
<!-- Custom titleView: app title on the left; the foreground EvenHub
app's phone-UI button, connection status and the warning-triangle
indicator right-aligned beside the overflow menu. -->
<GridLayout columns="auto,*,auto,auto,auto" width="100%" verticalAlignment="center">
<Label col="0" text="Faceclaw" class="action-bar-title" />
<Label col="2" text="{{ connectionStatusLabel }}" tap="{{ onConnectionStatusTap }}" class="action-bar-status" />
<Label col="3" text="&#x26A0;&#xFE0F;" tap="{{ onWarningIconTap }}" visibility="{{ warningIconVisibility }}" class="action-bar-warning" />
<Image col="2" src="{{ evenHubPhoneUiIcon }}" tap="{{ onEvenHubPhoneUiTap }}" visibility="{{ evenHubPhoneUiVisibility }}" class="action-bar-app-icon" />
<Label col="3" text="{{ connectionStatusLabel }}" tap="{{ onConnectionStatusTap }}" class="action-bar-status" />
<Label col="4" text="&#x26A0;&#xFE0F;" tap="{{ onWarningIconTap }}" visibility="{{ warningIconVisibility }}" class="action-bar-warning" />
</GridLayout>
<ActionItem text="{{ buttonLabel }}" tap="{{ onTap }}" isEnabled="{{ connectItemEnabled }}" visibility="{{ glassesMenuItemsVisibility }}" android.position="popup" />
<ActionItem text="Pair glasses" tap="{{ onPairGlassesTap }}" isEnabled="{{ canRun }}" android.position="popup" />
+25
View File
@@ -25,6 +25,7 @@ import { isAutoReconnectSuppressed, resumeAutoReconnect } from "../g2/reconnect-
import { isPreviewOnlyMode } from "./onboarding-state";
import { formatErrorMessage } from "../util/format-error";
import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image";
import { type PhoneUiButton } from "../apps/evenhub/manager";
const LENS_ASPECT_RATIO = G2_LENS_WIDTH / G2_LENS_HEIGHT;
@@ -63,6 +64,7 @@ export class MainViewModel extends RemoteControlsViewModel {
private _alarmReliabilityMessage = "";
private _warningsModalVisible = false;
private _previewMode = false;
private _evenHubPhoneUi: PhoneUiButton | null = null;
private _phase: "disconnected" | "connecting" | "connected" | "charging" | "disconnecting" = "disconnected";
// A new view model is built on every navigation to the main page; these
@@ -112,6 +114,7 @@ export class MainViewModel extends RemoteControlsViewModel {
this.batteryOptimizationWarningVisible = snapshot.batteryOptimizationWarningVisible;
this.fontsMissingWarningVisible = snapshot.fontsMissingWarningVisible;
this.alarmReliabilityMessage = snapshot.alarmReliabilityMessage;
this.evenHubPhoneUi = snapshot.evenHubPhoneUi;
this.refreshPadFocusLine();
}));
// Brightness / display mode can change from the glasses' Settings app too.
@@ -773,6 +776,28 @@ export class MainViewModel extends RemoteControlsViewModel {
return this._warningsModalVisible ? "visible" : "collapse";
}
set evenHubPhoneUi(value: PhoneUiButton | null) {
const current = this._evenHubPhoneUi;
if (current?.windowId === value?.windowId && current?.icon === value?.icon) return;
this._evenHubPhoneUi = value;
this.notifyPropertyChange("evenHubPhoneUiIcon", this.evenHubPhoneUiIcon);
this.notifyPropertyChange("evenHubPhoneUiVisibility", this.evenHubPhoneUiVisibility);
}
/** The foreground EvenHub app's icon, which opens its phone UI when tapped. */
get evenHubPhoneUiIcon(): ImageSource | null {
return this._evenHubPhoneUi?.icon ?? null;
}
get evenHubPhoneUiVisibility(): "visible" | "collapse" {
return this._evenHubPhoneUi?.icon ? "visible" : "collapse";
}
onEvenHubPhoneUiTap(): void {
const windowId = this._evenHubPhoneUi?.windowId;
if (windowId) dashboardController.showEvenHubPhoneUi(windowId);
}
onWarningIconTap(): void {
this.setWarningsModalVisible(true);
}
+5 -5
View File
@@ -3,13 +3,13 @@ import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../gestures";
import { Layer, type LayerActions, type LayerContext } from "../layers";
import { createInputDialogMenu, paintInputDialog, type InputDialogRow } from "./input-dialog";
const FOLLOW_UP_ROW = 0;
const FOLLOW_UP_ROW = 1;
const MENU_ROWS: readonly InputDialogRow[] = [
{ label: "Follow-up", dim: false },
{ label: "Done", dim: false },
{ label: "Follow-up", dim: false },
];
/** thinking: turn running; done/error: finished, showing the Follow-up/Done menu. */
/** thinking: turn running; done/error: finished, showing the Done/Follow-up menu. */
type AssistantPhase = "thinking" | "done" | "error";
export type AssistantLayerCallbacks = {
@@ -25,7 +25,7 @@ export type AssistantLayerCallbacks = {
/**
* The assistant overlay: streamed reply text with a status line for tool
* activity, and a Follow-up / Done menu once the turn ends. Double-click
* activity, and a Done / Follow-up menu once the turn ends. Double-click
* cancels an in-flight turn. The shell owns the AssistantSession and drives
* this layer's state through the on* methods as the turn streams.
*/
@@ -99,7 +99,7 @@ export class AssistantLayer implements Layer {
}
return;
}
// done / error: the Follow-up / Done menu.
// done / error: the Done / Follow-up menu.
switch (event.type) {
case "scroll-up":
case "scroll-down":
+7 -3
View File
@@ -14,8 +14,9 @@ export type PersistedOpenApps = {
const STATE_VERSION = 1;
const FILE_NAME = "open-apps.json";
// Coalesces bursts (restore, sidebar scrolling) into one write; short enough
// that a build-reinstall kill right after a change rarely loses it.
// Coalesces bursts (restore, sidebar scrolling) into one write once they
// settle; short enough that a build-reinstall kill right after a change
// rarely loses it.
const WRITE_DELAY_MS = 1000;
function openAppsFilePath(): string {
@@ -50,7 +51,10 @@ let pendingState: PersistedOpenApps | null = null;
/** Save the open-app state (debounced; the latest state wins). */
export function savePersistedOpenApps(state: PersistedOpenApps): void {
pendingState = state;
if (writeTimer !== null) return;
// Restarted on every change: scrolling through the switcher changes the
// foreground app a few times a second, and each synchronous write costs
// several milliseconds of main thread.
if (writeTimer !== null) clearTimeout(writeTimer);
writeTimer = setTimeout(() => {
writeTimer = null;
const state = pendingState;
+1 -1
View File
@@ -646,7 +646,7 @@ class Shell {
// The keyboard dialog likewise: typing happens on the phone, not the
// ring. An in-flight assistant turn suspends it for the same reason (a
// tool loop can run for a while with no input); once the turn ends and
// the Follow-up/Done menu is showing, the normal idle timeout resumes.
// the Done/Follow-up menu is showing, the normal idle timeout resumes.
if (this.activeVoiceLayer || this.activeKeyboardLayer || this.assistantSession?.isTurnActive() || this.foregroundWindow()?.isVoiceCapturing?.()) {
this.lastInputAtMs = nowMs;
return false;
@@ -63,7 +63,7 @@ class ScenePlanner(private val cache: ResourceCacheState) {
val calls = ArrayList<ByteArray>()
for (top in 0 until height step 32) {
val rows = minOf(32, height - top)
if (old != null && (top * stride until (top + rows) * stride).all { old[it] == next[it] }) continue
if (old != null && sameBytes(old, next, top * stride, (top + rows) * stride)) continue
var left = width; var right = -1
for (y in top until top + rows) for (x in 0 until width) {
val p = y * stride + x / 2; val shift = if (x % 2 == 0) 4 else 0
@@ -75,4 +75,12 @@ class ScenePlanner(private val cache: ResourceCacheState) {
}
return calls
}
private fun sameBytes(a: ByteArray, b: ByteArray, from: Int, to: Int): Boolean {
var i = from
while (i < to) {
if (a[i] != b[i]) return false
i++
}
return true
}
}
@@ -1036,6 +1036,10 @@ class GlassesSessionCore(
storeDesiredComposite(composite, paintMs, frameId)
}
/** See [SurfaceCompositor.isSurfaceCurrent]. */
fun isSurfaceCurrent(surfaceId: String, fingerprint: String): Boolean =
compositor.isSurfaceCurrent(surfaceId, fingerprint)
/** Store a composite as the desired frame unless a newer one won the race. */
internal fun storeDesiredComposite(composite: SurfaceCompositor.Composite, paintMs: Int, frameId: Int) {
var supersededFrameId = 0
@@ -2,11 +2,14 @@ package com.faceclaw.app
/** A retained selection or image, replayed at stereo depth over the screen and shell surfaces. */
class MenuSelection(val x: Int, val y: Int, val width: Int, val height: Int, val radius: Int,
val background: Int, val border: Int, val depth: Int, val packed: ByteArray, val occlusions: List<IntArray> = emptyList(), val kind: Int = DrawRecordKind.MENU_SELECTION, val mask: List<IntArray> = emptyList()) : RetainedDrawing {
val resource = CachedResource(DrawProtocol.rawImage(width, height, packed))
val background: Int, val border: Int, val depth: Int, val packed: ByteArray, val occlusions: List<IntArray> = emptyList(), val kind: Int = DrawRecordKind.MENU_SELECTION, val mask: List<IntArray> = emptyList(),
/** [packed] as a raw-image resource; translated copies share it (and its hash) instead of rebuilding it. */
val resource: CachedResource = CachedResource(DrawProtocol.rawImage(width, height, packed))) : RetainedDrawing {
override val resources = listOf(resource)
override val fingerprint = "$kind,${mask.joinToString { it.joinToString() }},$x,$y,$width,$height,$radius,$background,$border,$depth,${resource.hash},${occlusions.joinToString { it.joinToString() }}"
override fun translated(dx: Int, dy: Int) = MenuSelection(x + dx, y + dy, width, height, radius, background, border, depth, packed, occlusions.map { intArrayOf(it[0] + dx, it[1] + dy, it[2], it[3]) }, kind, mask)
override val fingerprint: String by lazy {
"$kind,${mask.joinToString { it.joinToString() }},$x,$y,$width,$height,$radius,$background,$border,$depth,${resource.hash},${occlusions.joinToString { it.joinToString() }}"
}
override fun translated(dx: Int, dy: Int) = if (dx == 0 && dy == 0) this else MenuSelection(x + dx, y + dy, width, height, radius, background, border, depth, packed, occlusions.map { intArrayOf(it[0] + dx, it[1] + dy, it[2], it[3]) }, kind, mask, resource)
override fun calls(ids: IntArray, nowMs: Long) = calls(ids.single())
fun calls(id: Int): List<ByteArray> {
val image = when (kind) {
@@ -43,11 +43,19 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
return maxOf(1, (((value * dim) + 128) shr 8))
}
/**
* The rest of [reader] as a heap-array reader. Parsing reads field by field, and through a
* platform buffer (Android's direct ByteBuffer) each byte was its own native peek; one bulk
* copy first is far cheaper.
*/
private fun heapReader(reader: ByteReader): ByteReader =
if (reader is ArrayByteReader) reader else ArrayByteReader(ByteArray(reader.remaining()).also { reader.get(it) })
private fun parseDraws(draws: ByteReader?): Array<ScreenDraw> {
if (((draws == null) || (draws.remaining() < 1))) {
return NO_DRAWS
}
val cursor: ByteReader = draws
val cursor: ByteReader = heapReader(draws)
var out: MutableList<ScreenDraw> = ArrayList()
while ((cursor.remaining() >= 1)) {
var kind: Int = (cursor.get() and 0xff)
@@ -253,8 +261,11 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
private var shellScene: ShellScene? = null
fun setShellScene(reader: ByteReader) {
val scene = ShellScene.decode(reader)
lock.withLock { shellScene = scene }
val scene = ShellScene.decode(heapReader(reader))
lock.withLock {
shellScene = scene
changedSinceComposite = true
}
}
private class Surface {
@@ -284,6 +295,16 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
/** Surface-local deferred draws of the retained content (already baked into pixels). */
@JvmField var draws: Array<ScreenDraw> = NO_DRAWS
/**
* [draws]' retained selections in screen coordinates, as built for [placedFor] at
* ([placedX], [placedY]). Reused by every composite until either changes, so the shell
* scene built from them (and its fingerprint) can be reused too.
*/
@JvmField var placedSelections: List<RetainedDrawing> = emptyList()
@JvmField var placedFor: Array<ScreenDraw>? = null
@JvmField var placedX: Int = 0
@JvmField var placedY: Int = 0
constructor(id: String) {
this.id = id
}
@@ -291,6 +312,8 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
private val lock = protocolPlatform().createLock()
private var animatedPreview: ShellScene.AnimatedPreview? = null
/** The last composite's scene; reused while its inputs are unchanged (see compositeLocked). */
private var lastScene: ShellScene? = null
private var previewKey: String? = null
private fun previewScene(scene: ShellScene, gray: ByteArray, key: String): ByteArray {
@@ -318,6 +341,13 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
private var nextCompositeSeq: Long = 1
/**
* Set by changes that take effect at the next composite (geometry, dim, depth, blanking,
* visibility, a new shell scene, content retained without compositing) and cleared by a
* composite that is kept (not a preview); see [isSurfaceCurrent].
*/
private var changedSinceComposite: Boolean = false
/** Set the output frame size. Must be called before any surface work. */
fun configureScreen(width: Int, height: Int): Unit {
if (((width <= 0) || (height <= 0))) {
@@ -376,12 +406,27 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
surface.height = height
surface.zOrder = zOrder
surface.transparency = transparency
changedSinceComposite = true
}
}
fun removeSurface(id: String): Unit {
lock.withLock {
surfaces.remove(id)
changedSinceComposite = true
}
}
/**
* Whether a full-surface update carrying [fingerprint] would change nothing: the surface
* already retains that content and every other change has reached a kept composite. A
* submitter can then drop an identical repaint without flattening or sending it.
*/
fun isSurfaceCurrent(id: String, fingerprint: String): Boolean {
lock.withLock {
if (changedSinceComposite) return false
val surface = surfaces.get(id) ?: return false
return surface.fingerprint.isNotEmpty() && surface.fingerprint == fingerprint
}
}
@@ -398,6 +443,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
lock.withLock {
underlayDimBelowZOrder = belowZOrder
underlayDim = maxOf(0, minOf(256, factor256))
changedSinceComposite = true
}
}
@@ -419,6 +465,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
throw IllegalArgumentException(("unknown surface " + id))
}
surface.visible = visible
changedSinceComposite = true
}
}
@@ -432,6 +479,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
lock.withLock {
val surface = surfaces.get(id) ?: throw IllegalArgumentException(("unknown surface " + id))
surface.depth = depth
changedSinceComposite = true
}
}
@@ -450,6 +498,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
fun setBlanked(blanked: Boolean): Unit {
lock.withLock {
this.blanked = blanked
changedSinceComposite = true
}
}
@@ -596,6 +645,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
}
surface.fingerprint = (if ((contentFingerprint == null)) "" else contentFingerprint)
surface.draws = parsed
if (!composeAfter) changedSinceComposite = true
return if (composeAfter) compositeLocked() else null
}
}
@@ -618,8 +668,10 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
return null
}
val seq = nextCompositeSeq
val changed = changedSinceComposite
val result = compositeLocked(includePreview = true)
nextCompositeSeq = seq
changedSinceComposite = changed
return result
}
}
@@ -640,6 +692,7 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
}
private fun compositeLocked(includePreview: Boolean = includePreviewInFrames): Composite {
changedSinceComposite = false
var gray: ByteArray = ByteArray((screenWidth * screenHeight))
if (blanked) {
animatedPreview?.player?.stop()
@@ -666,9 +719,9 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
}
blendLocked(gray, surface)
var dim: Int = dimForLocked(surface)
selections.addAll(placedSelectionsLocked(surface))
for (draw in surface.draws) {
val selected = draw.selection
if (selected != null) { selections.add(selected.translated(surface.x, surface.y)); continue }
if (draw.selection != null) continue
if (((dim < 256) && (draw.kind == ScreenDraw.KIND_IMAGE))) {
continue
}
@@ -710,8 +763,16 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
}
}
val screenDepth = screenDepthLocked(ordered)
val scene = if (surfaces.values.any { it.visible && it.zOrder > 1 }) ShellScene(emptyList(), screenDepth = screenDepth)
else ShellScene(shellScene?.layers ?: emptyList(), selections, screenDepth)
val overlaid = surfaces.values.any { it.visible && it.zOrder > 1 }
val sceneLayers = if (overlaid) emptyList() else shellScene?.layers ?: emptyList()
val sceneSelections: List<RetainedDrawing> = if (overlaid) emptyList() else selections
// Built per composite, a scene rebuilt its fingerprint and resource lists every time even
// though its inputs (the decoded shell layers, cached placed selections) rarely change.
val previous = lastScene
val scene = if (previous != null && previous.layers === sceneLayers && previous.screenDepth == screenDepth &&
sameElements(previous.selections, sceneSelections)) previous
else ShellScene(sceneLayers, sceneSelections, screenDepth)
lastScene = scene
val sceneKey = fingerprint.append("|shell:").append(scene.fingerprint).toString()
val preview = if (includePreview && (shellScene != null || selections.isNotEmpty())) {
previewScene(scene, gray, sceneKey)
@@ -727,6 +788,22 @@ class SurfaceCompositor @JvmOverloads constructor(private val includePreviewInFr
nextCompositeSeq++, draws.toTypedArray()).also { it.screenGray = gray; it.shellScene = scene }
}
private fun placedSelectionsLocked(surface: Surface): List<RetainedDrawing> {
if (surface.placedFor !== surface.draws || surface.placedX != surface.x || surface.placedY != surface.y) {
surface.placedSelections = surface.draws.mapNotNull { it.selection?.translated(surface.x, surface.y) }
surface.placedFor = surface.draws
surface.placedX = surface.x
surface.placedY = surface.y
}
return surface.placedSelections
}
private fun sameElements(a: List<RetainedDrawing>, b: List<RetainedDrawing>): Boolean {
if (a.size != b.size) return false
for (i in a.indices) if (a[i] !== b[i]) return false
return true
}
private fun blendLocked(gray: ByteArray, surface: Surface): Unit {
var srcX: Int = maxOf(0, -surface.x)
var srcY: Int = maxOf(0, -surface.y)
@@ -268,13 +268,16 @@ class FrameTimingsCore(
get() = lock.withLock { exportDirty }
/** The full export text (does not clear the dirty flag). */
fun buildExport(): String = lock.withLock { buildExportLocked() }
fun buildExport(): String = formatExport(lock.withLock { exportSnapshotLocked() })
/** The export text if anything changed since the last take, else null; clears the dirty flag. */
fun takeExport(): String? = lock.withLock {
if (!exportDirty) return null
exportDirty = false
buildExportLocked()
fun takeExport(): String? {
val snapshot = lock.withLock {
if (!exportDirty) return null
exportDirty = false
exportSnapshotLocked()
}
return formatExport(snapshot)
}
// ---------------------------------------------------------------------
@@ -360,30 +363,72 @@ class FrameTimingsCore(
)
}
private fun buildExportLocked(): String {
/**
* Frame state as of one moment, formatted into the export text outside the lock. Formatting
* the full export takes tens of milliseconds, and holding the lock for it stalled every
* thread recording a span meanwhile, the main thread included.
*/
private class FrameSnapshot(
val id: Int,
val reason: String,
val startedAtMs: Long,
val startedWallClockMs: Long,
val durationMs: Long,
val open: Boolean,
val outcome: String?,
val subtreeEndAtMs: Long,
val subtreeHasOpenFrame: Boolean,
val lines: List<Line>,
val children: List<FrameSnapshot>,
)
private class ExportSnapshot(
val wallClockMs: Long,
val statsSummary: String,
val slowest: List<FrameSnapshot>,
val recent: List<FrameSnapshot>,
)
private fun snapshotLocked(frame: Frame, now: Long): FrameSnapshot = FrameSnapshot(
frame.id, frame.reason, frame.startedAtMs, frame.startedWallClockMs, frame.durationMs(), frame.isOpen(),
frame.outcome, frame.subtreeEndAtMs(now), frame.subtreeHasOpenFrame(), frame.lines.toList(),
frame.children.map { snapshotLocked(it, now) },
)
private fun exportSnapshotLocked(): ExportSnapshot {
val now = platform.elapsedRealtimeMs()
// Stable sort, descending by whole-tree duration (matches Collections.sort).
val treeDurations = HashMap<Frame, Long>()
for (frame in slowestRoots) treeDurations[frame] = frame.subtreeEndAtMs(now) - frame.startedAtMs
slowestRoots.sortWith(compareByDescending { treeDurations.getValue(it) })
while (slowestRoots.size > SLOWEST_ROOTS_KEPT) {
slowestRoots.removeAt(slowestRoots.size - 1)
}
return ExportSnapshot(
wallClockMs(),
statsSummaryLocked(),
slowestRoots.map { snapshotLocked(it, now) },
recentRoots.map { snapshotLocked(it, now) },
)
}
private fun formatExport(snapshot: ExportSnapshot): String {
val out = StringBuilder(64 * 1024)
out.append("FrameTimings export at ").append(formatWallClock(wallClockMs())).append('\n')
out.append(statsSummaryLocked()).append('\n')
out.append("FrameTimings export at ").append(formatWallClock(snapshot.wallClockMs)).append('\n')
out.append(snapshot.statsSummary).append('\n')
out.append('\n')
out.append("Frames are trees: an input event's own frame is the root, and the renders it\n")
out.append("caused are indented under it with offsets measured from the root's start.\n")
out.append('\n')
// Stable sort, descending by whole-tree duration (matches Collections.sort).
slowestRoots.sortWith(compareByDescending { it.subtreeEndAtMs(now) - it.startedAtMs })
while (slowestRoots.size > SLOWEST_ROOTS_KEPT) {
slowestRoots.removeAt(slowestRoots.size - 1)
}
out.append("=== slowest frames that reached the glasses ===\n")
for (frame in slowestRoots) {
appendTreeLocked(out, frame, frame, now)
for (frame in snapshot.slowest) {
appendTree(out, frame, frame, 0)
}
out.append("=== recent frames (oldest first) ===\n")
for (frame in recentRoots) {
appendTreeLocked(out, frame, frame, now)
for (frame in snapshot.recent) {
appendTree(out, frame, frame, 0)
}
return out.toString()
}
@@ -416,28 +461,22 @@ class FrameTimingsCore(
}
/** Print a frame and its descendants, all timed against root's start. */
private fun appendTreeLocked(out: StringBuilder, frame: Frame, root: Frame, now: Long) {
var depth = 0
var walk: Frame? = frame
while (walk !== root) {
depth++
walk = walk!!.parent
}
private fun appendTree(out: StringBuilder, frame: FrameSnapshot, root: FrameSnapshot, depth: Int) {
val indent = " ".repeat(depth)
val startOffsetMs = frame.startedAtMs - root.startedAtMs
out.append(indent).append("frame#").append(frame.id)
.append(" [").append(frame.reason).append(']')
if (frame === root) {
out.append(" started ").append(formatWallClock(frame.startedWallClockMs))
val totalMs = frame.subtreeEndAtMs(now) - frame.startedAtMs
out.append(" duration ").append(frame.durationMs()).append("ms")
val totalMs = frame.subtreeEndAtMs - frame.startedAtMs
out.append(" duration ").append(frame.durationMs).append("ms")
if (frame.children.isNotEmpty()) {
out.append(" (tree ").append(totalMs).append("ms")
.append(if (frame.subtreeHasOpenFrame()) ", still open" else "").append(')')
.append(if (frame.subtreeHasOpenFrame) ", still open" else "").append(')')
}
} else {
out.append(" started +").append(startOffsetMs).append("ms")
.append(" duration ").append(if (frame.isOpen()) "open" else (frame.durationMs().toString() + "ms"))
.append(" duration ").append(if (frame.open) "open" else (frame.durationMs.toString() + "ms"))
}
out.append(" outcome ").append(frame.outcome ?: "(open)").append('\n')
for (line in frame.lines) {
@@ -445,7 +484,7 @@ class FrameTimingsCore(
.append("ms [").append(line.thread).append("] ").append(line.message).append('\n')
}
for (child in frame.children) {
appendTreeLocked(out, child, root, now)
appendTree(out, child, root, depth + 1)
}
}
}
@@ -97,6 +97,46 @@ class SharedGraphicsTest {
assertContentEquals(byteArrayOf(-56, -56, 0, -56, -56, 0), c.composite().gray)
}
@Test
fun surfaceIsCurrentOnlyAfterItsContentAndEveryChangeWasComposited() {
val c = SurfaceCompositor()
c.configureScreen(3, 2)
c.configureSurface("app", 0, 0, 3, 2, 0, 0)
assertFalse(c.isSurfaceCurrent("app", ""))
c.applyAndComposite("app", ArrayByteReader(ByteArray(6) { 200.toByte() }), 0, 0, 3, 2, "a")
assertTrue(c.isSurfaceCurrent("app", "a"))
assertFalse(c.isSurfaceCurrent("app", "b"))
assertFalse(c.isSurfaceCurrent("missing", "a"))
// A preview composite is not kept, so it does not apply pending changes.
c.setUnderlayDim(1, 128)
assertFalse(c.isSurfaceCurrent("app", "a"))
c.previewComposite()
assertFalse(c.isSurfaceCurrent("app", "a"))
c.composite()
assertTrue(c.isSurfaceCurrent("app", "a"))
for (change in listOf<() -> Unit>(
{ c.configureSurface("app", 1, 0, 3, 2, 0, 0) },
{ c.setSurfaceVisible("app", false) },
{ c.setSurfaceDepth("app", 2) },
{ c.setBlanked(false) },
{ c.removeSurface("other") },
)) {
change()
assertFalse(c.isSurfaceCurrent("app", "a"))
c.composite()
assertTrue(c.isSurfaceCurrent("app", "a"))
}
// Submitting without compositing retains the content but leaves it unapplied.
c.submitSurface("app", ArrayByteReader(ByteArray(6)), 0, 0, 3, 2, "b")
assertFalse(c.isSurfaceCurrent("app", "b"))
c.composite()
assertTrue(c.isSurfaceCurrent("app", "b"))
// A resize discards the retained content.
c.configureSurface("app", 0, 0, 2, 2, 0, 0)
c.composite()
assertFalse(c.isSurfaceCurrent("app", "b"))
}
@Test
fun pngChunksAndPixels() {
val png = SharedScreenshots.encode4BitGrayPng(byteArrayOf(0, 16, -1, 32, 48, 64), 3, 2)