Clean up unused code

Mostly remnants of iOS porting, where some things were temporarily in
typescript but became shared kotlin
This commit is contained in:
James Babcock committed 2026-09-30 13:54:50 -07:00
1 parent 2c088378bd
commit 7d8f03ffe5
18 files changed
+66 -644

No files matched your search

-80
View File
@@ -1,80 +0,0 @@
import { type RingInput } from "./ring-input";
import { type CompassEvent } from '../native/compass-types'
/** iOS binary bridge to the same Kotlin protocol used by Android. */
import { fromData, toData, nativeArray } from '../native/kotlin-data'
import { OsEventTypeList } from './events'
declare const FaceclawKitIosProtocol: any, FaceclawKitIosMessageReceiver: any
const protocol = FaceclawKitIosProtocol.new()
export const G2_WRITE = '00002760-08c2-11e1-9073-0e8ac72e5401'
export const G2_NOTIFY = '00002760-08c2-11e1-9073-0e8ac72e5402'
export const G2_RENDER_NOTIFY = '00002760-08c2-11e1-9073-0e8ac72e6402'
export const RING_NOTIFY = ['bae80011-4f05-4503-8e65-3af1f7329d1f', 'bae80013-4f05-4503-8e65-3af1f7329d1f']
export const SID = { auth: 0x80, launch: 1, hub: 0xe0, settings: 9, cfw: 0xf0 } as const
export function concat(...parts: Uint8Array[]): Uint8Array {
const output = new Uint8Array(parts.reduce((n, p) => n + p.length, 0))
let offset = 0
for (const part of parts) { output.set(part, offset); offset += part.length }
return output
}
export const integer = (field: number, value: number): Uint8Array => fromData(protocol.integerFieldValue(field, value))
export const bytes = (field: number, value: Uint8Array): Uint8Array => fromData(protocol.bytesFieldData(field, toData(value)))
export const authentication = (magic: number) => fromData(protocol.authenticationMagic(magic))
export const prelude = () => fromData(protocol.prelude())
export const heartbeat = (magic: number) => fromData(protocol.heartbeatMagic(magic))
export const audioControl = (magic: number, enabled: boolean) => fromData(protocol.audioControlMagicEnabled(magic, enabled))
export const settingsQuery = (magic: number) => fromData(protocol.settingsQueryMagic(magic))
export const shutdown = (magic: number) => fromData(protocol.shutdownMagic(magic))
export const framebufferLease = (acquire: boolean) => fromData(protocol.framebufferLeaseAcquire(acquire))
export const createLayout = (magic: number) => fromData(protocol.createLayoutMagic(magic))
export const crc16 = (data: Uint8Array): number => protocol.crcData(toData(data))
export function frameMessage(payload: Uint8Array, sid: number, flag: number, sequence: number, maxWrite = 240): Uint8Array[] {
const capacity = Math.min(232, Math.floor(maxWrite) - 8)
if (capacity < 12 || !Number.isFinite(capacity)) throw new Error('Negotiated BLE write size is too small')
if (Math.ceil((payload.length + 2) / capacity) > 255) throw new Error('Protocol message exceeds the fragment limit')
return nativeArray(protocol.frameDataSidFlagSequenceMaxWrite(toData(payload), sid, flag, sequence, Math.floor(maxWrite)), fromData)
}
export type ProtocolMessage = { sid: number; flag: number; payload: Uint8Array; command: number; magic: number; packet?: Uint8Array }
export class MessageReceiver {
private native = FaceclawKitIosMessageReceiver.new()
clear(): void { this.native.clear() }
receive(link: string, data: Uint8Array, now = Date.now()): ProtocolMessage[] {
return nativeArray(this.native.receiveLinkDataNow(link, toData(data), now), (message: any) => ({
sid: message.sid, flag: message.flag, payload: fromData(message.payload), command: message.command,
magic: message.magic, ...(message.packet ? { packet: fromData(message.packet) } : {}),
}))
}
}
export const readInteger = (data: Uint8Array, field: number, fallback = 0): number => protocol.readIntegerDataFieldFallback(toData(data), field, fallback)
export const readBytes = (data: Uint8Array, field: number): Uint8Array | undefined => {
const value = protocol.readBytesDataField(toData(data), field)
return value ? fromData(value) : undefined
}
export const readString = (data: Uint8Array, field: number): string => protocol.readStringDataField(toData(data), field)
export function authenticationSucceeded(message: ProtocolMessage, magic: number): boolean {
return message.sid === SID.auth && message.command === 4 && message.magic === magic && readBytes(message.payload, 3)?.length === 0
}
export type GlassesInput = { ringInput?: RingInput; kind: 'sys-event' | 'list-click' | 'text-click' | 'display-wake' | 'even-ai'; eventType: number; eventSource: number; systemExitReasonCode: number; containerName: string; frameId: number }
function input(event: any): GlassesInput | null {
return event ? { kind: event.kind === 'sys-event' && event.eventType === OsEventTypeList.HEAD_UP_EVENT ? 'display-wake' : event.kind,
eventType: event.eventType, eventSource: event.eventSource, systemExitReasonCode: event.systemExitReasonCode,
ringInput: Number(event.ringTick) >= 0 ? { tick: Number(event.ringTick), type: Number(event.ringType),
aux: Number(event.ringAux), speed: Number(event.ringSpeed) } : undefined,
containerName: event.containerName, frameId: 0 } : null
}
export const decodeGlassesInput = (message: ProtocolMessage): GlassesInput | null => input(protocol.glassesInputDataSidFlag(toData(message.payload), message.sid, message.flag))
export const decodeRingInput = (data: Uint8Array): GlassesInput | null => input(protocol.ringInputData(toData(data)))
export function packGray4(gray: Uint8Array, width: number, height: number): Uint8Array {
if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || gray.length !== width * height) throw new Error('Invalid display frame')
return fromData(protocol.packDataWidthHeight(toData(gray), width, height))
}
export const rle4 = (packed: Uint8Array): Uint8Array => fromData(protocol.rleData(toData(packed)))
export function decodeCompassInput(message: ProtocolMessage): CompassEvent | null {
const event = protocol.compassInputDataSidFlag(toData(message.payload), message.sid, message.flag)
return event ? { command: event.command, headingDegrees: event.headingDegrees,
...(event.diagnosticFlags >= 0 ? { diagnostics: {
magneticAccuracy: event.magneticAccuracy, magneticAnomalies: event.magneticAnomalies,
orientationSource: event.orientationSource, flags: event.diagnosticFlags, sampleTimeMs: Number(event.sampleTimeMs),
} } : {}),
} : null
}
-53
View File
@@ -1,53 +0,0 @@
/** Reader for the bundled Source Han Sans serialized LVGL font. Matches
* Android LvglFontFile's metrics/glyph byte format, without a Java dependency. */
export class LvglFont {
readonly metrics: Uint8Array
private readonly view: DataView
private readonly ids = new Map<number, number>()
private readonly bitmaps: number
private readonly descriptors: number
constructor(private readonly bytes: Uint8Array) {
this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
if (bytes.length < 64 || bytes.slice(0, 4).some(v => v !== 90)) throw new Error('Missing LVGL font header')
const height = this.u16(0x38), baseline = height - this.u16(0x3a)
const descriptor = this.pointer(this.u32(0x34))
this.bitmaps = this.pointer(this.u32(descriptor)); this.descriptors = this.pointer(this.u32(descriptor + 4))
const cmaps = this.pointer(this.u32(descriptor + 8)), packed = this.u16(descriptor + 18), count = packed & 0x1ff
if (!height || baseline < 0 || !count || ((packed >>> 9) & 15) !== 4 || (packed >>> 14) !== 3) throw new Error('Unsupported LVGL font')
this.metrics = new Uint8Array([height, baseline])
for (let i = 0; i < count; i++) {
const at = cmaps + i * 20, start = this.u32(at), length = this.u16(at + 4), first = this.u16(at + 6)
const unicodePtr = this.u32(at + 8), offsetsPtr = this.u32(at + 12), listLength = this.u16(at + 16), type = this.u8(at + 18)
if (type === 2 || type === 0) {
const offsets = type === 0 ? this.pointer(offsetsPtr) : 0
for (let n = 0; n < length; n++) {
const offset = type === 0 ? this.u8(offsets + n) : n
if (n && !offset) continue
this.ids.set(start + n, first + offset)
}
} else if (type === 1 || type === 3) {
const unicode = this.pointer(unicodePtr), offsets = offsetsPtr ? this.pointer(offsetsPtr) : -1
for (let n = 0; n < listLength; n++) {
const offset = offsets < 0 ? n : type === 1 ? this.u16(offsets + n * 2) : this.u8(offsets + n)
if (n && !offset) continue
this.ids.set(start + this.u16(unicode + n * 2), first + offset)
}
} else throw new Error('Unsupported LVGL cmap')
}
}
glyph(codePoint: number): Uint8Array {
const id = this.ids.get(codePoint)
if (!id) return new Uint8Array()
const at = this.descriptors + id * 16, bitmap = this.bitmaps + this.u32(at)
const width = this.u16(at + 8), height = this.u16(at + 10), length = width && height ? (Math.floor(width / 2) + 1) * height : 0
this.check(bitmap, length)
const result = new Uint8Array(8 + length)
result.set(this.bytes.subarray(at + 8, at + 16)); result.set(this.bytes.subarray(bitmap, bitmap + length), 8)
return result
}
private check(at: number, size: number): void { if (at < 0 || at + size > this.bytes.length) throw new Error('Truncated LVGL font') }
private pointer(address: number): number { const at = address - 0x80100000; this.check(at, 1); return at }
private u8(at: number): number { this.check(at, 1); return this.bytes[at] }
private u16(at: number): number { return this.view.getUint16(at, true) }
private u32(at: number): number { return this.view.getUint32(at, true) }
}
+5 -2
View File
@@ -1,6 +1,9 @@
import { fromData, toData } from '../native/kotlin-data'
import type { SurfaceConfiguration, SurfaceRect } from './surface-compositor'
export type { SurfaceConfiguration, SurfaceRect } from './surface-compositor'
export type SurfaceRect = { x: number; y: number; width: number; height: number }
export type SurfaceConfiguration = SurfaceRect & {
zOrder: number
transparency: 'opaque' | 'color-key'
}
declare const FaceclawKitIosSurfaceCompositor: any
/** Retained pixels, clipping, layers and composition live in shared Kotlin. */
export class SurfaceCompositor {
-103
View File
@@ -1,103 +0,0 @@
import { presentationRecords, readPresentation, paintPresentation, type Selection } from "./presentation-wire"
/** Platform-independent 8bpp surface composition for the local display. */
export type SurfaceRect = { x: number; y: number; width: number; height: number }
export type SurfaceConfiguration = SurfaceRect & {
zOrder: number
transparency: 'opaque' | 'color-key'
}
type Surface = SurfaceConfiguration & { pixels: Uint8Array; visible: boolean; selections: Selection[] }
export class SurfaceCompositor {
private readonly surfaces = new Map<string, Surface>()
private shellScene: Uint8Array | null = null
private shellReceivedAt = 0
setShellScene(bytes: Uint8Array): void { this.shellScene = new Uint8Array(bytes); this.shellReceivedAt = Date.now() }
private dimBelow = 0
private dimFactor = 1
private blanked = false
constructor(readonly width: number, readonly height: number) {
if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
throw new Error('Invalid compositor size')
}
}
configureSurface(id: string, options: SurfaceConfiguration): void {
if (![options.x, options.y, options.width, options.height, options.zOrder].every(Number.isInteger)
|| options.width <= 0 || options.height <= 0) throw new Error('Invalid surface geometry')
const previous = this.surfaces.get(id)
const pixels = previous?.width === options.width && previous.height === options.height
? previous.pixels : new Uint8Array(options.width * options.height)
this.surfaces.set(id, { ...options, pixels, visible: previous?.visible ?? true, selections: previous?.selections ?? [] })
}
removeSurface(id: string): void { this.surfaces.delete(id) }
setSurfaceVisible(id: string, visible: boolean): void {
const surface = this.surfaces.get(id)
if (surface) surface.visible = visible
}
/** Stereo depth only shifts the lenses; this local composite shows the unshifted screen. */
setSurfaceDepth(_id: string, _depth: number): void {}
setUnderlayDim(belowZOrder: number, factor: number): void {
if (!Number.isFinite(factor)) throw new Error('Invalid dim factor')
this.dimBelow = belowZOrder
this.dimFactor = Math.max(0, Math.min(1, factor))
}
setScreenBlanked(blanked: boolean): void { this.blanked = blanked }
submitSurfaceFrame(id: string, pixels: Uint8Array, rect: SurfaceRect, _draws: ArrayBuffer | null = null): void {
const surface = this.surfaces.get(id)
if (!surface) throw new Error(`Unknown surface: ${id}`)
if (![rect.x, rect.y, rect.width, rect.height].every(Number.isInteger)
|| rect.width <= 0 || rect.height <= 0 || pixels.length !== rect.width * rect.height) {
throw new Error('Invalid frame buffer or rectangle')
}
surface.selections = presentationRecords(_draws)
const left = Math.max(0, rect.x), right = Math.min(surface.width, rect.x + rect.width)
const top = Math.max(0, rect.y), bottom = Math.min(surface.height, rect.y + rect.height)
for (let y = top; y < bottom; y++) {
if (right <= left) break
const source = (y - rect.y) * rect.width + left - rect.x
surface.pixels.set(pixels.subarray(source, source + right - left), y * surface.width + left)
}
}
composite(): Uint8Array {
const output = new Uint8Array(this.width * this.height)
if (this.blanked) return output
const surfaces = [...this.surfaces.values()].filter(s => s.visible && !(this.shellScene && s === this.surfaces.get('shell'))).sort((a, b) => a.zOrder - b.zOrder)
for (const surface of surfaces) {
const left = Math.max(0, surface.x), right = Math.min(this.width, surface.x + surface.width)
const top = Math.max(0, surface.y), bottom = Math.min(this.height, surface.y + surface.height)
const dim = !this.shellScene && surface.zOrder < this.dimBelow ? this.dimFactor : 1
for (let y = top; y < bottom; y++) {
let source = (y - surface.y) * surface.width + left - surface.x
let target = y * this.width + left
for (let x = left; x < right; x++, source++, target++) {
const value = surface.pixels[source]
// Test the original value: opaque near-black must still cover the
// window beneath, even when dimming rounds it down to black.
if (surface.transparency === 'color-key' && value === 0) continue
output[target] = Math.round(value * dim)
}
}
}
const screen = output.slice()
if (!surfaces.some(s => s.zOrder > 1) && (this.shellScene || surfaces.some(s => s.selections.length))) {
for(let i=0;i<output.length;i++) output[i]=Math.min(15,(output[i]!+8)>>4)*16
for(const surface of surfaces) for(const row of surface.selections) paintPresentation(output,screen,this.width,this.height,{...row,x:row.x+surface.x,y:row.y+surface.y,occlusions:row.occlusions.map(r=>({...r,x:r.x+surface.x,y:r.y+surface.y}))})
}
if (this.shellScene && !surfaces.some(s => s.zOrder > 1)) {
const quantize = (v: number) => Math.min(15, (v + 8) >> 4)
for (let i=0;i<output.length;i++) output[i]=quantize(output[i])*16
const bytes=this.shellScene, view=new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
let p=2
for(let i=0;i<view.getUint16(0,true);i++) {
const x=view.getInt16(p+2,true), y=view.getInt16(p+4,true), w=view.getUint16(p+6,true), h=view.getUint16(p+8,true), dim=view.getUint16(p+10,true), selections=view.getUint16(p+12,true), shift=Math.floor(view.getInt16(p+14,true)/2)
p+=16
if(dim<256) for(let j=0;j<output.length;j++) output[j]=Math.floor((output[j]/16)*dim/256)*16
for(let yy=0;yy<h;yy++) for(let xx=0;xx<w;xx++) {
if(x+xx+shift>=0 && y+yy>=0 && x+xx+shift<this.width && y+yy<this.height) output[(y+yy)*this.width+x+xx+shift]=quantize(bytes[p+yy*w+xx])*16
}
p+=w*h
for(let j=0;j<selections;j++) { const record=readPresentation(bytes,p);p=record.end;if(record.selection.displayList?.timeline) record.selection.displayList = { ...record.selection.displayList, presentedAt: this.shellReceivedAt, timeline: { ...record.selection.displayList.timeline, startedAt: record.selection.displayList.timeline.startedAt - (Date.now()-this.shellReceivedAt) } };paintPresentation(output,screen,this.width,this.height,record.selection) }
}
}
return output
}
}
-33
View File
@@ -1,33 +0,0 @@
import type { KotlinBridge } from './kotlin-platform';
// Handwritten declarations for the small native surface, checked against the
// compiled API. NativeScript runtime metadata is generated from the AAR.
declare namespace com.faceclaw.shared {
// Used as com.faceclaw.shared.KotlinBridge; oxlint misses qualified references.
// oxlint-disable-next-line no-unused-vars
class KotlinBridge extends java.lang.Object {
constructor();
platform(): string;
threadName(): string;
isMainThread(): boolean;
greet(name: string): string;
roundTrip(message: string, listener: KotlinBridgeListener): string;
}
class KotlinBridgeListener extends java.lang.Object {
constructor(implementation: { transform(message: string): string });
}
}
export function createKotlinBridge(): KotlinBridge {
const bridge = new com.faceclaw.shared.KotlinBridge();
return {
platform: () => bridge.platform(),
threadName: () => bridge.threadName(),
isMainThread: () => bridge.isMainThread(),
greet: name => bridge.greet(name),
roundTrip(message, transform) {
const listener = new com.faceclaw.shared.KotlinBridgeListener({ transform });
return bridge.roundTrip(message, listener);
},
};
}
-11
View File
@@ -1,11 +0,0 @@
/** Exported native API normalized across Java interfaces and Obj-C protocols. */
export interface KotlinBridge {
platform(): string;
threadName(): string;
isMainThread(): boolean;
greet(name: string): string;
/** Synchronous callback; must not throw across the native boundary. */
roundTrip(message: string, transform: (message: string) => string): string;
}
export function createKotlinBridge(): KotlinBridge;
-42
View File
@@ -1,42 +0,0 @@
import type { KotlinBridge } from './kotlin-platform';
// Handwritten declarations matching FaceclawKit's Objective-C header.
declare class FaceclawKitKotlinBridge extends NSObject {
static alloc(): FaceclawKitKotlinBridge;
init(): this;
platform(): string;
threadName(): string;
isMainThread(): boolean;
greetName(name: string): string;
roundTripMessageListener(message: string, listener: FaceclawKitKotlinBridgeListener): string;
}
interface FaceclawKitKotlinBridgeListener {
transformMessage(message: string): string;
}
declare const FaceclawKitKotlinBridgeListener: {
prototype: FaceclawKitKotlinBridgeListener;
};
@NativeClass()
class KotlinCallback extends NSObject implements FaceclawKitKotlinBridgeListener {
static ObjCProtocols = [FaceclawKitKotlinBridgeListener];
transform!: (message: string) => string;
transformMessage(message: string): string { return this.transform(message); }
}
export function createKotlinBridge(): KotlinBridge {
const bridge = FaceclawKitKotlinBridge.alloc().init();
return {
platform: () => bridge.platform(),
threadName: () => bridge.threadName(),
isMainThread: () => bridge.isMainThread(),
greet: name => bridge.greetName(name),
roundTrip(message, transform) {
const listener = KotlinCallback.new() as KotlinCallback;
listener.transform = transform;
// Kotlin uses this listener synchronously and never retains it.
return bridge.roundTripMessageListener(message, listener);
},
};
}
+1 -1
View File
@@ -1,5 +1,5 @@
import { File, knownFolders, path, type ImageSource } from "@nativescript/core";
import { SurfaceCompositor } from "../graphics/surface-compositor";
import { SurfaceCompositor } from "../graphics/surface-compositor.ios";
import { G2_LENS_WIDTH, G2_LENS_HEIGHT } from "../graphics/image";
import { previewPixels } from "./ios-graphics";
import { toData } from "./kotlin-data";
-42
View File
@@ -1,42 +0,0 @@
import { Utils } from "@nativescript/core";
import { GrayImage } from "../graphics/image";
import { spanCurrent } from "./frame-timings";
import { toUint8Array } from "~/util/array-util";
declare const com: any;
const ICON_SIZE = 24;
const ICON_CACHE_MS = 5_000;
let cachedIcons: GrayImage[] = [];
let cachedAtMs = 0;
export function readSystemStatusIcons(): GrayImage[] {
if (!global.isAndroid) return [];
const now = Date.now();
if (now - cachedAtMs < ICON_CACHE_MS) {
return cachedIcons.map(cachedIcon => cachedIcon.clone());
}
const context = Utils.android.getApplicationContext();
if (!context) return [];
const bytes = spanCurrent("fetch-system-status-icons", () =>
toUint8Array(
com.faceclaw.app.FaceclawSystemStatusIconProvider.getSystemStatusIconGrays(context, ICON_SIZE),
),
);
const iconByteLength = ICON_SIZE * ICON_SIZE;
const iconCount = Math.floor(bytes.length / iconByteLength);
const icons: GrayImage[] = [];
for (let index = 0; index < iconCount; index++) {
const icon = new GrayImage(ICON_SIZE, ICON_SIZE, 0);
icon.pixels.set(bytes.subarray(index * iconByteLength, (index + 1) * iconByteLength));
icons.push(icon);
}
cachedIcons = icons;
cachedAtMs = now;
return icons.map(icon => icon.clone());
}