iOS porting: core bluetooth communication with the glasses

This commit is contained in:
James Babcock committed 2026-09-05 23:53:13 -07:00
1 parent 99793a37a7
commit 46c93c9421
14 files changed
+1182 -8

No files matched your search

+2
View File
@@ -18,6 +18,8 @@
<string>1</string>
<key>LSRequiresIPhoneOS</key>
<true/>
<key>NSBluetoothAlwaysUsageDescription</key>
<string>Faceclaw uses Bluetooth to connect to your glasses and ring, display your apps, and receive gestures.</string>
<key>UILaunchScreen</key>
<dict/>
<key>UISupportedInterfaceOrientations</key>
+1
View File
@@ -3,3 +3,4 @@ TARGETED_DEVICE_FAMILY = 1;
CODE_SIGN_STYLE = Automatic;
// Select the local signing team in Xcode or pass --teamId to the iOS scripts.
OTHER_LDFLAGS = $(inherited) -framework CoreBluetooth
+13
View File
@@ -0,0 +1,13 @@
#import <Foundation/Foundation.h>
#import <CoreBluetooth/CoreBluetooth.h>
/** Main-queue CoreBluetooth adapter. Protocol and MAC matching live in TS. */
@interface FaceclawBluetooth : NSObject <CBCentralManagerDelegate, CBPeripheralDelegate>
@property (nonatomic, copy) void (^eventHandler)(NSString *json);
- (void)initializeBluetooth;
- (void)scan:(BOOL)enabled;
- (void)connect:(NSString *)identifier requestId:(NSInteger)requestId;
- (void)subscribe:(NSString *)identifier characteristic:(NSString *)uuid requestId:(NSInteger)requestId;
- (void)write:(NSString *)identifier characteristic:(NSString *)uuid data:(NSData *)data requestId:(NSInteger)requestId;
- (void)disconnect:(NSString *)identifier;
@end
+190
View File
@@ -0,0 +1,190 @@
#import "FaceclawBluetooth.h"
@interface FCBPeripheral : NSObject
@property (nonatomic, strong) CBPeripheral *peripheral;
@property (nonatomic, strong) NSMutableDictionary<NSString *, CBCharacteristic *> *characteristics;
@property (nonatomic, strong) NSMutableDictionary<NSString *, NSNumber *> *subscriptions;
@property (nonatomic, strong) NSMutableArray<NSDictionary *> *writes;
@property (nonatomic, strong) NSNumber *connectRequest;
@property (nonatomic) NSInteger pendingServices;
@property (nonatomic) BOOL awaitingWriteResponse;
@end
@implementation FCBPeripheral
- (instancetype)init {
if ((self = [super init])) {
_characteristics = [NSMutableDictionary new]; _subscriptions = [NSMutableDictionary new];
_writes = [NSMutableArray new];
}
return self;
}
@end
@interface FaceclawBluetooth ()
@property (nonatomic, strong) CBCentralManager *central;
@property (nonatomic, strong) NSMutableDictionary<NSString *, FCBPeripheral *> *peers;
@property (nonatomic) BOOL scanRequested;
@end
@implementation FaceclawBluetooth
- (instancetype)init { if ((self = [super init])) _peers = [NSMutableDictionary new]; return self; }
- (void)emit:(NSDictionary *)event {
if (!self.eventHandler) return;
NSData *data = [NSJSONSerialization dataWithJSONObject:event options:0 error:nil];
if (data) self.eventHandler([[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
}
- (void)complete:(NSNumber *)request error:(NSString *)error details:(NSDictionary *)details {
if (!request) return;
NSMutableDictionary *event = [@{ @"kind": @"completion", @"id": request } mutableCopy];
if (error) event[@"error"] = error;
if (details) event[@"details"] = details;
[self emit:event];
}
- (void)initializeBluetooth {
if (!self.central) self.central = [[CBCentralManager alloc] initWithDelegate:self queue:dispatch_get_main_queue()];
else [self centralManagerDidUpdateState:self.central];
}
- (void)scan:(BOOL)enabled {
self.scanRequested = enabled;
if (!enabled) { [self.central stopScan]; return; }
[self initializeBluetooth];
if (self.central.state == CBManagerStatePoweredOn)
[self.central scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey: @YES}];
}
- (void)centralManagerDidUpdateState:(CBCentralManager *)central {
[self emit:@{@"kind": @"state", @"state": @(central.state), @"authorization": @(CBManager.authorization)}];
if (central.state != CBManagerStatePoweredOn) {
for (FCBPeripheral *peer in self.peers.allValues) [self failPeer:peer reason:@"Bluetooth is unavailable"];
} else if (self.scanRequested) {
[central scanForPeripheralsWithServices:nil options:@{CBCentralManagerScanOptionAllowDuplicatesKey: @YES}];
}
}
- (FCBPeripheral *)remember:(CBPeripheral *)peripheral {
NSString *identifier = peripheral.identifier.UUIDString;
FCBPeripheral *peer = self.peers[identifier];
if (!peer) { peer = [FCBPeripheral new]; peer.peripheral = peripheral; self.peers[identifier] = peer; }
peripheral.delegate = self;
return peer;
}
- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisement RSSI:(NSNumber *)RSSI {
[self remember:peripheral];
NSData *data = advertisement[CBAdvertisementDataManufacturerDataKey];
NSMutableString *hex = [NSMutableString new];
const uint8_t *bytes = data.bytes;
for (NSUInteger i = 0; i < data.length; i++) [hex appendFormat:@"%02x", bytes[i]];
[self emit:@{@"kind": @"advertisement", @"identifier": peripheral.identifier.UUIDString,
@"name": advertisement[CBAdvertisementDataLocalNameKey] ?: peripheral.name ?: @"",
@"manufacturerData": hex, @"rssi": RSSI,
@"connectable": advertisement[CBAdvertisementDataIsConnectable] ?: @YES}];
}
- (void)connect:(NSString *)identifier requestId:(NSInteger)requestId {
if (self.central.state != CBManagerStatePoweredOn) { [self complete:@(requestId) error:@"Bluetooth is not ready" details:nil]; return; }
FCBPeripheral *peer = self.peers[identifier.uppercaseString];
if (!peer) {
NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:identifier];
CBPeripheral *peripheral = uuid ? [self.central retrievePeripheralsWithIdentifiers:@[uuid]].firstObject : nil;
if (peripheral) peer = [self remember:peripheral];
}
if (!peer) { [self complete:@(requestId) error:@"Peripheral is unknown; scan for the device first" details:nil]; return; }
if (peer.connectRequest || peer.peripheral.state != CBPeripheralStateDisconnected) {
[self complete:@(requestId) error:@"Peripheral is already connecting or connected" details:nil]; return;
}
[peer.characteristics removeAllObjects]; peer.connectRequest = @(requestId);
[self.central connectPeripheral:peer.peripheral options:nil];
}
- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral {
[peripheral discoverServices:nil];
}
- (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error {
[self failPeer:[self remember:peripheral] reason:error.localizedDescription ?: @"Connection failed"];
}
- (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error {
[self failPeer:[self remember:peripheral] reason:error.localizedDescription ?: @"Disconnected"];
}
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {
FCBPeripheral *peer = [self remember:peripheral];
if (error || !peripheral.services.count) { [self failPeer:peer reason:error.localizedDescription ?: @"No services found"]; return; }
peer.pendingServices = peripheral.services.count;
for (CBService *service in peripheral.services) [peripheral discoverCharacteristics:nil forService:service];
}
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error {
FCBPeripheral *peer = [self remember:peripheral];
if (!peer.connectRequest) return;
if (error) { [self failPeer:peer reason:error.localizedDescription]; return; }
for (CBCharacteristic *characteristic in service.characteristics) peer.characteristics[characteristic.UUID.UUIDString.lowercaseString] = characteristic;
if (--peer.pendingServices == 0) {
NSNumber *request = peer.connectRequest; peer.connectRequest = nil;
[self complete:request error:nil details:@{@"characteristics": peer.characteristics.allKeys,
@"maxWrite": @([peripheral maximumWriteValueLengthForType:CBCharacteristicWriteWithoutResponse])}];
}
}
- (void)subscribe:(NSString *)identifier characteristic:(NSString *)uuid requestId:(NSInteger)requestId {
FCBPeripheral *peer = self.peers[identifier.uppercaseString];
CBCharacteristic *characteristic = peer.characteristics[uuid.lowercaseString];
if (!characteristic || !(characteristic.properties & (CBCharacteristicPropertyNotify | CBCharacteristicPropertyIndicate))) {
[self complete:@(requestId) error:@"Notification characteristic is unavailable" details:nil]; return;
}
if (characteristic.isNotifying) { [self complete:@(requestId) error:nil details:nil]; return; }
if (peer.subscriptions[uuid.lowercaseString]) { [self complete:@(requestId) error:@"Subscription already pending" details:nil]; return; }
peer.subscriptions[uuid.lowercaseString] = @(requestId);
[peer.peripheral setNotifyValue:YES forCharacteristic:characteristic];
}
- (void)peripheral:(CBPeripheral *)peripheral didUpdateNotificationStateForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
FCBPeripheral *peer = [self remember:peripheral]; NSString *key = characteristic.UUID.UUIDString.lowercaseString;
NSNumber *request = peer.subscriptions[key]; [peer.subscriptions removeObjectForKey:key];
[self complete:request error:error.localizedDescription ?: (characteristic.isNotifying ? nil : @"Notifications not enabled") details:nil];
}
- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
if (error) { [self emit:@{@"kind": @"error", @"message": error.localizedDescription}]; return; }
NSMutableString *hex = [NSMutableString new]; NSData *data = characteristic.value; const uint8_t *bytes = data.bytes;
for (NSUInteger i = 0; i < data.length; i++) [hex appendFormat:@"%02x", bytes[i]];
[self emit:@{@"kind": @"notification", @"identifier": peripheral.identifier.UUIDString,
@"characteristic": characteristic.UUID.UUIDString.lowercaseString, @"data": hex}];
}
- (void)write:(NSString *)identifier characteristic:(NSString *)uuid data:(NSData *)data requestId:(NSInteger)requestId {
FCBPeripheral *peer = self.peers[identifier.uppercaseString];
CBCharacteristic *characteristic = peer.characteristics[uuid.lowercaseString];
if (!characteristic || peer.peripheral.state != CBPeripheralStateConnected) {
[self complete:@(requestId) error:@"Write characteristic is disconnected or unavailable" details:nil]; return;
}
CBCharacteristicWriteType type = (characteristic.properties & CBCharacteristicPropertyWriteWithoutResponse)
? CBCharacteristicWriteWithoutResponse : CBCharacteristicWriteWithResponse;
if (!(characteristic.properties & (CBCharacteristicPropertyWriteWithoutResponse | CBCharacteristicPropertyWrite)) ||
data.length > [peer.peripheral maximumWriteValueLengthForType:type]) {
[self complete:@(requestId) error:@"Write exceeds the negotiated BLE payload size or is unsupported" details:nil]; return;
}
if (peer.writes.count >= 256) { [self complete:@(requestId) error:@"Bluetooth write queue is full" details:nil]; return; }
[peer.writes addObject:@{@"id": @(requestId), @"characteristic": characteristic, @"data": [data copy], @"type": @(type)}];
[self drain:peer];
}
- (void)drain:(FCBPeripheral *)peer {
while (peer.writes.count && !peer.awaitingWriteResponse && peer.peripheral.state == CBPeripheralStateConnected) {
NSDictionary *write = peer.writes.firstObject;
CBCharacteristicWriteType type = [write[@"type"] integerValue];
if (type == CBCharacteristicWriteWithoutResponse && !peer.peripheral.canSendWriteWithoutResponse) return;
if (type == CBCharacteristicWriteWithResponse) peer.awaitingWriteResponse = YES;
[peer.peripheral writeValue:write[@"data"] forCharacteristic:write[@"characteristic"] type:type];
if (peer.awaitingWriteResponse) return;
[peer.writes removeObjectAtIndex:0]; [self complete:write[@"id"] error:nil details:nil];
}
}
- (void)peripheralIsReadyToSendWriteWithoutResponse:(CBPeripheral *)peripheral { [self drain:[self remember:peripheral]]; }
- (void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error {
FCBPeripheral *peer = [self remember:peripheral];
if (!peer.awaitingWriteResponse || !peer.writes.count) return;
NSDictionary *write = peer.writes.firstObject; [peer.writes removeObjectAtIndex:0]; peer.awaitingWriteResponse = NO;
[self complete:write[@"id"] error:error.localizedDescription details:nil]; [self drain:peer];
}
- (void)failPeer:(FCBPeripheral *)peer reason:(NSString *)reason {
if (!peer) return;
NSNumber *connect = peer.connectRequest; peer.connectRequest = nil;
[self complete:connect error:reason details:nil];
NSArray *subscriptions = peer.subscriptions.allValues; [peer.subscriptions removeAllObjects];
NSArray *writes = [peer.writes copy]; [peer.writes removeAllObjects]; peer.awaitingWriteResponse = NO;
for (NSNumber *request in subscriptions) [self complete:request error:reason details:nil];
for (NSDictionary *write in writes) [self complete:write[@"id"] error:reason details:nil];
[peer.characteristics removeAllObjects];
if (peer.peripheral.state != CBPeripheralStateDisconnected) [self.central cancelPeripheralConnection:peer.peripheral];
[self emit:@{@"kind": @"disconnected", @"identifier": peer.peripheral.identifier.UUIDString, @"message": reason}];
}
- (void)disconnect:(NSString *)identifier { [self failPeer:self.peers[identifier.uppercaseString] reason:@"Disconnected"]; }
@end
+1
View File
@@ -1,4 +1,5 @@
module FaceclawGraphics {
header "FaceclawGraphics.h"
header "FaceclawBluetooth.h"
export *
}
+178
View File
@@ -0,0 +1,178 @@
/** G2 wire protocol, ported from g2protocol/BleProtocol.java. No platform APIs. */
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 } 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
}
function varint(value: number): Uint8Array {
const bytes: number[] = []
do { const next = value & 127; value >>>= 7; bytes.push(next | (value ? 128 : 0)) } while (value)
return new Uint8Array(bytes)
}
export const integer = (field: number, value: number): Uint8Array => concat(varint(field * 8), varint(value))
export const bytes = (field: number, value: Uint8Array): Uint8Array => concat(varint(field * 8 + 2), varint(value.length), value)
// Outbound names/text here are fixed ASCII protocol identifiers.
const string = (field: number, value: string): Uint8Array => bytes(field, new Uint8Array(Array.from(value, c => c.charCodeAt(0))))
const wrap = (command: number, magic: number, field: number, body: Uint8Array) => concat(integer(1, command), integer(2, magic), bytes(field, body))
export const authentication = (magic: number) => wrap(4, magic, 3, concat(integer(1, 1), integer(2, 4)))
export const prelude = () => wrap(2, 156, 4, bytes(3, bytes(2, bytes(2, concat(integer(1, 0), integer(2, 0))))))
export const heartbeat = (magic: number) => wrap(12, magic, 14, integer(1, 0))
export const settingsQuery = (magic: number) => wrap(2, magic, 4, integer(1, 1))
export const shutdown = (magic: number) => wrap(9, magic, 11, integer(1, 1))
export const framebufferLease = (acquire: boolean) => concat(integer(1, 1), integer(2, 0), bytes(101, new Uint8Array([70, 67, 1, acquire ? 5 : 6, 0, 0])))
export function createLayout(magic: number): Uint8Array {
const geometry = concat(integer(1, 0), integer(2, 0), integer(3, 576), integer(4, 288))
const text = concat(geometry, integer(9, 1), string(10, 'dashboard'), integer(11, 1), string(12, ' '))
const image = concat(geometry, integer(5, 10), string(6, 'img00'))
return wrap(0, magic, 3, concat(integer(1, 2), bytes(3, text), bytes(4, image), integer(5, 10000)))
}
export function imageFragment(magic: number, payload: Uint8Array, offset: number, size = 3800): Uint8Array {
const fragment = payload.subarray(offset, offset + size)
return wrap(3, magic, 5, concat(integer(1, 10), string(2, 'img00'), integer(3, 10), integer(4, payload.length),
integer(5, 0), integer(6, Math.floor(offset / size)), integer(7, fragment.length), bytes(8, fragment)))
}
export function crc16(data: Uint8Array): number {
let crc = 0xffff
for (const byte of data) {
crc ^= byte << 8
for (let i = 0; i < 8; i++) crc = ((crc << 1) ^ ((crc & 0x8000) ? 0x1021 : 0)) & 0xffff
}
return crc
}
export function frameMessage(payload: Uint8Array, sid: number, flag: number, sequence: number, maxWrite = 240): Uint8Array[] {
const chunkSize = Math.min(232, Math.floor(maxWrite) - 8)
if (chunkSize < 12) throw new Error('Negotiated BLE write size is too small')
const crc = crc16(payload), withCrc = concat(payload, new Uint8Array([crc & 255, crc >>> 8]))
const count = Math.ceil(withCrc.length / chunkSize)
if (count > 255) throw new Error('Protocol message exceeds the fragment limit')
return Array.from({ length: count }, (_, i) => {
const chunk = withCrc.subarray(i * chunkSize, (i + 1) * chunkSize)
return concat(new Uint8Array([0xaa, 0x21, sequence & 255, chunk.length, count, i + 1, sid, flag]), chunk)
})
}
export type ProtocolMessage = { sid: number; flag: number; payload: Uint8Array; command: number; magic: number }
/** Handles split/coalesced envelopes and reassembles each link/sequence separately. */
export class MessageReceiver {
private streams = new Map<string, Uint8Array>()
private messages = new Map<string, { chunks: Uint8Array[]; total: number; seen: number; size: number }>()
clear(): void { this.streams.clear(); this.messages.clear() }
receive(link: string, data: Uint8Array, now = Date.now()): ProtocolMessage[] {
for (const [key, message] of this.messages) if (now - message.seen > 5000) this.messages.delete(key)
let stream = concat(this.streams.get(link) ?? new Uint8Array(), data)
const output: ProtocolMessage[] = []
while (stream.length >= 8) {
if (stream[0] !== 0xaa || ![0x21, 0x12].includes(stream[1])) { stream = stream.subarray(1); continue }
const length = stream[3], count = stream[4], index = stream[5]
if (stream.length < length + 8) break
const sid = stream[6], flag = stream[7], key = `${link}:${stream[2]}:${sid}:${flag}`
const chunk = stream.slice(8, 8 + length); stream = stream.subarray(length + 8)
if (!count || !index || index > count) { this.messages.delete(key); continue }
if (index === 1) this.messages.set(key, { chunks: [], total: count, seen: now, size: 0 })
const message = this.messages.get(key)
if (!message || message.total !== count || message.chunks.length + 1 !== index) { this.messages.delete(key); continue }
message.chunks.push(chunk); message.size += chunk.length; message.seen = now
if (message.size > 65536) { this.messages.delete(key); continue }
if (index !== count) continue
this.messages.delete(key)
const complete = concat(...message.chunks)
if (complete.length < 2) continue
const payload = complete.subarray(0, -2), crc = complete[complete.length - 2] | (complete[complete.length - 1] << 8)
if (crc16(payload) !== crc) continue
try { output.push({ sid, flag, payload, command: readInteger(payload, 1, -1), magic: readInteger(payload, 2, -1) }) }
catch { /* Malformed notifications cannot satisfy an acknowledgement. */ }
}
this.streams.set(link, stream.slice())
return output
}
}
function readVarint(data: Uint8Array, offset: number): [number, number] {
let value = 0
for (let i = 0; i < 5 && offset < data.length; i++) {
const byte = data[offset++]; value += (byte & 127) * 2 ** (i * 7)
if (!(byte & 128)) return [value, offset]
}
throw new Error('Truncated or oversized protobuf varint')
}
function field(data: Uint8Array, number: number): number | Uint8Array | undefined {
let offset = 0
while (offset < data.length) {
let key: number; [key, offset] = readVarint(data, offset)
const tag = key >>> 3, wire = key & 7
if (!tag) throw new Error('Invalid protobuf field')
if (wire === 0) {
let value: number; [value, offset] = readVarint(data, offset)
if (tag === number) return value
} else {
let length: number
if (wire === 2) [length, offset] = readVarint(data, offset)
else if (wire === 1) length = 8
else if (wire === 5) length = 4
else throw new Error('Unsupported protobuf wire type')
if (offset + length > data.length) throw new Error('Truncated protobuf field')
if (tag === number && wire === 2) return data.subarray(offset, offset + length)
offset += length
}
}
return undefined
}
export function readInteger(data: Uint8Array, number: number, fallback = 0): number { const value = field(data, number); return typeof value === 'number' ? value : fallback }
export function readBytes(data: Uint8Array, number: number): Uint8Array | undefined { const value = field(data, number); return value instanceof Uint8Array ? value : undefined }
export function readString(data: Uint8Array, number: number): string { return Array.from(readBytes(data, number) ?? [], value => String.fromCharCode(value)).join('') }
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 = { kind: 'sys-event' | 'list-click' | 'text-click'; eventType: number; eventSource: number; systemExitReasonCode: number; containerName: string; frameId: number }
export function decodeGlassesInput(message: ProtocolMessage): GlassesInput | null {
if (message.sid !== SID.hub || ![1, 6].includes(message.flag)) return null
const events = readBytes(message.payload, 13); if (!events) return null
for (const [field, kind, typeField] of [[1, 'list-click', 5], [2, 'text-click', 3], [3, 'sys-event', 1]] as const) {
const event = readBytes(events, field)
if (event) return { kind, eventType: readInteger(event, typeField), eventSource: field === 3 ? readInteger(event, 2) : 0,
systemExitReasonCode: field === 3 ? readInteger(event, 4) : 0, containerName: field === 3 ? '' : readString(event, 2), frameId: 0 }
}
return null
}
export function decodeRingInput(data: Uint8Array): GlassesInput | null {
let eventType: number | undefined
if (data.length === 11 && data[0] === 0 && data[1] === 9 && data[2] === 0x61 && data[3] === 0)
eventType = ({ 0: 9, 1: 0, 2: 3, 4: 1, 5: 2, 8: 10 } as Record<number, number>)[data[4]]
if (data.length === 3 && data[0] === 255) {
if (data[1] === 3 && data[2] === 32) eventType = 9
if (data[1] === 4 && data[2] === 1) eventType = 0
if (data[1] === 4 && data[2] === 2) eventType = 3
if (data[1] === 5) eventType = data[2] <= 1 ? 2 : 1
}
return eventType === undefined ? null : { kind: 'sys-event', eventType, eventSource: 2, systemExitReasonCode: 0, containerName: '', frameId: 0 }
}
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')
const stride = Math.ceil(width / 2), packed = new Uint8Array(stride * height)
for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
const nibble = Math.min(15, (gray[y * width + x] + 8) >> 4)
packed[y * stride + (x >> 1)] |= nibble << (x % 2 ? 0 : 4)
}
return packed
}
export function rle4(packed: Uint8Array): Uint8Array {
const output = new Uint8Array(packed.length * 2)
const nibble = (i: number) => (packed[i >> 1] >> (i % 2 ? 0 : 4)) & 15
let used = 0, i = 0
while (i < packed.length * 2) {
const color = nibble(i); let end = i + 1
while (end < packed.length * 2 && nibble(end) === color) end++
let remaining = end - i
while (remaining) {
const count = Math.min(65535, remaining)
if (count <= 15) output[used++] = (count << 4) | color
else { output[used++] = color; if (count <= 255) output[used++] = count
else { output[used++] = 0; output[used++] = count & 255; output[used++] = count >>> 8 } }
remaining -= count
}
i = end
}
return output.slice(0, used)
}
+298
View File
@@ -0,0 +1,298 @@
import * as protocol from './ble-protocol'
import { hexToBytes } from '../util/hex-util'
import { deviceAddressError } from './ios-peripheral-identity'
declare function setTimeout(callback: () => void, ms: number): number
declare function clearTimeout(id: number): void
export type SessionAddresses = { left: string; right: string; ring: string }
export type TransportEvent = { kind: string; identifier?: string; characteristic?: string; data?: string; message?: string; state?: number }
export interface SessionTransport {
onEvent(listener: (event: TransportEvent) => void): () => void
resolveDevices(addresses: SessionAddresses): Promise<Record<string, string>>
connect(identifier: string): Promise<{ characteristics: string[]; maxWrite: number }>
subscribe(identifier: string, characteristic: string): Promise<void>
write(identifier: string, characteristic: string, bytes: Uint8Array): Promise<void>
disconnect(identifier: string): void
stopScan(): void
}
export type SessionState = { phase: 'disconnected' | 'connecting' | 'connected' | 'retrying' | 'disconnecting' | 'error';
status: string; battery: number | null; ring: boolean; frames: number; capabilities: string; leftVersion: string; rightVersion: string }
type PendingAck = { resolve: (message: protocol.ProtocolMessage) => void; reject: (error: Error) => void;
timer: number | null; command: number; label: string }
class AckTimeout extends Error {}
/** G2 session independent of the phone OS. Images go to L, control to R, as on Android. */
export class GlassesSession {
state: SessionState = { phase: 'disconnected', status: 'Preview only', battery: null, ring: false,
frames: 0, capabilities: '', leftVersion: '', rightVersion: '' }
private generation = 0
private ids: Record<string, string> = {}
private limits: Record<string, number> = {}
private pending = new Map<string, PendingAck>()
private receiver = new protocol.MessageReceiver()
private writes = new Map<string, Promise<void>>()
private magic = 100
private sequence = 0x40
private timer: number | null = null
private retryTimer: number | null = null
private retryCount = 0
private wanted = false
private addresses: SessionAddresses | null = null
private latest: Uint8Array | null = null
private displayed: Uint8Array | null = null
private pumping = false
private lastHeartbeat = 0
private lastLease = 0
private lastSettings = 0
private charging = false
private layoutCreated = false
private off: () => void
constructor(private readonly transport: SessionTransport,
private readonly deflate: (data: Uint8Array) => Uint8Array,
private readonly onState: (state: SessionState) => void,
private readonly onInput: (input: protocol.GlassesInput) => void,
private readonly log: (message: string) => void = () => {}) {
this.off = transport.onEvent(event => this.receive(event))
}
private update(phase: SessionState['phase'], status: string): void {
this.state = { ...this.state, phase, status }; this.log(status); this.onState({ ...this.state })
}
async start(addresses: SessionAddresses, retry = false): Promise<void> {
if (['connecting', 'connected', 'disconnecting'].includes(this.state.phase)) return
const invalid = deviceAddressError(addresses)
if (invalid) { this.update('error', invalid); return }
this.addresses = { ...addresses }; this.wanted = true
if (!retry) this.retryCount = 0
const generation = ++this.generation
this.state = { ...this.state, capabilities: '', leftVersion: '', rightVersion: '', battery: null, ring: false }
this.charging = false
this.update('connecting', 'Finding configured devices…')
try {
const ids = await this.transport.resolveDevices(addresses); this.check(generation)
this.ids = ids
for (const role of ['right', 'left']) {
this.update('connecting', `Connecting ${role} arm…`)
const details = await this.transport.connect(ids[role]); this.check(generation)
this.limits[role] = details.maxWrite
if (!details.characteristics.includes(protocol.G2_WRITE) || !details.characteristics.includes(protocol.G2_NOTIFY)) throw new Error(`${role} arm is missing G2 communication characteristics.`)
await this.transport.subscribe(ids[role], protocol.G2_NOTIFY); this.check(generation)
}
this.update('connecting', 'Authenticating… Accept pairing if iOS asks.')
await Promise.all(['right', 'left'].map(async role => {
try {
const answer = await this.request(role, protocol.SID.auth, protocol.authentication, 'Security authentication', 30_000, 0)
if (!protocol.authenticationSucceeded(answer, answer.magic)) throw new Error(`${role} arm rejected authentication.`)
} catch (error) {
if (!(error instanceof AckTimeout)) throw error
// Older CFW may not implement the reply. A settings response below
// still has to prove we have a working, compatible session.
this.log(`${role} authentication unconfirmed; checking firmware response`)
}
}))
this.check(generation)
this.update('connecting', 'Checking glasses firmware…')
const settings = await this.request('right', protocol.SID.settings, protocol.settingsQuery, 'Settings query')
this.applySettings(settings)
const caps = this.state.capabilities.split(/\s+/)
if (!['img640', 'fbguard', 'wearnotify'].every(cap => caps.includes(cap)))
throw new Error('The glasses do not report compatible Faceclaw firmware (img640, fbguard, wearnotify). Bluetooth is working, but this display requires the modified firmware. Flashing remains available on Android.')
this.update('connecting', 'Starting glasses display…')
await this.request('right', protocol.SID.launch, () => protocol.prelude(), 'App launch', 3500, 0x20, 156)
await this.lease(true)
await this.request('right', protocol.SID.hub, protocol.createLayout, 'Create display layout')
this.check(generation); this.layoutCreated = true
this.lastHeartbeat = this.lastLease = this.lastSettings = Date.now()
this.displayed = null; this.retryCount = 0
this.update('connected', 'Glasses connected')
this.schedule()
if (addresses.ring && ids.ring) {
try {
const ring = await this.transport.connect(ids.ring); this.check(generation)
const notifications = protocol.RING_NOTIFY.filter(uuid => ring.characteristics.includes(uuid))
if (!notifications.length) throw new Error('No R1 gesture notifications found')
for (const uuid of notifications) await this.transport.subscribe(ids.ring, uuid)
this.check(generation); this.state.ring = true; this.update('connected', 'Glasses and ring connected')
} catch (error) {
if (generation !== this.generation) return
this.transport.disconnect(ids.ring)
this.update('connected', `Glasses connected; ring unavailable: ${this.message(error)}`)
}
} else if (addresses.ring) this.update('connected', 'Glasses connected; configured ring was not found')
} catch (error) {
if (generation !== this.generation) return
this.fail(error, retry)
}
}
private check(generation: number): void { if (generation !== this.generation) throw new Error('Connection cancelled') }
private nextMagic(): number {
for (let i = 0; i < 156; i++) {
const magic = this.magic; this.magic = this.magic === 255 ? 100 : this.magic + 1
if (magic !== 156 && ![...this.pending.keys()].some(key => key.endsWith(`:${magic}`))) return magic
}
throw new Error('All message identifiers are in use')
}
private request(role: string, sid: number, build: (magic: number) => Uint8Array, label: string,
timeout = 3500, flag = 0x20, fixedMagic?: number): Promise<protocol.ProtocolMessage> {
const magic = fixedMagic ?? this.nextMagic(), payload = build(magic), key = `${sid}:${magic}`
const generation = this.generation
return new Promise((resolve, reject) => {
const pending: PendingAck = { resolve, reject, timer: null, command: protocol.readInteger(payload, 1, -1), label }
this.pending.set(key, pending)
this.send(role, sid, flag, payload).then(() => {
if (this.pending.get(key) !== pending || generation !== this.generation) return
pending.timer = setTimeout(() => {
this.pending.delete(key); reject(new AckTimeout(`${label} was not acknowledged by the glasses.`))
}, timeout)
}).catch(error => {
if (this.pending.get(key) !== pending) return
this.pending.delete(key); if (pending.timer) clearTimeout(pending.timer); reject(error)
})
})
}
private send(role: string, sid: number, flag: number, payload: Uint8Array): Promise<void> {
const identifier = this.ids[role], generation = this.generation
if (!identifier) return Promise.reject(new Error(`No ${role} device connected`))
const frames = protocol.frameMessage(payload, sid, flag, this.sequence++, this.limits[role])
const previous = this.writes.get(identifier) ?? Promise.resolve()
const work = previous.catch(() => {}).then(async () => {
for (const frame of frames) { this.check(generation); await this.transport.write(identifier, protocol.G2_WRITE, frame) }
})
// A whole message owns the write queue; heartbeat packets cannot split an image message.
this.writes.set(identifier, work)
return work
}
private lease(acquire: boolean): Promise<void[]> {
return Promise.all(['right', 'left'].map(role => this.send(role, protocol.SID.settings, 0x20, protocol.framebufferLease(acquire))))
}
private receive(event: TransportEvent): void {
if (!Object.values(this.ids).includes(event.identifier ?? '')) return
if (event.kind === 'disconnected') {
if (event.identifier === this.ids.ring) {
this.state.ring = false
if (this.state.phase === 'connected') this.update('connected', 'Glasses connected; ring disconnected')
} else if (['connected', 'connecting'].includes(this.state.phase)) this.fail(new Error(event.message || 'Glasses disconnected'), true)
return
}
if (event.kind !== 'notification' || !event.data) return
try {
const data = hexToBytes(event.data)
if (event.identifier === this.ids.ring) {
if (!protocol.RING_NOTIFY.includes(event.characteristic ?? '')) return
const input = protocol.decodeRingInput(data); if (input) this.onInput(input); return
}
if (event.characteristic !== protocol.G2_NOTIFY) return
for (const message of this.receiver.receive(event.identifier!, data)) {
if (![1, 6].includes(message.flag)) {
// A master arm can relay the other arm's ACK; magic is allocated
// across BOTH links, matching Android's communicator.
const key = `${message.sid}:${message.magic}`, pending = this.pending.get(key)
if (pending) {
this.pending.delete(key); if (pending.timer) clearTimeout(pending.timer)
pending.resolve(message)
}
}
if (message.sid === protocol.SID.settings) this.applySettings(message)
if (event.identifier === this.ids.right) {
const input = protocol.decodeGlassesInput(message)
if (input) {
if (input.kind === 'sys-event' && [5, 6, 7].includes(input.eventType) && this.state.phase === 'connected') {
// Respect an explicit glasses-side exit; the user can reconnect.
void this.stop(); continue
}
this.onInput(input)
}
}
}
} catch (error) { this.log(`Ignored malformed BLE notification: ${this.message(error)}`) }
}
private applySettings(message: protocol.ProtocolMessage): void {
const values = protocol.readBytes(message.payload, 4)
const capabilities = protocol.readString(message.payload, 100)
if (capabilities) this.state.capabilities = capabilities
if (values) {
const left = protocol.readString(values, 5), right = protocol.readString(values, 6)
if (left) this.state.leftVersion = left
if (right) this.state.rightVersion = right
const battery = protocol.readInteger(values, 12, -1), charging = protocol.readInteger(values, 13, -1)
if (battery >= 0 && battery <= 100) this.state.battery = battery
if (charging >= 0) this.charging = charging > 0
}
this.onState({ ...this.state })
}
setFrame(gray: Uint8Array): void {
if (this.state.phase !== 'connected') return
this.latest = protocol.packGray4(gray, 640, 480); this.schedule(0)
}
private schedule(delay = 1000): void {
if (delay === 0 && this.timer !== null) { clearTimeout(this.timer); this.timer = null }
if (this.timer !== null || this.pumping || this.state.phase !== 'connected') return
this.timer = setTimeout(() => { this.timer = null; void this.pump() }, delay)
}
private async pump(): Promise<void> {
if (this.pumping || this.state.phase !== 'connected') return
this.pumping = true; const generation = this.generation
try {
const now = Date.now()
if (now - this.lastHeartbeat >= 4000) {
await this.request('right', protocol.SID.hub, protocol.heartbeat, 'Heartbeat', 1500); this.lastHeartbeat = Date.now()
}
if (now - this.lastLease >= 45_000) { await this.lease(true); this.lastLease = Date.now() }
if (now - this.lastSettings >= (this.charging ? 30_000 : 300_000)) {
const settings = await this.request('right', protocol.SID.settings, protocol.settingsQuery, 'Battery query')
this.applySettings(settings); this.lastSettings = Date.now()
}
const frame = this.latest; this.latest = null
if (frame && !this.charging && (!this.displayed || !frame.every((value, i) => value === this.displayed![i]))) {
const payload = protocol.concat(new Uint8Array([6]), this.deflate(protocol.rle4(frame)))
if (payload.length > 165888) throw new Error('Compressed frame exceeds the glasses image buffer')
for (let offset = 0; offset < payload.length; offset += 3800) {
await this.request('left', protocol.SID.hub, magic => protocol.imageFragment(magic, payload, offset), 'Display frame')
this.check(generation); this.lastHeartbeat = Date.now()
}
this.displayed = frame; this.state.frames++; this.onState({ ...this.state })
this.log(`Display frame ${this.state.frames} acknowledged (${payload.length} bytes)`)
} else if (frame && this.charging) this.latest = frame
} catch (error) { if (generation === this.generation) this.fail(error, true) }
finally { if (generation === this.generation) { this.pumping = false; this.schedule(this.latest && !this.charging ? 0 : 1000) } }
}
private reset(): void {
++this.generation
if (this.timer !== null) clearTimeout(this.timer)
if (this.retryTimer !== null) clearTimeout(this.retryTimer)
this.timer = this.retryTimer = null; this.pumping = false
const pending = [...this.pending.values()]; this.pending.clear()
for (const request of pending) { if (request.timer) clearTimeout(request.timer); request.reject(new Error('Connection ended')) }
this.receiver.clear(); this.writes.clear(); this.latest = this.displayed = null
}
private closeLinks(): void {
const ids = this.ids; this.ids = {}; this.limits = {}
for (const identifier of Object.values(ids)) this.transport.disconnect(identifier)
this.transport.stopScan(); this.layoutCreated = false; this.state.ring = false
}
private fail(error: unknown, retry: boolean): void {
const message = this.message(error); this.reset(); this.closeLinks()
if (retry && this.wanted && this.addresses && this.retryCount < 5) {
const delay = Math.min(30_000, 2000 * 2 ** this.retryCount++)
this.update('retrying', `${message} Retrying in ${delay / 1000}s…`)
this.retryTimer = setTimeout(() => { this.retryTimer = null; if (this.wanted && this.addresses) void this.start(this.addresses, true) }, delay)
} else { this.wanted = false; this.update('error', message) }
}
async stop(): Promise<void> {
this.wanted = false
const cleanup = this.layoutCreated && this.state.phase === 'connected'
this.update('disconnecting', 'Disconnecting…'); this.reset()
try {
if (cleanup) {
if (this.state.capabilities.split(/\s+/).includes('cleanup11'))
await this.request('left', protocol.SID.hub, magic => protocol.imageFragment(magic, new Uint8Array([11]), 0), 'Display cleanup', 1200)
else {
await this.request('right', protocol.SID.hub, protocol.shutdown, 'Close display', 1200)
await this.lease(false)
}
}
} catch (error) { this.log(`Disconnect cleanup: ${this.message(error)}`) }
finally { this.reset(); this.closeLinks(); this.update('disconnected', 'Preview only') }
}
dispose(): void { void this.stop().finally(() => this.off()) }
private message(error: unknown): string { return error instanceof Error ? error.message : String(error) }
}
+25
View File
@@ -0,0 +1,25 @@
import { classifyAdvertisement, hasEvenManufacturerSignature, type EvenAdvertisement } from './even-advertisement'
import { hexToBytes } from '../util/hex-util'
export type IosAdvertisement = { identifier: string; name: string; manufacturerData: string; rssi: number; connectable: boolean }
export type IosDevice = EvenAdvertisement & { identifier: string }
/** Only a full vendor-advertised MAC may bind a manually entered address. */
export function identifyIosPeripheral(raw: IosAdvertisement): IosDevice | null {
if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(raw.identifier)) return null
if (!hasEvenManufacturerSignature(hexToBytes(raw.manufacturerData))) return null
const candidate = classifyAdvertisement({ ...raw, address: '', source: 'scan', bonded: false,
txPower: null, seenAtMs: Date.now() })
if (!candidate?.embeddedMac) return null
return { ...candidate, address: candidate.embeddedMac, embeddedMacMismatch: false, identifier: raw.identifier.toUpperCase() }
}
export function deviceAddressError(addresses: { left: string; right: string; ring: string }): string | null {
for (const role of ['right', 'left', 'ring'] as const) {
const address = addresses[role]
if (role === 'ring' && !address) continue
if (!/^[0-9A-F]{2}(?::[0-9A-F]{2}){5}$/.test(address)) return `${role === 'ring' ? 'Ring' : role === 'left' ? 'Left arm' : 'Right arm'} MAC address is invalid.`
}
const values = Object.values(addresses).filter(Boolean)
return new Set(values).size === values.length ? null : 'Each device must have a different MAC address.'
}
+58 -4
View File
@@ -1,4 +1,8 @@
import { Dialogs, type ImageSource } from '@nativescript/core'
import { Dialogs, File, knownFolders, path, type ImageSource } from '@nativescript/core'
import { iosBluetooth } from '../native/ios-bluetooth'
import { GlassesSession, type SessionState } from './glasses-session'
import { loadDeviceAddresses } from './device-addresses'
import { deviceAddressError } from './ios-peripheral-identity'
import { createLauncherWindow, LAUNCHER_SURFACE_ID } from '../apps/launcher/launcher-app'
import { CalculatorLayer } from '../apps/calculator/calculator'
import { MathCoordinator } from '../apps/calculator/math/coordinator'
@@ -10,7 +14,7 @@ import { makeInputEvent, type InputEventPayload } from '../ui/gestures'
import { noopLayerActions, type LayerActions } from '../ui/layers'
import { MenuLayer } from '../ui/menu'
import { createInProcessWindow } from '../ui/shell/in-process-window'
import { shell, type ShellWindow } from '../ui/shell/shell'
import { shell, rawInputEventToInputEvent, type ShellWindow } from '../ui/shell/shell'
import { appViewportRect, SIDEBAR_WIDTH, sidebarStripVisible } from '../ui/shell/geometry'
import { DISPLAY_MODE_VALUES, displayModeLabel, displayModeSetting, onAnySettingChanged,
previewColorSetting, timeFormatSetting, verticalPositionSetting } from '../ui/dashboard-settings'
@@ -27,6 +31,11 @@ export class IosPreviewController {
private inputQueue: Promise<void> = Promise.resolve()
private lastLayout = ''
private prompting = false
private session: GlassesSession | null = null
private resumeConnection = false
private suspendedDisconnect: Promise<void> = Promise.resolve()
private logLines: string[] = []
private logTimer: ReturnType<typeof setTimeout> | null = null
private readonly actions: LayerActions = {
...noopLayerActions,
requestRender: () => this.requestShellRender(),
@@ -38,7 +47,8 @@ export class IosPreviewController {
}
constructor(private readonly onFrame: (image: ImageSource, focus: string) => void,
private readonly onError: (message: string) => void) {
private readonly onError: (message: string) => void,
private readonly onConnectionState: (state: SessionState) => void = () => {}) {
this.compositor.configureSurface('shell', { x: 0, y: 0, width: 640, height: 480, zOrder: 1, transparency: 'color-key' })
shell.configure({
actions: this.actions,
@@ -78,8 +88,14 @@ export class IosPreviewController {
shell.foregroundWindow()?.requestRender()
this.requestShellRender()
console.log('[ios-preview] Main screen active')
if (this.resumeConnection) {
this.resumeConnection = false
void this.suspendedDisconnect.then(() => { if (this.active) void this.connect() })
}
}
pause(): void {
this.resumeConnection = !!this.session && ['connected', 'connecting', 'retrying'].includes(this.session.state.phase)
if (this.session) this.suspendedDisconnect = this.session.stop()
this.active = false
this.offSettings?.(); this.offSettings = null
if (this.clockTimer) clearInterval(this.clockTimer)
@@ -119,7 +135,9 @@ export class IosPreviewController {
this.compositor.submitSurfaceFrame('shell', image.pixels, { x: 0, y: 0, width: 640, height: 480 })
this.compositor.setUnderlayDim(1, shell.underlayDim())
}
const image = previewPixels(this.compositor.composite(), 640, 480, previewColorSetting.get() === 'green')
const pixels = this.compositor.composite()
this.session?.setFrame(pixels)
const image = previewPixels(pixels, 640, 480, previewColorSetting.get() === 'green')
this.onFrame(image, `${shell.foregroundWindow()?.title ?? 'Apps'} · ${shell.getFocus() === 'sidebar' ? 'App switcher' : 'App'}`)
} catch (error) { this.fail(error) }
}, 33)
@@ -203,6 +221,42 @@ export class IosPreviewController {
displayModeSetting.set(values[(values.indexOf(displayModeSetting.get()) + 1) % values.length])
}
get displayModeLabel(): string { return displayModeLabel(displayModeSetting.get()) }
get connectionState(): SessionState | null { return this.session?.state ?? null }
get connectionDetails(): string {
const state = this.connectionState
return state ? `${state.status}\nL: ${state.leftVersion || 'unknown'}\nR: ${state.rightVersion || 'unknown'}\nBattery: ${state.battery ?? '?'}%\nRing: ${state.ring ? 'connected' : 'disconnected'}\nFrames acknowledged: ${state.frames}\n${state.capabilities}\n\n${this.logLines.slice(-12).join('\n')}` : 'Preview only. Configure devices, then connect.'
}
async connect(): Promise<void> {
if (!this.active) return
const addresses = loadDeviceAddresses(), error = deviceAddressError(addresses)
if (error) { this.onError(error); return }
if (!this.session) {
const { deflate } = require('pako') as { deflate: (data: Uint8Array) => Uint8Array }
this.session = new GlassesSession(iosBluetooth(), deflate, state => {
this.onConnectionState(state)
if (state.phase === 'connected') this.requestShellRender()
}, input => {
this.inputQueue = this.inputQueue.then(async () => {
if (!this.active) return
await shell.receiveInput(rawInputEventToInputEvent(input)); this.requestShellRender()
this.logBluetooth(`Input ${input.eventType} source ${input.eventSource}`)
}).catch(error => this.fail(error))
}, message => this.logBluetooth(message))
}
await this.session.start(addresses)
}
async disconnect(): Promise<void> { this.resumeConnection = false; await this.session?.stop() }
private logBluetooth(message: string): void {
const line = `${new Date().toISOString()} ${message}`
console.log(`[ios-ble] ${line}`); this.logLines.push(line)
if (this.logLines.length > 200) this.logLines.shift()
if (this.logTimer !== null) return
this.logTimer = setTimeout(() => {
this.logTimer = null
try { File.fromPath(path.join(knownFolders.documents().path, 'bluetooth.log')).writeTextSync(this.logLines.join('\n')) }
catch (error) { console.warn(`Bluetooth log: ${error}`) }
}, 500)
}
async typeIntoApp(): Promise<void> {
if (this.prompting || !shell.foregroundWindow()?.receiveTextInput) return
this.prompting = true
+144
View File
@@ -0,0 +1,144 @@
import { ApplicationSettings } from '@nativescript/core'
import { identifyIosPeripheral, type IosAdvertisement, type IosDevice } from '../g2/ios-peripheral-identity'
import { hexToBytes } from '../util/hex-util'
declare const FaceclawBluetooth: any
type NativeEvent = { kind: string; id?: number; error?: string; details?: ConnectionDetails; state?: number;
identifier?: string; characteristic?: string; data?: string; message?: string } & Partial<IosAdvertisement>
export type ConnectionDetails = { characteristics: string[]; maxWrite: number }
export type BluetoothEvent = NativeEvent | { kind: 'device'; device: IosDevice }
type Pending = { resolve: (details: ConnectionDetails) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> }
/** One central manager per app, with asynchronous main-queue GATT operations. */
export class IosBluetooth {
private readonly native = FaceclawBluetooth.new()
private readonly listeners = new Set<(event: BluetoothEvent) => void>()
private readonly pending = new Map<number, Pending>()
private readonly advertisements = new Map<string, IosAdvertisement>()
readonly devices = new Map<string, IosDevice>()
private requestId = 0
private scanTimer: ReturnType<typeof setTimeout> | null = null
state = 0
scanning = false
constructor() {
this.native.eventHandler = (json: string) => {
try { this.receive(JSON.parse(json)) } catch (error) { console.error(`[ios-ble] ${error}`) }
}
}
onEvent(listener: (event: BluetoothEvent) => void): () => void {
this.listeners.add(listener); return () => { this.listeners.delete(listener) }
}
private emit(event: BluetoothEvent): void { for (const listener of [...this.listeners]) listener(event) }
private receive(event: NativeEvent): void {
if (event.kind === 'completion') {
const pending = this.pending.get(event.id!)
if (pending) {
this.pending.delete(event.id!); clearTimeout(pending.timer)
if (event.error) pending.reject(new Error(event.error)); else pending.resolve(event.details!)
}
return
}
if (event.kind === 'state') this.state = event.state!
if (event.kind === 'advertisement') {
const previous = this.advertisements.get(event.identifier!)
const raw: IosAdvertisement = { identifier: event.identifier!, name: event.name || previous?.name || '',
manufacturerData: event.manufacturerData || previous?.manufacturerData || '', rssi: event.rssi!, connectable: event.connectable !== false }
// Bound the cache even in a crowded radio environment.
if (this.advertisements.size >= 512 && !this.advertisements.has(raw.identifier)) this.advertisements.delete(this.advertisements.keys().next().value!)
this.advertisements.set(raw.identifier, raw)
const device = identifyIosPeripheral(raw)
if (device) {
this.devices.set(device.address, device)
ApplicationSettings.setString(`ios.ble.peripheral.${device.address}`, JSON.stringify({ identifier: device.identifier, role: device.role }))
this.emit({ kind: 'device', device })
}
return
}
this.emit(event)
}
ensureReady(): Promise<void> {
return new Promise((resolve, reject) => {
const finish = (error?: Error) => { clearTimeout(timer); off(); error ? reject(error) : resolve() }
const off = this.onEvent(event => {
if (event.kind !== 'state') return
const state = (event as NativeEvent).state
if (state === 5) finish()
else if (state === 2) finish(new Error('Bluetooth is unavailable on this device. Use the physical iPhone.'))
else if (state === 3) finish(new Error('Allow Faceclaw to use Bluetooth in iPhone Settings.'))
else if (state === 4) finish(new Error('Turn on Bluetooth, then try again.'))
})
const timer = setTimeout(() => finish(new Error('Waiting for Bluetooth permission timed out. Try again after allowing Bluetooth.')), 30_000)
this.native.initializeBluetooth()
})
}
async startScan(durationMs = 12_000): Promise<void> {
await this.ensureReady()
this.stopScan(); this.scanning = true; this.native.scan(true)
this.scanTimer = setTimeout(() => this.stopScan(), durationMs)
this.emit({ kind: 'scan-started' })
}
stopScan(): void {
if (this.scanTimer) clearTimeout(this.scanTimer)
this.scanTimer = null; this.native.scan(false)
const wasScanning = this.scanning; this.scanning = false
if (wasScanning) this.emit({ kind: 'scan-stopped' })
}
async resolveDevices(addresses: { left: string; right: string; ring: string }): Promise<Record<string, string>> {
await this.ensureReady()
const result: Record<string, string> = {}
for (const role of ['left', 'right', 'ring'] as const) {
const address = addresses[role]
if (!address) continue
const live = this.devices.get(address)
if (live && live.role !== role) throw new Error(`${address} advertises as ${live.role}, not ${role}. Check Configure devices.`)
try {
const saved = JSON.parse(ApplicationSettings.getString(`ios.ble.peripheral.${address}`, '{}'))
if (saved.role === role && typeof saved.identifier === 'string') result[role] = saved.identifier
} catch { /* A fresh scan can recover malformed settings. */ }
}
const missing = () => (['left', 'right'] as const).filter(role => !result[role])
if (!missing().length && (!addresses.ring || result.ring)) return result
await this.startScan(15_000)
await new Promise<void>((resolve, reject) => {
const off = this.onEvent(event => {
if (event.kind === 'device') {
const device = (event as { device: IosDevice }).device
for (const role of ['left', 'right', 'ring'] as const) {
if (addresses[role] === device.address && device.role === role) result[role] = device.identifier
}
if (!missing().length && (!addresses.ring || result.ring)) { off(); this.stopScan(); resolve() }
} else if (event.kind === 'scan-stopped') {
off()
if (missing().length) reject(new Error(`Could not find the ${missing().join(' and ')} arm. Wake the glasses, disconnect other apps, and scan again.`))
else resolve() // An optional missing ring must not block the glasses.
}
})
})
return result
}
private operation(identifier: string, call: (id: number) => void, timeoutMs = 10_000): Promise<ConnectionDetails> {
const id = ++this.requestId
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
this.pending.delete(id); this.native.disconnect(identifier)
reject(new Error('Bluetooth operation timed out. Wake the device and try connecting again.'))
}, timeoutMs)
this.pending.set(id, { resolve, reject, timer })
try { call(id) } catch (error) { clearTimeout(timer); this.pending.delete(id); reject(error) }
})
}
connect(identifier: string): Promise<ConnectionDetails> { return this.operation(identifier, id => this.native.connectRequestId(identifier, id), 20_000) }
async subscribe(identifier: string, characteristic: string): Promise<void> {
await this.operation(identifier, id => this.native.subscribeCharacteristicRequestId(identifier, characteristic, id))
}
async write(identifier: string, characteristic: string, bytes: Uint8Array): Promise<void> {
const copy = new Uint8Array(bytes)
const data = NSData.dataWithBytesLength(interop.handleof(copy.buffer), copy.byteLength)
await this.operation(identifier, id => this.native.writeCharacteristicDataRequestId(identifier, characteristic, data, id))
}
disconnect(identifier: string): void { this.native.disconnect(identifier) }
forget(address: string): void { ApplicationSettings.remove(`ios.ble.peripheral.${address}`); this.devices.delete(address) }
}
let instance: IosBluetooth | null = null
export function iosBluetooth(): IosBluetooth { return instance ??= new IosBluetooth() }
export { hexToBytes }
+68
View File
@@ -0,0 +1,68 @@
import { Button, Color, GridLayout, Label, Page, ScrollView, StackLayout, TextField } from '@nativescript/core'
import { loadDeviceAddresses, normalizeMacAddress, saveDeviceAddresses } from '../g2/device-addresses'
import { deviceAddressError, type IosDevice } from '../g2/ios-peripheral-identity'
import { iosBluetooth } from '../native/ios-bluetooth'
export function createConfigureDevicesPage(): Page {
const page = new Page(); page.actionBarHidden = true
const root = new GridLayout(); root.rows = 'auto,*,auto'; root.padding = 16; page.content = root
const title = new Label(); title.text = 'Configure devices'; title.fontSize = 24; title.fontWeight = 'bold'; root.addChild(title)
const scroll = new ScrollView(); GridLayout.setRow(scroll, 1); root.addChild(scroll)
const form = new StackLayout(); scroll.content = form
const text = (value: string, size = 15) => {
const label = new Label(); label.text = value; label.fontSize = size; label.textWrap = true; label.marginTop = 12; form.addChild(label); return label
}
text('Enter the G2 arm MAC addresses and optional R1 ring address. Scan once so this iPhone can find the matching devices. Saving does not connect.')
const stored = loadDeviceAddresses()
const fields = {} as Record<'left' | 'right' | 'ring', TextField>
for (const role of ['right', 'left', 'ring'] as const) {
text(role === 'ring' ? 'R1 ring MAC (optional)' : `${role === 'left' ? 'Left' : 'Right'} arm MAC`)
const field = new TextField(); field.text = stored[role]; field.hint = 'AA:BB:CC:DD:EE:FF'
field.autocorrect = false; field.autocapitalizationType = 'allcharacters'; field.fontSize = 18
field.padding = 10; field.backgroundColor = new Color('#ffffff'); field.accessibilityLabel = `${role} MAC address`
field.accessibilityIdentifier = `device-address-${role}`; form.addChild(field); fields[role] = field
}
const status = text('Addresses are saved only when you tap Save.'); status.color = new Color('#285c45')
const button = (label: string, action: () => void) => {
const view = new Button(); view.text = label; view.fontSize = 15; view.marginTop = 12; view.on('tap', action); return view
}
let off: (() => void) | null = null
let closed = false
const found = new StackLayout()
const rows = new Map<string, Button>()
const showDevice = (device: IosDevice) => {
if (device.connectable === false) return
let row = rows.get(device.address)
if (!row) {
row = button('', () => { fields[device.role].text = device.address; status.text = `${device.role} address selected. Tap Save to keep it.` })
row.textWrap = true; row.fontSize = 13; rows.set(device.address, row); found.addChild(row)
}
row.text = `${device.role === 'ring' ? 'Ring' : device.role === 'left' ? 'Left arm' : 'Right arm'} · ${device.address}\n${device.serial || device.name} · ${device.rssi ?? '?'} dBm`
}
const scan = button('Scan for devices', () => {
for (const field of Object.values(fields)) field.dismissSoftInput()
const ble = iosBluetooth()
off?.(); off = ble.onEvent(event => {
if (closed) return
if (event.kind === 'device' && 'device' in event) showDevice(event.device)
if (event.kind === 'scan-stopped') { scan.isEnabled = true; status.text = rows.size ? 'Tap a device to fill its address, then Save.' : 'No matching devices found. Wake the glasses and disconnect other apps, then scan again.' }
})
rows.clear(); found.removeChildren(); scan.isEnabled = false; status.text = 'Scanning… Allow Bluetooth if iOS asks.'
void ble.startScan().catch(error => { if (!closed) { status.text = String(error.message ?? error); scan.isEnabled = true } })
})
form.addChild(scan); form.addChild(found)
const footer = new GridLayout(); footer.columns = '*,*'; GridLayout.setRow(footer, 2); root.addChild(footer)
const close = () => { closed = true; off?.(); off = null; iosBluetooth().stopScan(); page.closeModal() }
const back = button('Back', close); footer.addChild(back)
const save = button('Save', () => {
const addresses = { right: normalizeMacAddress(fields.right.text), left: normalizeMacAddress(fields.left.text), ring: normalizeMacAddress(fields.ring.text) }
const error = deviceAddressError(addresses)
if (error) { status.text = error; return }
saveDeviceAddresses(addresses)
for (const role of ['left', 'right', 'ring'] as const) { fields[role].text = addresses[role]; fields[role].dismissSoftInput() }
status.text = 'Saved device addresses. Return to the main screen and choose Connect.'
})
GridLayout.setColumn(save, 1); footer.addChild(save)
page.on('unloaded', () => { closed = true; off?.(); off = null; iosBluetooth().stopScan() })
return page
}
+30 -4
View File
@@ -1,7 +1,10 @@
import { Application, Button, Color, GridLayout, Image, Label, Page, StackLayout, type TouchGestureEventData } from '@nativescript/core'
import { Application, Button, Color, Dialogs, GridLayout, Image, Label, Page, StackLayout, type TouchGestureEventData } from '@nativescript/core'
import { createConfigureDevicesPage } from './config-page.ios'
import { IosPreviewController } from '../g2/ios-preview-controller'
import { PhoneGestureRecognizer } from './phone-gestures'
import { onAnySettingChanged, previewColorSetting } from '../ui/dashboard-settings'
import { loadDeviceAddresses } from '../g2/device-addresses'
import { deviceAddressError } from '../g2/ios-peripheral-identity'
export function createMainPage(): Page {
const page = new Page()
@@ -13,10 +16,13 @@ export function createMainPage(): Page {
header.columns = '*,auto'; header.padding = '12 20'
const title = new Label()
title.text = 'Faceclaw'; title.fontSize = 25; title.fontWeight = 'bold'
header.addChild(title)
const heading = new StackLayout(); heading.addChild(title); header.addChild(heading)
const state = new Label()
state.text = 'Preview only'; state.fontSize = 14; state.verticalAlignment = 'middle'
GridLayout.setColumn(state, 1); header.addChild(state); root.addChild(header)
state.text = 'Preview only'; state.fontSize = 12; heading.addChild(state)
const devices = new Button()
devices.text = 'Devices'; devices.accessibilityLabel = 'Configure devices'; devices.fontSize = 14; devices.padding = '10 12'
devices.on('tap', () => { void openDevices() })
GridLayout.setColumn(devices, 1); header.addChild(devices); root.addChild(header)
const body = new GridLayout()
GridLayout.setRow(body, 1); root.addChild(body)
const mirror = new Image()
@@ -52,7 +58,21 @@ export function createMainPage(): Page {
mirror.imageSource = image; focus.text = selectedTab === 'ring' ? 'Ring' : label
}, message => {
errorLabel.text = message; errorLabel.visibility = 'visible'; selectTab('settings')
}, connection => {
state.text = connection.phase === 'connected' ? `Connected${connection.battery !== null ? ` · ${connection.battery}%` : ''}${connection.ring ? ' · R1' : ''}`
: ({ disconnected: 'Preview only', connecting: 'Connecting…', retrying: 'Reconnecting…', disconnecting: 'Disconnecting…', error: 'Connection failed · Devices for details' })[connection.phase] || connection.phase
})
async function openDevices(): Promise<void> {
const connected = ['connected', 'connecting', 'retrying'].includes(controller.connectionState?.phase ?? '')
const choice = await Dialogs.action({ title: 'Devices', message: controller.connectionState?.status ?? 'Preview only', cancelButtonText: 'Cancel',
actions: ['Configure devices', connected ? 'Disconnect' : 'Connect', 'Connection details'] })
if (choice === 'Configure devices') {
await controller.disconnect()
page.showModal(createConfigureDevicesPage(), { fullscreen: true, closeCallback: () => {} })
} else if (choice === 'Connect') await controller.connect()
else if (choice === 'Disconnect') await controller.disconnect()
else if (choice === 'Connection details') await Dialogs.alert({ title: 'Connection details', message: controller.connectionDetails, okButtonText: 'OK' })
}
const padInput = new PhoneGestureRecognizer(gesture => controller.gesture(gesture, selectedTab === 'ring' ? 'ring' : 'watch'))
const mirrorInput = new PhoneGestureRecognizer((gesture, x, y) => {
const size = mirror.getActualSize()
@@ -128,10 +148,16 @@ export function createMainPage(): Page {
}
const resume = () => controller.resume()
let offSettings: (() => void) | null = null
let firstLoad = true
page.on('loaded', () => {
Application.on(Application.suspendEvent, pause); Application.on(Application.resumeEvent, resume)
offSettings?.(); offSettings = onAnySettingChanged(() => { sizeButton.text = controller.displayModeLabel })
selectTab(selectedTab); controller.resume()
if (firstLoad) {
firstLoad = false
// Match Android's reconnect-on-launch behavior once addresses are saved.
if (!deviceAddressError(loadDeviceAddresses())) void controller.connect()
}
})
page.on('unloaded', () => {
pause(); offSettings?.(); offSettings = null
+171
View File
@@ -0,0 +1,171 @@
const test = require('node:test');
const assert = require('node:assert/strict');
const p = require('../.test-build/app/g2/ble-protocol.js');
const { identifyIosPeripheral, deviceAddressError } = require('../.test-build/app/g2/ios-peripheral-identity.js');
const { GlassesSession } = require('../.test-build/app/g2/glasses-session.js');
const { deflate, inflate } = require('pako');
const hex = bytes => Buffer.from(bytes).toString('hex');
const string = (field, text) => p.bytes(field, new Uint8Array(Buffer.from(text)));
// Generated by compiling the existing Android BleProtocol.java/BmpUtil.java,
// plus BleImageOptimizer's unchanged RLE method, with javac 25.0.2.
test('iOS/shared protocol matches Android-generated wire vectors byte for byte', () => {
const vectors = [
[p.authentication(101), '080410651a0408011004'],
[p.prelude(), '0802109c01220a1a081206120408001000'],
[p.createLayout(102), '080010661a3808021a1c0800100018c00420a0024801520964617368626f617264580162012022130800100018c00420a002280a3205696d67303028904e'],
[p.heartbeat(103), '080c106772020800'],
[p.settingsQuery(104), '0802106822020801'],
[p.shutdown(105), '080910695a020801'],
[p.framebufferLease(true), '08011000aa0606464301050000'],
[p.framebufferLease(false), '08011000aa0606464301060000'],
[p.imageFragment(106, new Uint8Array([6, 1, 2, 3, 4]), 0), '0803106a2a1a080a1205696d673030180a200528003000380542050601020304'],
[p.frameMessage(p.authentication(101), 128, 0, 64)[0], 'aa21400c01018000080410651a04080110041024'],
];
for (const [actual, expected] of vectors) assert.equal(hex(actual), expected);
const packed = p.packGray4(new Uint8Array([0, 1, 7, 8, 15, 16, 23, 24, 127, 128, 247, 255]), 3, 4);
assert.equal(hex(packed), '0000111012808ff0');
assert.equal(hex(p.rle4(packed)), '40311011121810182f10');
});
test('negotiated-MTU framing reassembles split and coalesced notifications and rejects bad CRC', () => {
const payload = p.concat(p.integer(1, 3), p.integer(2, 110), p.bytes(8, new Uint8Array(3900).fill(55)));
const frames = p.frameMessage(payload, 0xe0, 0x20, 17, 185);
assert.ok(frames.every(f => f.length <= 185));
const receiver = new p.MessageReceiver(), stream = p.concat(...frames);
assert.deepEqual(receiver.receive('L', stream.slice(0, 7)), []);
const messages = receiver.receive('L', stream.slice(7));
assert.equal(messages.length, 1); assert.deepEqual(messages[0].payload, payload);
stream[stream.length - 1] ^= 1;
assert.deepEqual(receiver.receive('L', stream), []);
assert.throws(() => p.frameMessage(payload, 1, 0, 1, 10), /too small/);
assert.throws(() => p.readBytes(new Uint8Array([0x1a, 0x7f]), 3), /Truncated/);
});
test('interleaved links and missing/expired fragments cannot produce false ACKs', () => {
const payload = p.concat(p.integer(1, 3), p.integer(2, 110), p.bytes(8, new Uint8Array(300)));
const frames = p.frameMessage(payload, 224, 0, 17), receiver = new p.MessageReceiver();
assert.deepEqual(receiver.receive('L', frames[0], 0), []);
assert.deepEqual(receiver.receive('R', frames[1], 1), []);
assert.deepEqual(receiver.receive('L', frames[1], 6000), []);
assert.equal(receiver.receive('L', p.concat(...frames), 6001).length, 1);
});
test('full-frame RLE splits 65535-pixel runs and preserves opaque near-black', () => {
const packed = p.packGray4(new Uint8Array(640 * 480).fill(1), 640, 480);
assert.ok(packed.every(v => v === 0));
const encoded = p.rle4(packed);
let count = 0, offset = 0;
while (offset < encoded.length) {
const token = encoded[offset++]; let run = token >>> 4;
if (!run) { run = encoded[offset++]; if (!run) { run = encoded[offset] | (encoded[offset + 1] << 8); offset += 2; } }
assert.equal(token & 15, 0); count += run;
}
assert.equal(count, 640 * 480);
assert.deepEqual(inflate(deflate(encoded)), encoded);
});
test('iOS mapping requires the full advertised MAC, never just a name suffix', () => {
const raw = { identifier: '8A2DD845-B208-F292-EB77-F4645C5AC42F', name: 'Even G2_32_L_B6ECE0',
manufacturerData: '4552' + Buffer.from('S211GBBC180304').toString('hex') + 'e0ecb61412e001', rssi: -45, connectable: true };
const device = identifyIosPeripheral(raw);
assert.equal(device.address, 'E0:12:14:B6:EC:E0'); assert.equal(device.role, 'left');
assert.equal(device.identifier, raw.identifier); assert.equal(device.serial, 'S211GBBC180304');
assert.equal(identifyIosPeripheral({ ...raw, manufacturerData: '' }), null);
assert.equal(identifyIosPeripheral({ ...raw, identifier: 'not-a-uuid' }), null);
assert.match(deviceAddressError({ left: device.address, right: device.address, ring: '' }), /different/);
assert.equal(deviceAddressError({ left: device.address, right: 'AA:BB:CC:DD:EE:FF', ring: '' }), null);
});
test('ring and arm input decoders preserve gesture and source', () => {
assert.equal(p.decodeRingInput(new Uint8Array([255, 4, 2])).eventType, 3);
assert.equal(p.decodeRingInput(new Uint8Array([255, 5, 0])).eventType, 2);
assert.equal(p.decodeRingInput(new Uint8Array([255, 5, 2])).eventType, 1);
assert.equal(p.decodeRingInput(new Uint8Array([0, 9, 97, 0, 8, 0, 0, 0, 0, 0, 0])).eventType, 10);
assert.equal(p.decodeRingInput(new Uint8Array([255, 4, 99])), null);
const payload = p.bytes(13, p.bytes(3, p.concat(p.integer(1, 9), p.integer(2, 3))));
assert.equal(p.decodeGlassesInput({ sid: 224, flag: 1, payload }).eventSource, 3);
assert.equal(p.decodeGlassesInput({ sid: 224, flag: 32, payload }), null);
});
class FakeTransport {
events = new Set(); receiver = new p.MessageReceiver(); sent = []; subscriptions = []; closed = [];
hold = false; held = []; stock = false;
onEvent(fn) { this.events.add(fn); return () => this.events.delete(fn); }
emit(event) { for (const fn of [...this.events]) fn(event); }
async resolveDevices() { return { left: 'L', right: 'R', ring: 'ring' }; }
async connect(id) { return { characteristics: id === 'ring' ? p.RING_NOTIFY : [p.G2_WRITE, p.G2_NOTIFY], maxWrite: 185 }; }
async subscribe(id, characteristic) { this.subscriptions.push([id, characteristic]); }
disconnect(id) { this.closed.push(id); this.emit({ kind: 'disconnected', identifier: id }); }
stopScan() {}
ack(id, message, overrides = {}) {
let body = new Uint8Array();
if (message.sid === p.SID.auth) body = p.bytes(3, new Uint8Array());
if (message.sid === p.SID.settings) body = p.concat(p.bytes(4, p.concat(string(5, '2.2.9.22'), string(6, '2.2.9.22'), p.integer(12, 90), p.integer(13, 0))), string(100, this.stock ? '' : 'EVENCFW/18 img640 fbguard wearnotify cleanup11'));
const payload = p.concat(p.integer(1, message.command), p.integer(2, overrides.magic ?? message.magic), body);
const data = hex(p.concat(...p.frameMessage(payload, overrides.sid ?? message.sid, 0, 12)));
// The right/master link also carries ACKs for image writes to L.
this.emit({ kind: 'notification', identifier: overrides.identifier ?? 'R', characteristic: p.G2_NOTIFY, data });
}
async write(id, characteristic, frame) {
assert.equal(characteristic, p.G2_WRITE); assert.ok(frame.length <= 185);
for (const message of this.receiver.receive(id, frame)) {
this.sent.push({ id, message });
if (!message.magic) continue;
if (this.hold) this.held.push({ id, message });
else queueMicrotask(() => this.ack(id, message));
}
}
}
const addresses = { right: 'AA:BB:CC:DD:EE:01', left: 'AA:BB:CC:DD:EE:02', ring: '' };
async function until(predicate) {
for (let i = 0; i < 100; i++) { if (predicate()) return; await new Promise(resolve => setTimeout(resolve, 5)); }
assert.fail('Timed out waiting for test state');
}
function harness(t, transport = new FakeTransport()) {
const states = [], input = [];
const session = new GlassesSession(transport, deflate, state => states.push(state), event => input.push(event));
t.after(async () => { transport.hold = false; await session.stop(); });
return { transport, session, states, input };
}
test('session authenticates both arms, checks firmware and sends acknowledged display data to L', async t => {
const h = harness(t); await h.session.start({ ...addresses, ring: 'AA:BB:CC:DD:EE:03' });
assert.equal(h.session.state.phase, 'connected'); assert.equal(h.session.state.ring, true);
assert.equal(h.session.state.battery, 90);
assert.deepEqual(h.transport.sent.filter(s => s.message.sid === 128).map(s => s.id).sort(), ['L', 'R']);
h.session.setFrame(new Uint8Array(640 * 480)); await until(() => h.session.state.frames === 1);
const image = h.transport.sent.find(s => s.message.sid === 224 && s.message.command === 3);
assert.equal(image.id, 'L');
const fragment = p.readBytes(image.message.payload, 5), payload = p.readBytes(fragment, 8);
assert.equal(payload[0], 6); assert.ok(inflate(payload.slice(1)).length > 0);
await h.session.stop();
assert.equal(h.session.state.phase, 'disconnected');
assert.ok(h.transport.sent.some(s => s.message.command === 3 && p.readBytes(p.readBytes(s.message.payload, 5), 8)[0] === 11));
});
test('stock firmware is rejected before framebuffer/layout/image commands', async t => {
const transport = new FakeTransport(); transport.stock = true;
const h = harness(t, transport); await h.session.start(addresses);
assert.equal(h.session.state.phase, 'error'); assert.match(h.session.state.status, /modified firmware/);
assert.ok(!transport.sent.some(s => s.message.sid === p.SID.hub));
});
test('disconnect cancels in-flight authentication and ignores late acknowledgements', async t => {
const h = harness(t); h.transport.hold = true;
const start = h.session.start(addresses); await until(() => h.transport.held.length === 2);
await h.session.stop();
for (const held of h.transport.held) h.transport.ack(held.id, held.message);
await start;
assert.equal(h.session.state.phase, 'disconnected');
assert.ok(!h.states.some(s => s.phase === 'connected'));
assert.equal(h.transport.sent.length, 2);
});
test('wrong peer, service or magic cannot satisfy a pending request; timeout rejects it', async t => {
const h = harness(t); await h.session.start(addresses); h.transport.hold = true;
const request = h.session.request('right', p.SID.hub, p.heartbeat, 'test heartbeat', 30);
const rejected = assert.rejects(request, /not acknowledged/);
await until(() => h.transport.held.length > 0);
const held = h.transport.held[0];
h.transport.ack(held.id, held.message, { identifier: 'stranger' });
h.transport.ack(held.id, held.message, { sid: 9 });
h.transport.ack(held.id, held.message, { magic: held.message.magic + 1 });
await rejected;
});
+3
View File
@@ -11,6 +11,9 @@
"outDir": "../.test-build"
},
"include": [
"../app/g2/ble-protocol.ts",
"../app/g2/ios-peripheral-identity.ts",
"../app/g2/glasses-session.ts",
"../app/graphics/surface-compositor.ts",
"../app/phone-ui/phone-gestures.ts",
"../app/g2/glasses-hardware-identity.ts",