forked from Blendman974/faceclaw
Merge main into ios-port and update the iOS CFW transport
This commit is contained in:
commit
e8e144f3f2
156 files changed
+10528
-1679
No files matched your search
+19
@@ -0,0 +1,19 @@
|
||||
package com.faceclaw.app;
|
||||
|
||||
/** Production Android encoder oracle for the iOS transport parity test. */
|
||||
public final class CfwTransportVectors {
|
||||
public static void main(String[] args) {
|
||||
CfwTransport transport = new CfwTransport();
|
||||
for (String line : args) {
|
||||
String[] fields = line.split(":", -1);
|
||||
if (fields[0].equals("reset")) { transport.reset(); continue; }
|
||||
int id = Integer.parseInt(fields[0]), lenses = Integer.parseInt(fields[1]);
|
||||
int maxWrite = Integer.parseInt(fields[2]);
|
||||
byte[] payload = java.util.HexFormat.of().parseHex(fields[3]);
|
||||
StringBuilder result = new StringBuilder();
|
||||
for (byte[] packet : transport.encode(payload, id, lenses, maxWrite + 3))
|
||||
result.append(java.util.HexFormat.of().formatHex(packet)).append(" ");
|
||||
System.out.println(result.toString().trim());
|
||||
}
|
||||
}
|
||||
}
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
package com.faceclaw.app;
|
||||
import java.util.Arrays;
|
||||
|
||||
public class FaceclawGestureEventTest {
|
||||
private static byte[] hex(String value) {
|
||||
byte[] result = new byte[value.length() / 2];
|
||||
for (int i = 0; i < result.length; ++i)
|
||||
result[i] = (byte)Integer.parseInt(value.substring(i * 2, i * 2 + 2), 16);
|
||||
return result;
|
||||
}
|
||||
private static byte[] pb(byte[] payload) {
|
||||
byte[] frame = BleProtocol.framePb(payload, 9, BleProtocol.FLAG_NOTIFY, 15).get(0);
|
||||
return BleProtocol.parseFrame(frame).pb;
|
||||
}
|
||||
/** G2SettingPackage{commandId=3, magic=0, field102=['F','C',1,event,source,0]}: the CFW's wire shape. */
|
||||
private static byte[] packet(int event, int source) {
|
||||
byte[] p = hex("08031000b20606464301000000");
|
||||
p[10] = (byte)event; p[11] = (byte)source;
|
||||
return p;
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
// Event codes map to the sys-events a live page would produce.
|
||||
int[][] events = {
|
||||
{2, BleProtocol.EVENT_CLICK},
|
||||
{3, BleProtocol.EVENT_RING_LONG_PRESS},
|
||||
{4, BleProtocol.EVENT_RING_LONG_PRESS_RELEASE},
|
||||
};
|
||||
int[][] sources = {
|
||||
{0, BleProtocol.EVENT_SOURCE_GLASSES_L},
|
||||
{1, BleProtocol.EVENT_SOURCE_GLASSES_R},
|
||||
{4, BleProtocol.EVENT_SOURCE_RING},
|
||||
{7, 0},
|
||||
};
|
||||
for (int[] e : events) for (int[] s : sources) {
|
||||
BleProtocol.FaceclawGestureEvent g = BleProtocol.parseFaceclawGestureEvent(pb(packet(e[0], s[0])));
|
||||
assert g != null && g.eventType == e[1] && g.eventSource == s[1] : e[0] + "/" + s[0];
|
||||
}
|
||||
// The double-tap wake event (1) and unknown codes are not gestures, and the
|
||||
// wake parser does not mistake a gesture for a wake.
|
||||
byte[] wake = packet(1, 0x34); wake[12] = 0x12;
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(wake)) == null;
|
||||
assert BleProtocol.parseFaceclawWakeEvent(pb(wake)) == 0x1234;
|
||||
assert BleProtocol.parseFaceclawWakeEventCode(pb(wake)) == 1;
|
||||
// The head-up wake (5) shares the nonce handshake but keeps its own code.
|
||||
byte[] headUp = packet(5, 0x34); headUp[12] = 0x12;
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(headUp)) == null;
|
||||
assert BleProtocol.parseFaceclawWakeEvent(pb(headUp)) == 0x1234;
|
||||
assert BleProtocol.parseFaceclawWakeEventCode(pb(headUp)) == BleProtocol.FACECLAW_WAKE_EVENT_HEAD_UP;
|
||||
for (int code : new int[] {2, 3, 4, 6}) {
|
||||
assert BleProtocol.parseFaceclawWakeEvent(pb(packet(code, 1))) == -1;
|
||||
assert BleProtocol.parseFaceclawWakeEventCode(pb(packet(code, 1))) == -1;
|
||||
}
|
||||
for (int code : new int[] {0, 5, 6, 255})
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(packet(code, 1))) == null;
|
||||
// Wrong protocol version, wrong magic letters, truncated payloads, plain settings.
|
||||
byte[] bad = packet(2, 1); bad[9] = 2;
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(bad)) == null;
|
||||
bad = packet(2, 1); bad[7] = 'X';
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(bad)) == null;
|
||||
byte[] full = packet(2, 1);
|
||||
for (int n = 0; n < full.length; ++n)
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(Arrays.copyOf(full, n))) == null : n;
|
||||
assert BleProtocol.parseFaceclawGestureEvent(pb(hex("08031000"))) == null;
|
||||
assert BleProtocol.parseFaceclawGestureEvent(null) == null;
|
||||
System.out.println("FaceclawGestureEventTest ok");
|
||||
}
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
package com.faceclaw.app;
|
||||
import java.util.Arrays;
|
||||
|
||||
public class RingBatteryProtocolTest {
|
||||
private static byte[] hex(String value) {
|
||||
byte[] result = new byte[value.length() / 2];
|
||||
for (int i = 0; i < result.length; ++i)
|
||||
result[i] = (byte)Integer.parseInt(value.substring(i * 2, i * 2 + 2), 16);
|
||||
return result;
|
||||
}
|
||||
private static BleProtocol.RingBatterySnapshot parse(byte[] payload) {
|
||||
byte[] frame = BleProtocol.framePb(payload, 9, BleProtocol.FLAG_NOTIFY, 15).get(0);
|
||||
return BleProtocol.parseRingBattery(BleProtocol.parseFrame(frame).pb);
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
// Same golden payload as g2flash/tests/ring_battery_test.c.
|
||||
byte[] packet = hex("08031000d206055242010752");
|
||||
BleProtocol.RingBatterySnapshot result = parse(packet);
|
||||
assert result.battery == 82 && result.charging == 1;
|
||||
packet[10] = 3;
|
||||
for (int level = 0; level <= 100; ++level) {
|
||||
packet[11] = (byte)level;
|
||||
result = parse(packet);
|
||||
assert result.battery == level && result.charging == 0;
|
||||
}
|
||||
for (int flags : new int[] {0, 1}) {
|
||||
packet[10] = (byte)flags; packet[11] = (byte)255;
|
||||
result = parse(packet);
|
||||
assert result.battery == -1 && result.charging == -1;
|
||||
}
|
||||
packet = hex("08031000d206055242010752");
|
||||
for (int n = 0; n < packet.length; ++n)
|
||||
assert parse(Arrays.copyOf(packet, n)) == null;
|
||||
for (int offset : new int[] {7, 8, 9, 10, 11}) {
|
||||
byte previous = packet[offset]; packet[offset] = (byte)255;
|
||||
assert parse(packet) == null;
|
||||
packet[offset] = previous;
|
||||
}
|
||||
assert parse(hex("08031000")) == null; // older firmware
|
||||
assert parse(hex("d206055242010252")) == null; // valid without connected
|
||||
assert parse(hex("d206055242010352")).battery == 82;
|
||||
assert parse(hex("d2060552420100ff")).battery == -1;
|
||||
// Invalid unknown value and charging-without-valid must be rejected.
|
||||
assert parse(hex("d206055242010052")) == null;
|
||||
assert parse(hex("d2060552420105ff")) == null;
|
||||
assert parse(hex("d206055242010364")).battery == 100;
|
||||
assert parse(hex("d206055242010365")) == null;
|
||||
assert BleProtocol.parseRingBattery(null) == null;
|
||||
}
|
||||
}
|
||||
+58
@@ -0,0 +1,58 @@
|
||||
package com.faceclaw.app;
|
||||
|
||||
import java.lang.reflect.*;
|
||||
import java.util.*;
|
||||
|
||||
public class TextureCacheProtocolTest {
|
||||
static int u16(byte[] b, int p) { return (b[p]&255) | (b[p+1]&255)<<8; }
|
||||
static int u32(byte[] b, int p) { return u16(b,p) | u16(b,p+2)<<16; }
|
||||
public static void main(String[] args) throws Exception {
|
||||
TextureCacheState cache = new TextureCacheState();
|
||||
byte[] pixels = new byte[255*255];
|
||||
for (int i=0;i<pixels.length;i++) pixels[i]=(byte)(i%15+1);
|
||||
ImageAtlas.Entry big = new ImageAtlas.Entry(255,255,pixels);
|
||||
for (int i=0;i<3;i++) assert cache.ensureImage(i,big)>=0;
|
||||
ImageAtlas.Entry tiny = new ImageAtlas.Entry(1,1,new byte[]{15});
|
||||
int imageOffset = cache.ensureImage(100,tiny);
|
||||
assert imageOffset>65535;
|
||||
GlyphAtlas.Glyph glyph = new GlyphAtlas.Glyph(1,1,0,1,0,null,new byte[]{15});
|
||||
int glyphOffset = cache.ensureGlyph(42,'A',glyph);
|
||||
int table = cache.fontTableOffset(42);
|
||||
assert table>65535 && glyphOffset==table+96*4;
|
||||
byte[] memory = new byte[262144];
|
||||
for (byte[] upload: cache.drainUploadPayloads(3600)) {
|
||||
assert upload[0]==18;
|
||||
int pos=1;
|
||||
while (pos<upload.length) {
|
||||
int offset=u32(upload,pos), n=u16(upload,pos+4);
|
||||
System.arraycopy(upload,pos+6,memory,offset,n); pos+=6+n;
|
||||
}
|
||||
assert pos==upload.length;
|
||||
}
|
||||
assert memory[imageOffset]==1 && memory[imageOffset+2]==0x1f;
|
||||
assert u32(memory,table+('A'-32)*4)==glyphOffset;
|
||||
assert !cache.hasPendingUploads();
|
||||
// Exercise the production planner encoders with offsets above 64 KiB.
|
||||
Class<?> selected=Class.forName("com.faceclaw.app.TexturePlanner$Selected");
|
||||
Constructor<?> ctor=selected.getDeclaredConstructors()[0]; ctor.setAccessible(true);
|
||||
Object image=ctor.newInstance(SurfaceCompositor.ScreenDraw.image(100,321,123),null,tiny,321,15);
|
||||
Method encode=TexturePlanner.class.getDeclaredMethod("encodeImageDraw",TextureCacheState.class,selected);
|
||||
encode.setAccessible(true);
|
||||
byte[] draw=(byte[])encode.invoke(null,cache,image);
|
||||
assert draw.length==10 && draw[0]==19 && u32(draw,1)==imageOffset;
|
||||
assert u16(draw,5)==321 && u16(draw,7)==123 && draw[9]==31;
|
||||
Object letter=ctor.newInstance(SurfaceCompositor.ScreenDraw.glyph(42,'A',321,123,255),glyph,null,321,15);
|
||||
Method runs=TexturePlanner.class.getDeclaredMethod("buildRuns",TextureCacheState.class,List.class,List.class);
|
||||
runs.setAccessible(true); List<byte[]> out=new ArrayList<>();
|
||||
runs.invoke(null,cache,Collections.singletonList(letter),out);
|
||||
byte[] run=out.get(0);
|
||||
assert run.length==12 && run[0]==20 && u32(run,1)==table;
|
||||
assert u16(run,5)==321 && u16(run,7)==123 && run[9]==31 && run[10]==1 && run[11]=='A';
|
||||
int id=200;
|
||||
while (cache.ensureImage(id++,big)>=0) {}
|
||||
int before=cache.usedBytes();
|
||||
assert cache.ensureImage(id,big)==-1 && cache.usedBytes()==before;
|
||||
cache.reset(); assert cache.usedBytes()==0 && !cache.hasPendingUploads();
|
||||
assert cache.ensureImage(id,tiny)==0;
|
||||
}
|
||||
}
|
||||
Vendored
+60
@@ -0,0 +1,60 @@
|
||||
// Execute the production worker, replacing only NativeScript/platform services.
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const vm = require('node:vm');
|
||||
const ts = require('typescript');
|
||||
const root = path.resolve(__dirname, '../..');
|
||||
|
||||
function load(file, modules = {}, extra = '', globals = {}) {
|
||||
const context = { exports: {}, console, ...globals, require: (name) => {
|
||||
if (!(name in modules)) throw new Error(`Unexpected dependency: ${name}`);
|
||||
return modules[name];
|
||||
} };
|
||||
const source = fs.readFileSync(path.join(root, file), 'utf8');
|
||||
vm.runInNewContext(ts.transpileModule(source, {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText + extra, context, { filename: file });
|
||||
return context.exports;
|
||||
}
|
||||
|
||||
const { BdfFont } = load('app/graphics/bdffont.ts', { '@nativescript/core': {} });
|
||||
const font = (size) => BdfFont.parse(fs.readFileSync(path.join(root, `app/fonts/terminus/ter-u${size}n.bdf`), 'utf8'));
|
||||
const fonts = { terminus24: font(24), terminus32: font(32) };
|
||||
const smallFont = font(18);
|
||||
const graphics = load('app/graphics/image.ts', { './textwrap': load('app/graphics/textwrap.ts') });
|
||||
|
||||
module.exports = function worker() {
|
||||
let now = 10000;
|
||||
let highScore = '0';
|
||||
const noop = () => {};
|
||||
const global = { postMessage: noop };
|
||||
const api = load('app/apps/pinball/pinball-app.worker.ts', {
|
||||
'@nativescript/core/globals': {},
|
||||
'../../graphics/image': graphics,
|
||||
'../../graphics/plane': {}, '../../graphics/glyph-wire': {},
|
||||
'../../graphics/bdffont': { getFont: (name) => fonts[name] },
|
||||
'../../graphics/ui-fonts': { getDefaultSmallFont: () => smallFont },
|
||||
'../../native/frame-timings': { finishFrame: noop, logFrame: noop },
|
||||
'../../native/active-display': {},
|
||||
'../../native/settings-store': { getStringSetting: () => highScore, setStringSetting: (_, value) => { highScore = value; } },
|
||||
'../../ui/sound-effects': {},
|
||||
'../../ui/sound-setting': { loadSoundEnabled: () => true, saveSoundEnabled: () => {} },
|
||||
'../../ui/window-menu': { WindowMenu: class { open() {} } },
|
||||
'../../ui/gestures': { directionalFallback: (event) => event, GESTURE_CLICK: '●', GESTURE_DOUBLE_CLICK: '●●', GESTURE_SCROLL: '↕', GESTURE_LONG_PRESS: '—' },
|
||||
'../../util/numeric-util': { clamp: (v, lo, hi) => Math.max(lo, Math.min(hi, v)) },
|
||||
}, `
|
||||
renderAndSubmit = () => {};
|
||||
playSfx = () => {};
|
||||
exports.api = { windows, launchBall, ballDrained, stepPhysics, tick, flip,
|
||||
checkTargets, checkRollovers, collideBumpers, resetGame, paintContent, TARGETS, ROLLOVERS };
|
||||
`, { global, Date: { now: () => now }, setInterval: () => 1, clearInterval: noop }).api;
|
||||
const message = (data) => global.onmessage({ data });
|
||||
message({ type: 'open-window', windowId: 'test', surfaceId: 'test', title: 'Pinball', viewport: { width: 576, height: 260 } });
|
||||
message({ type: 'foreground', windowId: 'test', foreground: true, focused: true });
|
||||
const w = api.windows.get('test');
|
||||
return { ...api, w, message, highScore: () => Number(highScore),
|
||||
input: (type) => message({ type: 'input', windowId: 'test', focused: true, frameId: 1, event: { type } }),
|
||||
advance: (seconds) => { for (let i = 0; i < Math.round(seconds * 120); i++) { now += 1000 / 120; api.stepPhysics(w); } },
|
||||
elapse: (seconds) => { now += seconds * 1000; },
|
||||
};
|
||||
};
|
||||
Reference in new issue
Block a user