mirror of
https://git.undefined-dev.fr/Blendman974/faceclaw.git
synced 2026-11-19 21:03:09 +00:00
Refactor Kotlin for iOS commonality
This commit is contained in:
1 parent
587364e5e6
commit
c3a0ba9f56
31 files changed
+2780
-964
No files matched your search
@@ -1,14 +0,0 @@
|
||||
#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)connect:(NSString *)identifier requiresANCS:(BOOL)requiresANCS 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
|
||||
@@ -1,197 +0,0 @@
|
||||
#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 {
|
||||
[self connect:identifier requiresANCS:NO requestId:requestId];
|
||||
}
|
||||
- (void)connect:(NSString *)identifier requiresANCS:(BOOL)requiresANCS 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:requiresANCS ? @{CBConnectPeripheralOptionRequiresANCS: @YES} : nil];
|
||||
}
|
||||
- (void)centralManager:(CBCentralManager *)central didUpdateANCSAuthorizationForPeripheral:(CBPeripheral *)peripheral {
|
||||
[self emit:@{@"kind": @"ancs-authorization", @"identifier": peripheral.identifier.UUIDString,
|
||||
@"authorized": @(peripheral.ancsAuthorized)}];
|
||||
}
|
||||
- (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,13 +0,0 @@
|
||||
#import <Foundation/Foundation.h>
|
||||
@interface FaceclawRemoteInput : NSObject
|
||||
+ (instancetype)shared;
|
||||
+ (NSString *)interfaces;
|
||||
- (NSString *)start:(int)port;
|
||||
- (NSString *)start:(int)port address:(NSString *)address;
|
||||
- (void)stop;
|
||||
- (void)setRequestListener:(void (^)(void))listener;
|
||||
- (NSString *)nextRequest;
|
||||
- (void)complete:(long long)identifier response:(NSString *)response;
|
||||
- (NSString *)randomSecret;
|
||||
- (NSString *)tokenDigest:(NSString *)value;
|
||||
@end
|
||||
@@ -1,166 +0,0 @@
|
||||
#import "FaceclawRemoteInput.h"
|
||||
#import "FaceclawCrypto.h"
|
||||
#import <Security/Security.h>
|
||||
#import <sys/socket.h>
|
||||
#import <netinet/in.h>
|
||||
#import <unistd.h>
|
||||
#import <poll.h>
|
||||
#import <ifaddrs.h>
|
||||
#import <net/if.h>
|
||||
#import <netdb.h>
|
||||
#import <arpa/inet.h>
|
||||
|
||||
@implementation FaceclawRemoteInput {
|
||||
NSCondition *_condition;
|
||||
int _server, _client;
|
||||
NSUInteger _generation;
|
||||
long long _nextId, _requestId;
|
||||
NSTimeInterval _deadline;
|
||||
NSString *_pending, *_reply;
|
||||
void (^_requestListener)(void);
|
||||
}
|
||||
+ (instancetype)shared {
|
||||
static FaceclawRemoteInput *instance; static dispatch_once_t once;
|
||||
dispatch_once(&once, ^{ instance = [self new]; }); return instance;
|
||||
}
|
||||
- (instancetype)init {
|
||||
if ((self = [super init])) { _condition = [NSCondition new]; _server = _client = -1; }
|
||||
return self;
|
||||
}
|
||||
- (NSString *)start:(int)port { return [self start:port address:@"127.0.0.1"]; }
|
||||
- (NSString *)start:(int)port address:(NSString *)address {
|
||||
[_condition lock];
|
||||
if (_server >= 0) { [_condition unlock]; return @""; }
|
||||
struct addrinfo hints = {0}, *resolved = NULL;
|
||||
hints.ai_flags = AI_NUMERICHOST; hints.ai_socktype = SOCK_STREAM;
|
||||
NSString *service = [NSString stringWithFormat:@"%d", port];
|
||||
if (getaddrinfo(address.UTF8String, service.UTF8String, &hints, &resolved) != 0) {
|
||||
[_condition unlock]; return @"Invalid local address.";
|
||||
}
|
||||
BOOL wildcard = resolved->ai_family == AF_INET ?
|
||||
((struct sockaddr_in *)resolved->ai_addr)->sin_addr.s_addr == INADDR_ANY :
|
||||
IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)resolved->ai_addr)->sin6_addr);
|
||||
if (wildcard) { freeaddrinfo(resolved); [_condition unlock]; return @"Wildcard addresses are not allowed."; }
|
||||
int fd = socket(resolved->ai_family, SOCK_STREAM, 0), yes = 1;
|
||||
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
|
||||
int result = fd < 0 ? -1 : bind(fd, resolved->ai_addr, (socklen_t)resolved->ai_addrlen);
|
||||
freeaddrinfo(resolved);
|
||||
if (result || listen(fd, 8)) {
|
||||
if (fd >= 0) close(fd); [_condition unlock]; return @"Could not open input port on this address.";
|
||||
}
|
||||
_server = fd; NSUInteger generation = ++_generation;
|
||||
[_condition unlock];
|
||||
dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ [self serve:fd generation:generation]; });
|
||||
return @"";
|
||||
}
|
||||
- (void)stop {
|
||||
[_condition lock]; ++_generation;
|
||||
// The serving thread owns close(); shutdown interrupts its blocking I/O.
|
||||
if (_server >= 0) shutdown(_server, SHUT_RDWR);
|
||||
if (_client >= 0) shutdown(_client, SHUT_RDWR);
|
||||
_server = _client = -1; _requestId = 0; _pending = _reply = nil;
|
||||
[_condition broadcast]; [_condition unlock];
|
||||
}
|
||||
- (NSString *)nextRequest {
|
||||
[_condition lock];
|
||||
NSString *result = NSDate.date.timeIntervalSince1970 < _deadline ? _pending : nil;
|
||||
_pending = nil; [_condition unlock]; return result;
|
||||
}
|
||||
- (void)setRequestListener:(void (^)(void))listener {
|
||||
[_condition lock]; _requestListener = [listener copy]; [_condition unlock];
|
||||
}
|
||||
- (void)notifyRequestReady:(long long)identifier {
|
||||
// Dispatch from under the condition lock; invoke JS only on the main thread,
|
||||
// outside the lock, and discard notifications invalidated by stop/timeout.
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
[self->_condition lock];
|
||||
void (^callback)(void) = self->_requestId == identifier && self->_pending &&
|
||||
NSDate.date.timeIntervalSince1970 < self->_deadline ? self->_requestListener : nil;
|
||||
[self->_condition unlock];
|
||||
if (callback) callback();
|
||||
});
|
||||
}
|
||||
- (void)complete:(long long)identifier response:(NSString *)response {
|
||||
[_condition lock];
|
||||
if (_requestId == identifier && NSDate.date.timeIntervalSince1970 < _deadline) { _reply = response; [_condition signal]; }
|
||||
[_condition unlock];
|
||||
}
|
||||
- (void)serve:(int)listener generation:(NSUInteger)generation {
|
||||
for (;;) {
|
||||
[_condition lock]; BOOL current = generation == _generation; [_condition unlock];
|
||||
if (!current) break;
|
||||
// Poll also guarantees stop is observed on platforms where shutdown does not wake accept.
|
||||
struct pollfd p = { .fd = listener, .events = POLLIN };
|
||||
if (poll(&p, 1, 250) <= 0) continue;
|
||||
int client = accept(listener, NULL, NULL);
|
||||
if (client < 0) break;
|
||||
@autoreleasepool {
|
||||
[_condition lock]; current = generation == _generation;
|
||||
if (current) _client = client;
|
||||
[_condition unlock];
|
||||
if (!current) { close(client); break; }
|
||||
struct timeval timeout = {5, 0}; int yes = 1;
|
||||
setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
|
||||
setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
|
||||
setsockopt(client, SOL_SOCKET, SO_NOSIGPIPE, &yes, sizeof(yes));
|
||||
NSTimeInterval readDeadline = NSDate.date.timeIntervalSince1970 + 5;
|
||||
NSMutableData *body = [NSMutableData new]; unsigned char byte; BOOL complete = NO;
|
||||
while (body.length <= 65536) {
|
||||
NSTimeInterval remaining = readDeadline - NSDate.date.timeIntervalSince1970;
|
||||
struct pollfd input = { .fd = client, .events = POLLIN };
|
||||
if (remaining <= 0 || poll(&input, 1, (int)(remaining * 1000)) <= 0 || recv(client, &byte, 1, 0) != 1) break;
|
||||
if (byte == '\n') { complete = YES; break; }
|
||||
[body appendBytes:&byte length:1];
|
||||
}
|
||||
NSString *text = complete ? [[NSString alloc] initWithData:body encoding:NSUTF8StringEncoding] : nil;
|
||||
if (text) {
|
||||
[_condition lock];
|
||||
if (generation == _generation) {
|
||||
_requestId = ++_nextId; _deadline = NSDate.date.timeIntervalSince1970 + 5; _reply = nil;
|
||||
NSData *json = [NSJSONSerialization dataWithJSONObject:@{@"id":@(_requestId), @"expiresAt":@(_deadline * 1000), @"body":text} options:0 error:nil];
|
||||
_pending = [[NSString alloc] initWithData:json encoding:NSUTF8StringEncoding];
|
||||
[self notifyRequestReady:_requestId];
|
||||
while (!_reply && generation == _generation && NSDate.date.timeIntervalSince1970 < _deadline)
|
||||
[_condition waitUntilDate:[NSDate dateWithTimeIntervalSince1970:_deadline]];
|
||||
NSString *reply = _reply ?: @"{\"ok\":false,\"error\":\"timeout\",\"message\":\"Faceclaw did not respond in time.\"}";
|
||||
if (generation == _generation) { _pending = _reply = nil; _requestId = 0; }
|
||||
[_condition unlock];
|
||||
NSData *data = [[reply stringByAppendingString:@"\n"] dataUsingEncoding:NSUTF8StringEncoding];
|
||||
NSUInteger offset = 0;
|
||||
while (offset < data.length) {
|
||||
ssize_t n = send(client, (const char *)data.bytes + offset, data.length - offset, 0);
|
||||
if (n <= 0) break; offset += n;
|
||||
}
|
||||
} else [_condition unlock];
|
||||
}
|
||||
[_condition lock]; if (generation == _generation) _client = -1; [_condition unlock];
|
||||
close(client);
|
||||
}
|
||||
}
|
||||
close(listener);
|
||||
[_condition lock]; if (generation == _generation) _server = -1; [_condition unlock];
|
||||
}
|
||||
+ (NSString *)interfaces {
|
||||
NSMutableArray *result = [NSMutableArray new]; struct ifaddrs *interfaces = NULL;
|
||||
if (getifaddrs(&interfaces) == 0) {
|
||||
for (struct ifaddrs *item = interfaces; item; item = item->ifa_next) {
|
||||
if (!item->ifa_addr || !(item->ifa_flags & IFF_UP) || (item->ifa_flags & IFF_LOOPBACK)) continue;
|
||||
int family = item->ifa_addr->sa_family;
|
||||
if (family != AF_INET && family != AF_INET6) continue;
|
||||
char address[NI_MAXHOST];
|
||||
if (getnameinfo(item->ifa_addr, item->ifa_addr->sa_len, address, sizeof(address), NULL, 0, NI_NUMERICHOST)) continue;
|
||||
[result addObject:@{@"name":@(item->ifa_name), @"address":@(address), @"pointToPoint":@((item->ifa_flags & IFF_POINTOPOINT) != 0)}];
|
||||
}
|
||||
freeifaddrs(interfaces);
|
||||
}
|
||||
return [[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:result options:0 error:nil] encoding:NSUTF8StringEncoding];
|
||||
}
|
||||
- (NSString *)randomSecret {
|
||||
unsigned char bytes[32];
|
||||
if (SecRandomCopyBytes(kSecRandomDefault, sizeof(bytes), bytes) != errSecSuccess) return @"";
|
||||
NSMutableString *hex = [NSMutableString new];
|
||||
for (NSUInteger i = 0; i < sizeof(bytes); i++) [hex appendFormat:@"%02x", bytes[i]];
|
||||
return hex;
|
||||
}
|
||||
- (NSString *)tokenDigest:(NSString *)value { return [FaceclawCrypto sha256:[value dataUsingEncoding:NSUTF8StringEncoding]]; }
|
||||
@end
|
||||
@@ -1,8 +0,0 @@
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
/** Streaming POST. Events are polled by the owning JS isolate, including workers. */
|
||||
@interface FaceclawSseRequest : NSObject <NSURLSessionDataDelegate>
|
||||
- (instancetype)initWithURL:(NSString *)url body:(NSString *)body headers:(NSString *)headersJson;
|
||||
- (NSString *)takeEvents;
|
||||
- (void)cancel;
|
||||
@end
|
||||
@@ -1,153 +0,0 @@
|
||||
#import "FaceclawSseRequest.h"
|
||||
#import <TargetConditionals.h>
|
||||
#if TARGET_OS_IOS
|
||||
#import <UIKit/UIKit.h>
|
||||
#endif
|
||||
|
||||
@interface FaceclawSseRequest ()
|
||||
@property(nonatomic, strong) NSURLSession *session;
|
||||
@property(nonatomic, strong) NSURLSessionDataTask *task;
|
||||
@property(nonatomic, strong) NSMutableData *buffer;
|
||||
@property(nonatomic, strong) NSMutableArray *events;
|
||||
@property(nonatomic) NSUInteger queuedBytes;
|
||||
@property(nonatomic) NSInteger status;
|
||||
@property(nonatomic) BOOL finished;
|
||||
@property(nonatomic) BOOL cancelled;
|
||||
@property(nonatomic) BOOL firstLine;
|
||||
#if TARGET_OS_IOS
|
||||
@property(nonatomic) UIBackgroundTaskIdentifier backgroundTask;
|
||||
#endif
|
||||
@end
|
||||
|
||||
@implementation FaceclawSseRequest
|
||||
- (instancetype)initWithURL:(NSString *)url body:(NSString *)body headers:(NSString *)headersJson {
|
||||
if ((self = [super init])) {
|
||||
_buffer = [NSMutableData new]; _events = [NSMutableArray new]; _firstLine = YES;
|
||||
#if TARGET_OS_IOS
|
||||
_backgroundTask = UIBackgroundTaskInvalid;
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
@synchronized(self) {
|
||||
if (self.cancelled || self.finished) return;
|
||||
self.backgroundTask = [UIApplication.sharedApplication beginBackgroundTaskWithName:@"Assistant response" expirationHandler:^{
|
||||
[self finish:@{@"kind": @"failure", @"text": @"iOS background time expired. Open Faceclaw and retry."}];
|
||||
[self endBackgroundTask];
|
||||
}];
|
||||
}
|
||||
});
|
||||
#endif
|
||||
NSURL *target = [NSURL URLWithString:url];
|
||||
if (!target || ![@[@"https", @"http"] containsObject:target.scheme.lowercaseString]) {
|
||||
[self finish:@{@"kind": @"failure", @"text": @"Invalid streaming URL"}]; return self;
|
||||
}
|
||||
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:target];
|
||||
request.HTTPMethod = @"POST";
|
||||
request.HTTPBody = [body dataUsingEncoding:NSUTF8StringEncoding];
|
||||
[request setValue:@"application/json; charset=utf-8" forHTTPHeaderField:@"Content-Type"];
|
||||
[request setValue:@"text/event-stream" forHTTPHeaderField:@"Accept"];
|
||||
NSDictionary *headers = [NSJSONSerialization JSONObjectWithData:[headersJson dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
|
||||
if ([headers isKindOfClass:NSDictionary.class]) for (NSString *name in headers) {
|
||||
if ([headers[name] isKindOfClass:NSString.class]) [request setValue:headers[name] forHTTPHeaderField:name];
|
||||
}
|
||||
NSURLSessionConfiguration *config = NSURLSessionConfiguration.ephemeralSessionConfiguration;
|
||||
config.timeoutIntervalForRequest = 180;
|
||||
config.timeoutIntervalForResource = 180;
|
||||
_session = [NSURLSession sessionWithConfiguration:config delegate:self delegateQueue:nil];
|
||||
_task = [_session dataTaskWithRequest:request];
|
||||
[_task resume];
|
||||
}
|
||||
return self;
|
||||
}
|
||||
- (void)endBackgroundTask {
|
||||
#if TARGET_OS_IOS
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
@synchronized(self) {
|
||||
if (self.backgroundTask == UIBackgroundTaskInvalid) return;
|
||||
[UIApplication.sharedApplication endBackgroundTask:self.backgroundTask];
|
||||
self.backgroundTask = UIBackgroundTaskInvalid;
|
||||
}
|
||||
});
|
||||
#endif
|
||||
}
|
||||
- (void)finish:(NSDictionary *)event {
|
||||
@synchronized(self) {
|
||||
if (_finished || _cancelled) return;
|
||||
_finished = YES; [_events addObject:event];
|
||||
[_session invalidateAndCancel]; _session = nil; _task = nil;
|
||||
[_buffer setLength:0];
|
||||
}
|
||||
}
|
||||
- (NSString *)takeEvents {
|
||||
@synchronized(self) {
|
||||
NSData *data = [NSJSONSerialization dataWithJSONObject:_events options:0 error:nil];
|
||||
[_events removeAllObjects]; _queuedBytes = 0;
|
||||
if (_finished) [self endBackgroundTask];
|
||||
return [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding] ?: @"[]";
|
||||
}
|
||||
}
|
||||
- (void)cancel {
|
||||
@synchronized(self) {
|
||||
_cancelled = YES;
|
||||
[_events removeAllObjects]; [_buffer setLength:0]; _queuedBytes = 0;
|
||||
[_session invalidateAndCancel]; _session = nil; _task = nil;
|
||||
[self endBackgroundTask];
|
||||
}
|
||||
}
|
||||
- (void)line:(NSData *)data {
|
||||
NSString *line = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
|
||||
if (!line) { [self finish:@{@"kind": @"failure", @"text": @"Invalid UTF-8 in streaming response"}]; return; }
|
||||
if (_firstLine && [line hasPrefix:@"\uFEFF"]) line = [line substringFromIndex:1];
|
||||
_firstLine = NO;
|
||||
_queuedBytes += data.length;
|
||||
if (_queuedBytes > 8 * 1024 * 1024 || _events.count >= 16384) {
|
||||
[_events removeAllObjects];
|
||||
[self finish:@{@"kind": @"failure", @"text": @"Streaming response queue overflow"}]; return;
|
||||
}
|
||||
[_events addObject:@{@"kind": @"line", @"text": line}];
|
||||
}
|
||||
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)task didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler {
|
||||
@synchronized(self) { _status = [(NSHTTPURLResponse *)response statusCode]; }
|
||||
completionHandler(NSURLSessionResponseAllow);
|
||||
}
|
||||
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest *))completionHandler {
|
||||
// Never forward provider credentials to a redirected endpoint.
|
||||
completionHandler(nil);
|
||||
}
|
||||
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)task didReceiveData:(NSData *)data {
|
||||
@synchronized(self) {
|
||||
if (_finished || _cancelled) return;
|
||||
if (_status < 200 || _status >= 300) {
|
||||
NSUInteger remaining = 65536 - _buffer.length;
|
||||
[_buffer appendData:[data subdataWithRange:NSMakeRange(0, MIN(remaining, data.length))]];
|
||||
return;
|
||||
}
|
||||
[_buffer appendData:data];
|
||||
NSUInteger start = 0;
|
||||
const uint8_t *bytes = _buffer.bytes;
|
||||
for (NSUInteger i = 0; i < _buffer.length; i++) {
|
||||
if (bytes[i] != '\r' && bytes[i] != '\n') continue;
|
||||
if (bytes[i] == '\r' && i + 1 == _buffer.length) break;
|
||||
[self line:[_buffer subdataWithRange:NSMakeRange(start, i - start)]];
|
||||
if (_finished) return;
|
||||
if (bytes[i] == '\r' && bytes[i + 1] == '\n') i++;
|
||||
start = i + 1;
|
||||
}
|
||||
if (start) [_buffer replaceBytesInRange:NSMakeRange(0, start) withBytes:NULL length:0];
|
||||
if (_buffer.length > 2 * 1024 * 1024) [self finish:@{@"kind": @"failure", @"text": @"Streaming response line too large"}];
|
||||
}
|
||||
}
|
||||
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
|
||||
@synchronized(self) {
|
||||
if (_finished || _cancelled) return;
|
||||
if (error) { [self finish:@{@"kind": @"failure", @"text": error.localizedDescription}]; return; }
|
||||
if (_status < 200 || _status >= 300) {
|
||||
NSString *body = [[NSString alloc] initWithData:_buffer encoding:NSUTF8StringEncoding] ?: @"";
|
||||
[self finish:@{@"kind": @"http-error", @"code": @(_status), @"text": body}]; return;
|
||||
}
|
||||
if (_buffer.length) {
|
||||
if (((const uint8_t *)_buffer.bytes)[_buffer.length - 1] == '\r') [_buffer setLength:_buffer.length - 1];
|
||||
[self line:_buffer];
|
||||
}
|
||||
[self finish:@{@"kind": @"complete"}];
|
||||
}
|
||||
}
|
||||
@end
|
||||
@@ -1,91 +0,0 @@
|
||||
/** Stock EVENOTA validation and transfer, matching Android's flasher/g2flash.py. */
|
||||
import { StockConnection, OTA_WRITE, OTA_NOTIFY } from './stock-connection'
|
||||
import { concat } from './ble-protocol'
|
||||
import type { FlashProgress } from './firmware-types'
|
||||
|
||||
export type FirmwareSegment = { offset: number; size: number; name: string }
|
||||
const CRC_TABLE = Array.from({ length: 256 }, (_, b) => {
|
||||
let c = b << 24
|
||||
for (let i = 0; i < 8; i++) c = c & 0x80000000 ? (c << 1) ^ 0x1edc6f41 : c << 1
|
||||
return c >>> 0
|
||||
})
|
||||
export function firmwareCrc(data: Uint8Array): number {
|
||||
let crc = 0
|
||||
for (const byte of data) crc = (crc << 8) ^ CRC_TABLE[((crc >>> 24) ^ byte) & 255]
|
||||
return crc >>> 0
|
||||
}
|
||||
export function validateFirmware(image: Uint8Array): FirmwareSegment[] {
|
||||
const u32 = (offset: number) => {
|
||||
if (offset < 0 || offset + 4 > image.length) throw new Error('Firmware header is truncated.')
|
||||
return new DataView(image.buffer, image.byteOffset, image.byteLength).getUint32(offset, true)
|
||||
}
|
||||
if (image.length < 0x40) throw new Error('File is too small to be a firmware image.')
|
||||
const count = u32(8)
|
||||
if (count < 5 || count > 6 || 0x40 + count * 16 > image.length) throw new Error('Expected 5–6 firmware components.')
|
||||
const segments: FirmwareSegment[] = []
|
||||
for (let i = 0; i < count; i++) {
|
||||
const toc = 0x40 + i * 16, offset = u32(toc + 4)
|
||||
if (offset < 0x40 + count * 16 || offset + 128 > image.length) throw new Error('Firmware component header is out of bounds.')
|
||||
const size = u32(offset + 8), end = offset + 128 + size
|
||||
if (!size || end > image.length) throw new Error('Firmware component payload is truncated.')
|
||||
if (segments.some(s => offset < s.offset + 128 + s.size && s.offset < end)) throw new Error('Firmware components overlap.')
|
||||
const nameBytes = image.subarray(offset + 48, offset + 128)
|
||||
const name = String.fromCharCode(...nameBytes.subarray(0, nameBytes.indexOf(0) < 0 ? 80 : nameBytes.indexOf(0)))
|
||||
const crc = firmwareCrc(image.subarray(offset + 128, end))
|
||||
if (crc !== u32(toc + 12) || crc !== u32(offset + 12)) throw new Error(`Component ${name} CRC32C is stale (image not checksum-fixed).`)
|
||||
segments.push({ offset, size, name })
|
||||
}
|
||||
const mains = segments.filter(s => s.name === 'ota/s200_firmware_ota.bin')
|
||||
if (mains.length !== 1) throw new Error('Required main firmware component is missing or duplicated.')
|
||||
const main = mains[0], payload = main.offset + 128
|
||||
if (main.size < 32 || u32(payload + 0x14) !== 0x00438000 || (u32(payload) & 0xffffff) !== main.size)
|
||||
throw new Error('Main-app preamble load address or length is invalid.')
|
||||
if (0x00438000 + main.size - 32 > 0x007f0000) throw new Error('Main-app exceeds the safe MRAM ceiling — refusing to flash.')
|
||||
return segments
|
||||
}
|
||||
|
||||
export async function flashLensImage(link: StockConnection, role: string, image: Uint8Array, segments: FirmwareSegment[],
|
||||
progress: (value: FlashProgress) => void, log: (line: string) => void,
|
||||
delay: (ms: number) => Promise<void>): Promise<void> {
|
||||
let sequence = 0
|
||||
const ctrl = async (op: number, payload = new Uint8Array(), data?: Uint8Array): Promise<number> => {
|
||||
sequence = (sequence + 1) & 255
|
||||
const message = await link.exchange(role, 0xc0, concat(new Uint8Array([op]), payload),
|
||||
message => message.command === op, data ? 4000 : 8000, OTA_WRITE, OTA_NOTIFY, 0, sequence, data)
|
||||
return message.payload[1]
|
||||
}
|
||||
const accepted = (status: number) => [0, 8, 9].includes(status)
|
||||
const begin = await ctrl(0)
|
||||
if (!accepted(begin)) throw new Error(`OTA BEGIN rejected (status ${begin}).`)
|
||||
const total = segments.reduce((sum, segment) => sum + segment.size, 0)
|
||||
let before = 0
|
||||
for (const [index, segment] of segments.entries()) {
|
||||
let verified = false, failure: unknown
|
||||
for (let attempt = 0; attempt < 3; attempt++) {
|
||||
link.check()
|
||||
if (attempt) { log(`${segment.name}: re-flash attempt ${attempt + 1}/3`); await delay(1500) }
|
||||
try {
|
||||
const status = await ctrl(1, image.slice(segment.offset, segment.offset + 128))
|
||||
if (status !== 0) throw new Error(`FILE_CHECK rejected (status ${status}).`)
|
||||
const blocks = Math.ceil(segment.size / 4096)
|
||||
for (let block = 0; block < blocks; block++) {
|
||||
const start = segment.offset + 128 + block * 4096
|
||||
const data = image.slice(start, Math.min(start + 4096, segment.offset + 128 + segment.size))
|
||||
let ok = false
|
||||
for (let retry = 0; retry < 3; retry++) {
|
||||
if (await ctrl(2, new Uint8Array(), data) === 0) { ok = true; break }
|
||||
}
|
||||
if (!ok) throw new Error(`Block ${block + 1} rejected three times.`)
|
||||
if (block % 20 === 0 || block === blocks - 1)
|
||||
progress({ lens: role, componentIndex: index + 1, componentCount: segments.length, blockIndex: block + 1,
|
||||
blockCount: blocks, bytesSent: before + Math.min((block + 1) * 4096, segment.size), bytesTotal: total })
|
||||
}
|
||||
const end = await ctrl(3)
|
||||
if (!accepted(end)) throw new Error(`END verification failed (status ${end}).`)
|
||||
log(`${role} ${segment.name}: END verify OK (status ${end})`); verified = true; break
|
||||
} catch (error) { link.check(); failure = error }
|
||||
}
|
||||
if (!verified) throw new Error(`Component ${segment.name} failed after 3 attempts: ${failure}`)
|
||||
before += segment.size
|
||||
}
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
import { bytes, concat, integer, readBytes, readInteger, readString, type ProtocolMessage } from './ble-protocol'
|
||||
const text = (field: number, value: string) => bytes(field, new Uint8Array(Array.from(value, ch => ch.charCodeAt(0))))
|
||||
export function createFlashPrompt(magic: number, warning: string): Uint8Array {
|
||||
const geometry = (y: number, height: number, id: number, name: string) => concat(
|
||||
integer(1, 0), integer(2, y), integer(3, 280), integer(4, height), integer(9, id), text(10, name))
|
||||
const list = concat(geometry(150, 120, 2, 'flashmenu'), bytes(11, concat(integer(1, 2), integer(3, 1), text(4, 'No, cancel'), text(4, 'Yes, flash'))), integer(12, 1))
|
||||
const label = concat(geometry(0, 130, 1, 'flashwarn'), text(12, warning))
|
||||
return concat(integer(1, 0), integer(2, magic), bytes(3, concat(integer(1, 2), bytes(2, list), bytes(3, label), integer(5, 10000))))
|
||||
}
|
||||
export function flashPromptSelection(message: ProtocolMessage): boolean | null {
|
||||
if (message.sid !== 0xe0 || ![1, 6].includes(message.flag)) return null
|
||||
const event = readBytes(message.payload, 13), list = event && readBytes(event, 1)
|
||||
if (!list || readString(list, 2) !== 'flashmenu' || readInteger(list, 5, 0) !== 0) return null
|
||||
const index = readInteger(list, 4, -1), name = readString(list, 3).toLowerCase()
|
||||
if (index === 1 || name.startsWith('yes')) return true
|
||||
if (index === 0 || name.startsWith('no')) return false
|
||||
return null
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
import * as p from './ble-protocol'
|
||||
import type { SessionTransport, SessionAddresses, TransportEvent } from './glasses-session'
|
||||
import { hexToBytes } from '../util/hex-util'
|
||||
|
||||
declare function setTimeout(callback: () => void, ms: number): number
|
||||
declare function clearTimeout(id: number): void
|
||||
|
||||
export const OTA_WRITE = '00002760-08c2-11e1-9073-0e8ac72e0001'
|
||||
export const OTA_NOTIFY = '00002760-08c2-11e1-9073-0e8ac72e0002'
|
||||
export class StockTimeout extends Error {}
|
||||
type Waiter = { role: string; characteristic: string; match: (message: p.ProtocolMessage) => boolean;
|
||||
resolve: (message: p.ProtocolMessage) => void; reject: (error: Error) => void; timer: ReturnType<typeof setTimeout> | null }
|
||||
|
||||
/** Exclusive, short-lived stock-protocol connection for onboarding/OTA. No display pump. */
|
||||
export class StockConnection {
|
||||
ids: Record<string, string> = {}
|
||||
private limits: Record<string, number> = {}
|
||||
private receiver = new p.MessageReceiver()
|
||||
private waiters = new Set<Waiter>()
|
||||
private listeners = new Set<(role: string, message: p.ProtocolMessage) => void>()
|
||||
private lost = new Set<string>()
|
||||
private writes = new Map<string, Promise<void>>()
|
||||
private closed = false
|
||||
private magic = 0x60
|
||||
private sequence = 0
|
||||
private off: () => void
|
||||
constructor(private transport: SessionTransport, private log: (line: string) => void = () => {}) {
|
||||
this.off = transport.onEvent(event => this.receive(event))
|
||||
}
|
||||
check(): void { if (this.closed) throw new Error('Cancelled.') }
|
||||
isConnected(role: string): boolean { return !this.closed && !!this.limits[role] && !this.lost.has(role) }
|
||||
async resolve(addresses: SessionAddresses): Promise<void> {
|
||||
this.ids = await this.transport.resolveDevices(addresses); this.check()
|
||||
}
|
||||
async connect(role: string, ota = false): Promise<void> {
|
||||
this.check(); this.lost.delete(role)
|
||||
const id = this.ids[role]
|
||||
if (!id) throw new Error(`No ${role} lens configured.`)
|
||||
const details = await this.transport.connect(id)
|
||||
if (this.closed) { this.transport.disconnect(id); this.check() }
|
||||
this.limits[role] = details.maxWrite
|
||||
for (const characteristic of [p.G2_WRITE, p.G2_NOTIFY, ...(ota ? [OTA_WRITE, OTA_NOTIFY] : [])])
|
||||
if (!details.characteristics.includes(characteristic)) throw new Error(`${role} lens is missing ${ota ? 'firmware update' : 'G2'} characteristics.`)
|
||||
await this.transport.subscribe(id, p.G2_NOTIFY); this.check()
|
||||
if (ota) { await this.transport.subscribe(id, OTA_NOTIFY); this.check() }
|
||||
}
|
||||
nextMagic(): number { this.magic = this.magic >= 0x7f ? 0x60 : this.magic + 1; return this.magic }
|
||||
async authenticate(role: string): Promise<void> {
|
||||
for (let attempt = 0; attempt < 2; attempt++) {
|
||||
const magic = this.nextMagic()
|
||||
try {
|
||||
await this.exchange(role, p.SID.auth, p.authentication(magic),
|
||||
message => p.authenticationSucceeded(message, magic), 30_000, p.G2_WRITE, p.G2_NOTIFY, 0)
|
||||
this.log(`Security authentication complete: ${role} lens`); return
|
||||
} catch (error) { this.check(); if (!(error instanceof StockTimeout) || attempt === 1) throw error }
|
||||
}
|
||||
}
|
||||
request(role: string, sid: number, build: (magic: number) => Uint8Array, timeout = 3500, fixedMagic?: number): Promise<p.ProtocolMessage> {
|
||||
const magic = fixedMagic ?? this.nextMagic()
|
||||
return this.exchange(role, sid, build(magic), message => message.sid === sid && message.magic === magic && ![1, 6].includes(message.flag), timeout)
|
||||
}
|
||||
write(role: string, sid: number, payload: Uint8Array, characteristic = p.G2_WRITE, flag = 0x20, sequence = ++this.sequence): Promise<void> {
|
||||
// Keep a fragmented control message together when the prompt heartbeat
|
||||
// overlaps a settings request or shutdown.
|
||||
const pending = (this.writes.get(role) ?? Promise.resolve()).catch(() => {}).then(async () => {
|
||||
this.check()
|
||||
for (const frame of p.frameMessage(payload, sid, flag, sequence, this.limits[role])) {
|
||||
this.check()
|
||||
if (this.lost.has(role)) throw new Error(`Lost connection to the ${role} lens.`)
|
||||
await this.transport.write(this.ids[role], characteristic, frame)
|
||||
}
|
||||
this.check()
|
||||
if (this.lost.has(role)) throw new Error(`Lost connection to the ${role} lens.`)
|
||||
})
|
||||
this.writes.set(role, pending)
|
||||
return pending
|
||||
}
|
||||
exchange(role: string, sid: number, payload: Uint8Array, match: Waiter['match'], timeout: number,
|
||||
write = p.G2_WRITE, notify = p.G2_NOTIFY, flag = 0x20, sequence?: number, data?: Uint8Array): Promise<p.ProtocolMessage> {
|
||||
this.check()
|
||||
return new Promise((resolve, reject) => {
|
||||
let written = false, reply: p.ProtocolMessage | null = null
|
||||
const waiter: Waiter = { role, characteristic: notify, match,
|
||||
resolve: message => { reply = message; if (written) resolve(message) }, reject,
|
||||
timer: null }
|
||||
this.waiters.add(waiter)
|
||||
void (async () => {
|
||||
await this.write(role, sid, payload, write, flag, sequence)
|
||||
if (data) await this.write(role, 0xc1, data, write, flag, sequence)
|
||||
this.check()
|
||||
if (!reply && !this.waiters.has(waiter)) return
|
||||
written = true
|
||||
if (reply) resolve(reply)
|
||||
else waiter.timer = setTimeout(() => {
|
||||
this.waiters.delete(waiter)
|
||||
reject(new StockTimeout(`No response from the ${role} lens (0x${sid.toString(16)}).`))
|
||||
}, timeout)
|
||||
})().catch(error => { this.waiters.delete(waiter); if (waiter.timer !== null) clearTimeout(waiter.timer); reject(error) })
|
||||
})
|
||||
}
|
||||
|
||||
onMessage(listener: (role: string, message: p.ProtocolMessage) => void): () => void {
|
||||
this.listeners.add(listener); return () => this.listeners.delete(listener)
|
||||
}
|
||||
private receive(event: TransportEvent): void {
|
||||
if (this.closed) return
|
||||
const role = Object.keys(this.ids).find(role => this.ids[role] === event.identifier)
|
||||
if (!role) return
|
||||
if (event.kind === 'disconnected') {
|
||||
this.lost.add(role)
|
||||
for (const waiter of [...this.waiters]) if (waiter.role === role) {
|
||||
this.waiters.delete(waiter); if (waiter.timer !== null) clearTimeout(waiter.timer); waiter.reject(new Error(`Lost connection to the ${role} lens.`))
|
||||
}
|
||||
return
|
||||
}
|
||||
if (event.kind !== 'notification' || !event.data || ![p.G2_NOTIFY, OTA_NOTIFY].includes(event.characteristic!)) return
|
||||
try {
|
||||
const data = hexToBytes(event.data)
|
||||
const messages = event.characteristic === OTA_NOTIFY ? decodeOtaAcks(data) : this.receiver.receive(event.identifier!, data)
|
||||
for (const message of messages) {
|
||||
for (const waiter of [...this.waiters]) if (waiter.role === role && waiter.characteristic === event.characteristic && waiter.match(message)) {
|
||||
this.waiters.delete(waiter); if (waiter.timer !== null) clearTimeout(waiter.timer); waiter.resolve(message)
|
||||
}
|
||||
if (event.characteristic === p.G2_NOTIFY) for (const listener of this.listeners) listener(role, message)
|
||||
}
|
||||
} catch (error) { this.log(`Ignored malformed onboarding notification: ${error}`) }
|
||||
}
|
||||
disconnect(role: string): void { this.lost.add(role); if (this.ids[role]) this.transport.disconnect(this.ids[role]); this.receiver.clear() }
|
||||
close(): void {
|
||||
if (this.closed) return
|
||||
this.closed = true; this.off(); this.transport.stopScan()
|
||||
for (const waiter of this.waiters) { if (waiter.timer !== null) clearTimeout(waiter.timer); waiter.reject(new Error('Cancelled.')) }
|
||||
this.waiters.clear(); this.listeners.clear()
|
||||
for (const role of Object.keys(this.ids)) this.disconnect(role)
|
||||
}
|
||||
}
|
||||
|
||||
/** OTA ACKs are raw opcode/status bytes, not protobuf; validate the aa21 CRC envelope. */
|
||||
export function decodeOtaAcks(data: Uint8Array): p.ProtocolMessage[] {
|
||||
const messages: p.ProtocolMessage[] = []
|
||||
for (let offset = 0; offset + 8 <= data.length;) {
|
||||
const n = data[offset + 3], end = offset + 8 + n
|
||||
if (end > data.length) break
|
||||
if (data[offset] === 0xaa && [0x12, 0x21].includes(data[offset + 1]) && data[offset + 4] === 1 && data[offset + 5] === 1 && n >= 4) {
|
||||
const payload = data.slice(offset + 8, end - 2)
|
||||
if (p.crc16(payload) === (data[end - 2] | data[end - 1] << 8))
|
||||
messages.push({ sid: data[offset + 6], flag: data[offset + 7], payload, command: payload[0], magic: -1 })
|
||||
}
|
||||
offset = end
|
||||
}
|
||||
return messages
|
||||
}
|
||||
+2
-2
@@ -19,7 +19,7 @@ object FirmwareImage {
|
||||
const val TOC_ENTRY_SIZE = 16
|
||||
const val SUBHEADER_SIZE = 128
|
||||
const val NAME_OFFSET = 48
|
||||
const val NAME_MAX = 80
|
||||
const val NAME_LENGTH = 80
|
||||
|
||||
// Firmware 2.2.4 has 5 components; 2.2.6 has 6.
|
||||
const val MIN_SEGMENTS = 5
|
||||
@@ -107,7 +107,7 @@ object FirmwareImage {
|
||||
if (psLong <= 0 || off + SUBHEADER_SIZE + psLong > img.size) {
|
||||
throw IllegalStateException("segment $i payload is truncated")
|
||||
}
|
||||
val name = readCString(img, off + NAME_OFFSET, NAME_MAX)
|
||||
val name = readCString(img, off + NAME_OFFSET, NAME_LENGTH)
|
||||
val seg = Segment(off, psLong.toInt(), crc, name)
|
||||
for (other in segs) {
|
||||
if (seg.off < other.end && other.off < seg.end) {
|
||||
|
||||
+46
@@ -32,6 +32,10 @@ class GlassesSessionCore(
|
||||
companion object {
|
||||
const val TAG = "FaceclawComm"
|
||||
|
||||
/** Relay-frame signature ('A','N') checked by [rawFrameTap]. */
|
||||
internal const val RELAY_TAG_A: Byte = 0x41
|
||||
internal const val RELAY_TAG_N: Byte = 0x4e
|
||||
|
||||
// Local metadata for custom-command bookkeeping, not an EvenHub container.
|
||||
// Submitted frames supply pixel geometry; the stock layout only captures input.
|
||||
internal val DASHBOARD_TILE: BleProtocol.ImageTileOptions =
|
||||
@@ -102,6 +106,14 @@ class GlassesSessionCore(
|
||||
internal val ringAddress: String = ringAddress?.trim() ?: ""
|
||||
|
||||
@Volatile internal var listener: FaceclawBleCommunicatorListener? = null
|
||||
|
||||
/**
|
||||
* Optional tap for relay frames the session does not interpret: notifications on the
|
||||
* right arm's data characteristic whose first two bytes are 'A','N' (the iOS ANCS
|
||||
* notification relay, consumed by the phone-side ANCS client). Unset (Android) they
|
||||
* fall through to the normal frame parser exactly as before. Called on the BLE thread.
|
||||
*/
|
||||
@Volatile internal var rawFrameTap: ((ByteArray) -> Unit)? = null
|
||||
internal val imuListeners = CopyOnWriteList<FaceclawImuListener>(platform)
|
||||
/** A compass subscriber plus the dispatcher it registered from (see addCompassListener). */
|
||||
internal class CompassSubscription(
|
||||
@@ -309,6 +321,33 @@ class GlassesSessionCore(
|
||||
// ---------------------------------------------------------------------
|
||||
// Lifecycle
|
||||
|
||||
/** See [rawFrameTap]; null restores the default (frames parsed by the session). */
|
||||
fun setRawFrameTap(tap: ((ByteArray) -> Unit)?) {
|
||||
rawFrameTap = tap
|
||||
}
|
||||
|
||||
/**
|
||||
* Write one already-framed packet to an arm outside the message scheduler (the ANCS
|
||||
* relay client builds its own packets). Blocks like any link write; false when the
|
||||
* arm is unknown, the link rejects the write, or the session is not running.
|
||||
*/
|
||||
fun writeRawPacket(arm: String, packet: ByteArray): Boolean {
|
||||
val address = when (arm.uppercase()) {
|
||||
"R", "RIGHT" -> rightAddress
|
||||
"L", "LEFT" -> leftAddress
|
||||
else -> return false
|
||||
}
|
||||
val active = monitor.withLock { running }
|
||||
if (!active) return false
|
||||
return try {
|
||||
link.writeFrames(address, BleProtocol.WRITE_CHAR_UUID, listOf(packet), ConnectionOptions.WRITE_MODE,
|
||||
ConnectionOptions.WRITE_TIMEOUT_MS)
|
||||
} catch (t: Throwable) {
|
||||
logLine("raw packet write failed: " + safeMessage(t))
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fun setListener(listener: FaceclawBleCommunicatorListener?) {
|
||||
this.listener = listener
|
||||
emitState()
|
||||
@@ -1308,6 +1347,13 @@ class GlassesSessionCore(
|
||||
interruptibleSleep.interrupt()
|
||||
return
|
||||
}
|
||||
val tap = rawFrameTap
|
||||
if (tap != null && data.size >= 2 && data[0] == RELAY_TAG_A && data[1] == RELAY_TAG_N
|
||||
&& address.equals(rightAddress, ignoreCase = true)) {
|
||||
monitor.withLock { lastIncomingAtMs = now() }
|
||||
tap(data.copyOf())
|
||||
return
|
||||
}
|
||||
logDebug("onNotification: address=" + address + " characteristicUuid=" + characteristicUuid + " data.length=" + data.size)
|
||||
val frame = BleProtocol.parseFrame(data)
|
||||
val decodedWearState = BleProtocol.parseWearState(frame)
|
||||
|
||||
+9
-4
@@ -132,7 +132,8 @@ class RemoteInputSession(
|
||||
fun randomSecret(): String = BinaryEncoding.bytesToHex(random.nextBytes(32))
|
||||
|
||||
private fun notifyRequestReady(id: Long) {
|
||||
// Called with the condition held; dispatching keeps JS off the socket thread and outside the lock.
|
||||
// Called WITHOUT the condition held (ProtocolCondition is not reentrant on iOS, and a
|
||||
// dispatcher may run the closure inline); the closure re-checks the request under the lock.
|
||||
dispatch {
|
||||
val callback = condition.withLock {
|
||||
if (requestId != id || pending == null || wallClock() >= deadline) null else requestListener
|
||||
@@ -150,14 +151,18 @@ class RemoteInputSession(
|
||||
client = connection
|
||||
}
|
||||
val text = readFrame(connection) ?: continue
|
||||
val response: String = condition.withLock {
|
||||
val id = condition.withLock {
|
||||
if (server !== listener) return
|
||||
requestId = ++nextId
|
||||
deadline = wallClock() + requestTimeoutMs
|
||||
reply = null
|
||||
pending = Json.write(linkedMapOf("id" to requestId, "expiresAt" to deadline, "body" to text))
|
||||
notifyRequestReady(requestId)
|
||||
while (reply == null && server === listener && wallClock() < deadline) {
|
||||
requestId
|
||||
}
|
||||
notifyRequestReady(id)
|
||||
val response: String = condition.withLock {
|
||||
if (server !== listener) return
|
||||
while (reply == null && requestId == id && server === listener && wallClock() < deadline) {
|
||||
condition.awaitMs(maxOf(1L, deadline - wallClock()))
|
||||
}
|
||||
val result = reply ?: TIMEOUT_RESPONSE
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import platform.Foundation.NSDocumentDirectory
|
||||
import platform.Foundation.NSSearchPathForDirectoriesInDomains
|
||||
import platform.Foundation.NSUserDomainMask
|
||||
|
||||
/**
|
||||
* iOS facade over the shared [FrameTimingsCore] with the Android FrameTimings method set.
|
||||
* [startExport] enables the export thread that sweeps timed-out frames every 5 s and writes
|
||||
* <Documents>/frame-timings.txt every 15 s while dirty (the app's Documents folder is
|
||||
* visible in Finder/Files when UIFileSharingEnabled is on).
|
||||
*/
|
||||
class IosFrameTimings internal constructor(platform: ProtocolPlatform) {
|
||||
constructor() : this(IosProtocolPlatform)
|
||||
|
||||
val core = FrameTimingsCore(platform)
|
||||
private val lock = platform.createLock()
|
||||
private var exportDir: String? = null
|
||||
private var exporting = false
|
||||
|
||||
/** Idempotent; enables filesystem export into [directory] (default: Documents). */
|
||||
fun startExport(directory: String?) {
|
||||
lock.withLock {
|
||||
exportDir = directory ?: documentsDirectory()
|
||||
if (exporting) return
|
||||
exporting = true
|
||||
}
|
||||
startThread("FrameTimingsExport", true) { exportLoop() }
|
||||
}
|
||||
|
||||
fun startFrame(reason: String?): Int = core.startFrame(reason)
|
||||
|
||||
fun startFrame(reason: String?, parentFrameId: Int): Int = core.startFrame(reason, parentFrameId)
|
||||
|
||||
fun annotate(frameId: Int, text: String?) = core.annotate(frameId, text)
|
||||
|
||||
fun log(frameId: Int, message: String?) = core.log(frameId, message)
|
||||
|
||||
fun spanStart(frameId: Int, name: String) = core.spanStart(frameId, name)
|
||||
|
||||
fun spanEnd(frameId: Int, name: String) = core.spanEnd(frameId, name)
|
||||
|
||||
fun finishFrame(frameId: Int, outcome: String?) = core.finishFrame(frameId, outcome)
|
||||
|
||||
fun statsSummary(): String = core.statsSummary()
|
||||
|
||||
/** Writes the export now (if anything changed); returns the file path or null. */
|
||||
fun exportNow(): String? {
|
||||
val dir = lock.withLock { exportDir } ?: return null
|
||||
val content = core.takeExport() ?: return null
|
||||
val target = "$dir/$EXPORT_FILE_NAME"
|
||||
val temp = "$target.tmp"
|
||||
return try {
|
||||
writeFileData(temp, content.encodeToByteArray())
|
||||
if (renameFile(temp, target)) target else {
|
||||
PlatformLog.w(TAG, "failed to rename $temp to $target")
|
||||
null
|
||||
}
|
||||
} catch (t: Throwable) {
|
||||
PlatformLog.w(TAG, "failed to export frame timings: ${t.message}")
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
private fun exportLoop() {
|
||||
var lastExportAtMs = 0L
|
||||
while (true) {
|
||||
sleepMs(FrameTimingsCore.SWEEP_INTERVAL_MS)
|
||||
try {
|
||||
core.sweepTimedOut()
|
||||
val now = IosProtocolPlatform.elapsedRealtimeMs()
|
||||
if (core.isExportDirty && now - lastExportAtMs >= FrameTimingsCore.EXPORT_INTERVAL_MS) {
|
||||
lastExportAtMs = now
|
||||
exportNow()
|
||||
}
|
||||
} catch (t: Throwable) {
|
||||
PlatformLog.w(TAG, "export loop error: ${t.message}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = FrameTimingsCore.TAG
|
||||
const val EXPORT_FILE_NAME = "frame-timings.txt"
|
||||
val shared: IosFrameTimings by lazy { IosFrameTimings() }
|
||||
|
||||
fun documentsDirectory(): String =
|
||||
NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true).firstOrNull() as? String ?: "."
|
||||
}
|
||||
}
|
||||
@@ -63,12 +63,16 @@ actual fun formatLocalTime(epochMs: Long, pattern: String): String {
|
||||
}
|
||||
|
||||
actual object PlatformLog {
|
||||
actual fun i(tag: String, message: String) = NSLog("%@", "$tag: $message")
|
||||
// NSLog's vararg bridge cannot take a Kotlin String (it segfaults), so the message becomes
|
||||
// the format string itself with '%' escaped.
|
||||
private fun emit(text: String) = NSLog(text.replace("%", "%%"))
|
||||
|
||||
actual fun w(tag: String, message: String) = NSLog("%@", "$tag: [warn] $message")
|
||||
actual fun i(tag: String, message: String) = emit("$tag: $message")
|
||||
|
||||
actual fun w(tag: String, message: String) = emit("$tag: [warn] $message")
|
||||
|
||||
actual fun e(tag: String, message: String, error: Throwable?) =
|
||||
NSLog("%@", "$tag: [error] $message" + (error?.let { " (${it.message})" } ?: ""))
|
||||
emit("$tag: [error] $message" + (error?.let { " (${it.message})" } ?: ""))
|
||||
}
|
||||
|
||||
actual fun startThread(name: String, daemon: Boolean, body: () -> Unit) {
|
||||
|
||||
@@ -0,0 +1,718 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class, kotlinx.cinterop.BetaInteropApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
import kotlinx.cinterop.ObjCSignatureOverride
|
||||
import platform.CoreBluetooth.CBAdvertisementDataIsConnectable
|
||||
import platform.CoreBluetooth.CBAdvertisementDataLocalNameKey
|
||||
import platform.CoreBluetooth.CBAdvertisementDataManufacturerDataKey
|
||||
import platform.CoreBluetooth.CBCentralManager
|
||||
import platform.CoreBluetooth.CBCentralManagerDelegateProtocol
|
||||
import platform.CoreBluetooth.CBCentralManagerScanOptionAllowDuplicatesKey
|
||||
import platform.CoreBluetooth.CBCharacteristic
|
||||
import platform.CoreBluetooth.CBCharacteristicPropertyIndicate
|
||||
import platform.CoreBluetooth.CBCharacteristicPropertyNotify
|
||||
import platform.CoreBluetooth.CBCharacteristicPropertyWrite
|
||||
import platform.CoreBluetooth.CBCharacteristicPropertyWriteWithoutResponse
|
||||
import platform.CoreBluetooth.CBCharacteristicWriteType
|
||||
import platform.CoreBluetooth.CBCharacteristicWriteWithResponse
|
||||
import platform.CoreBluetooth.CBCharacteristicWriteWithoutResponse
|
||||
import platform.CoreBluetooth.CBConnectPeripheralOptionRequiresANCS
|
||||
import platform.CoreBluetooth.CBManager
|
||||
import platform.CoreBluetooth.CBManagerStatePoweredOff
|
||||
import platform.CoreBluetooth.CBManagerStatePoweredOn
|
||||
import platform.CoreBluetooth.CBManagerStateUnauthorized
|
||||
import platform.CoreBluetooth.CBManagerStateUnsupported
|
||||
import platform.CoreBluetooth.CBPeripheral
|
||||
import platform.CoreBluetooth.CBPeripheralDelegateProtocol
|
||||
import platform.CoreBluetooth.CBPeripheralStateConnected
|
||||
import platform.CoreBluetooth.CBPeripheralStateDisconnected
|
||||
import platform.CoreBluetooth.CBService
|
||||
import platform.Foundation.NSData
|
||||
import platform.Foundation.NSError
|
||||
import platform.Foundation.NSNumber
|
||||
import platform.Foundation.NSUUID
|
||||
import platform.darwin.NSObject
|
||||
import platform.darwin.dispatch_async
|
||||
import platform.darwin.dispatch_get_main_queue
|
||||
import platform.darwin.dispatch_queue_create
|
||||
import platform.darwin.dispatch_sync
|
||||
|
||||
/** Scan/state events for the phone-side device picker; delivered on the main queue. */
|
||||
interface IosBleScanListener {
|
||||
/** CBManagerState raw value and CBManagerAuthorization raw value. */
|
||||
fun onBluetoothState(state: Int, authorization: Int)
|
||||
|
||||
fun onAdvertisement(identifier: String, name: String, manufacturerDataHex: String, rssi: Int, connectable: Boolean)
|
||||
}
|
||||
|
||||
/** ANCS authorization changes for a connected peripheral; delivered on the BLE queue. */
|
||||
fun interface IosAncsAuthorizationListener {
|
||||
fun onAncsAuthorization(identifier: String, authorized: Boolean)
|
||||
}
|
||||
|
||||
/**
|
||||
* CoreBluetooth central used by the shared session and stock-firmware flows on iOS. It is
|
||||
* the iOS counterpart of Android's FaceclawBleManager: every [SessionLink]/[StockLink] call
|
||||
* blocks the calling (worker) thread until the delegate reports completion or the timeout
|
||||
* elapses. CoreBluetooth runs on a private serial queue; the calling thread hands it work
|
||||
* with dispatch_sync and waits on a condition the delegate signals. Addresses are peripheral
|
||||
* identifier UUID strings (case-insensitive). Inbound notifications and connection-state
|
||||
* changes go to the registered listeners on the BLE queue; scan events go to the main queue.
|
||||
*
|
||||
* Locking: [cond] (non-reentrant) guards all peer state. It is never held across a
|
||||
* dispatch_sync or a listener callback.
|
||||
*/
|
||||
class IosBleCentral(private val platform: ProtocolPlatform = IosProtocolPlatform) : SessionLink, StockLink {
|
||||
companion object {
|
||||
const val TAG = "FaceclawBle"
|
||||
const val ADVERTISEMENT_CACHE = 512
|
||||
private const val READY_TIMEOUT_MS = 30_000
|
||||
private const val DEFAULT_ATT_MTU = 23
|
||||
private const val MAX_ATT_MTU = 517
|
||||
}
|
||||
|
||||
private class Peer(val peripheral: CBPeripheral) {
|
||||
val identifier: String = peripheral.identifier.UUIDString.uppercase()
|
||||
val characteristics = HashMap<String, CBCharacteristic>()
|
||||
var connectPending = false
|
||||
var connected = false
|
||||
var failure: String? = null
|
||||
var discoverPending = false
|
||||
var pendingServices = 0
|
||||
var notifyPending: String? = null
|
||||
var notifyResult: Boolean? = null
|
||||
var writePending = false
|
||||
var writeError: String? = null
|
||||
var readyForWriteWithoutResponse = false
|
||||
var requiresAncs = false
|
||||
var reportedConnected = false
|
||||
}
|
||||
|
||||
private class Advertisement(var name: String, var manufacturerDataHex: String)
|
||||
|
||||
private val queue = dispatch_queue_create("com.faceclaw.ble", null)
|
||||
private val cond: ProtocolCondition = platform.createCondition()
|
||||
private val peers = HashMap<String, Peer>()
|
||||
private val advertisements = LinkedHashMap<String, Advertisement>()
|
||||
private val delegate = Delegate(this)
|
||||
private var central: CBCentralManager? = null
|
||||
|
||||
@Volatile private var bluetoothState: Long = 0
|
||||
@Volatile private var scanRequested = false
|
||||
@Volatile private var scanListener: IosBleScanListener? = null
|
||||
@Volatile private var ancsListener: IosAncsAuthorizationListener? = null
|
||||
@Volatile private var sessionListener: FaceclawBleListener? = null
|
||||
@Volatile private var stockListener: StockLinkListener? = null
|
||||
@Volatile private var closed = false
|
||||
|
||||
// ----- listeners ------------------------------------------------------------------
|
||||
|
||||
/** The session core (a FaceclawBleListener); called on the BLE queue. */
|
||||
fun setSessionListener(listener: FaceclawBleListener?) {
|
||||
sessionListener = listener
|
||||
}
|
||||
|
||||
override fun setListener(listener: StockLinkListener?) {
|
||||
stockListener = listener
|
||||
}
|
||||
|
||||
fun setAncsAuthorizationListener(listener: IosAncsAuthorizationListener?) {
|
||||
ancsListener = listener
|
||||
}
|
||||
|
||||
/** Connect [identifier] with CBConnectPeripheralOptionRequiresANCS (the right arm relays iPhone notifications). */
|
||||
fun setRequiresAncs(identifier: String, required: Boolean) {
|
||||
val key = identifier.uppercase()
|
||||
cond.withLock { peers[key]?.requiresAncs = required }
|
||||
pendingAncs[key] = required
|
||||
}
|
||||
|
||||
private val pendingAncs = HashMap<String, Boolean>()
|
||||
|
||||
/** Whether the OS granted ANCS for the peripheral (false when unknown or disconnected). */
|
||||
fun isAncsAuthorized(identifier: String): Boolean =
|
||||
cond.withLock { peers[identifier.uppercase()]?.peripheral?.ancsAuthorized ?: false }
|
||||
|
||||
// ----- readiness and scanning -----------------------------------------------------------
|
||||
|
||||
/** Current CBManagerState raw value (0 until the central reports). */
|
||||
fun bluetoothState(): Int = bluetoothState.toInt()
|
||||
|
||||
fun authorization(): Int = CBManager.authorization.toInt()
|
||||
|
||||
/**
|
||||
* Creates the central (which triggers the permission prompt on first use) and waits for
|
||||
* it to power on. Returns null when ready or a user-facing message (the same texts the
|
||||
* TypeScript transport used).
|
||||
*/
|
||||
fun waitForPoweredOn(timeoutMs: Int = READY_TIMEOUT_MS): String? {
|
||||
ensureCentral()
|
||||
val deadline = platform.elapsedRealtimeMs() + timeoutMs
|
||||
cond.lock()
|
||||
try {
|
||||
while (true) {
|
||||
when (bluetoothState) {
|
||||
CBManagerStatePoweredOn -> return null
|
||||
CBManagerStateUnsupported -> return "Bluetooth is unavailable on this device. Use the physical iPhone."
|
||||
CBManagerStateUnauthorized -> return "Allow Faceclaw to use Bluetooth in iPhone Settings."
|
||||
CBManagerStatePoweredOff -> return "Turn on Bluetooth, then try again."
|
||||
}
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) return "Waiting for Bluetooth permission timed out. Try again after allowing Bluetooth."
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
} finally {
|
||||
cond.unlock()
|
||||
}
|
||||
}
|
||||
|
||||
private fun ensureCentral() {
|
||||
if (central != null) {
|
||||
// Re-report the current state so a fresh listener learns it.
|
||||
val listener = scanListener
|
||||
if (listener != null) {
|
||||
val state = bluetoothState.toInt()
|
||||
val authorization = authorization()
|
||||
dispatch_async(dispatch_get_main_queue()) { listener.onBluetoothState(state, authorization) }
|
||||
}
|
||||
return
|
||||
}
|
||||
central = CBCentralManager(delegate = delegate, queue = queue)
|
||||
}
|
||||
|
||||
fun setScanListener(listener: IosBleScanListener?) {
|
||||
scanListener = listener
|
||||
}
|
||||
|
||||
/** Starts (or keeps) scanning for all peripherals with duplicates; events reach the scan listener on main. */
|
||||
fun startScan() {
|
||||
scanRequested = true
|
||||
ensureCentral()
|
||||
dispatch_sync(queue) {
|
||||
val manager = central ?: return@dispatch_sync
|
||||
if (manager.state == CBManagerStatePoweredOn) beginScan(manager)
|
||||
}
|
||||
}
|
||||
|
||||
fun stopScan() {
|
||||
scanRequested = false
|
||||
dispatch_sync(queue) { central?.stopScan() }
|
||||
}
|
||||
|
||||
private fun beginScan(manager: CBCentralManager) {
|
||||
manager.scanForPeripheralsWithServices(null, mapOf(CBCentralManagerScanOptionAllowDuplicatesKey to true))
|
||||
}
|
||||
|
||||
/** Known peripheral identifiers from this process's scans/retrievals (uppercase). */
|
||||
fun knownIdentifiers(): List<String> = cond.withLock { peers.keys.toList() }
|
||||
|
||||
// ----- SessionLink / StockLink ----------------------------------------------------------
|
||||
|
||||
override fun connect(address: String, timeoutMs: Int): Boolean {
|
||||
val identifier = address.uppercase()
|
||||
val deadline = platform.elapsedRealtimeMs() + timeoutMs
|
||||
val ready = waitForPoweredOn(minOf(timeoutMs, READY_TIMEOUT_MS))
|
||||
if (ready != null) {
|
||||
log("connect $identifier: $ready")
|
||||
return false
|
||||
}
|
||||
val peer = findOrDiscover(identifier, deadline) ?: run {
|
||||
log("connect $identifier: peripheral not found")
|
||||
return false
|
||||
}
|
||||
val requiresAncs = cond.withLock {
|
||||
if (peer.connected || peer.connectPending) {
|
||||
log("connect $identifier: already connecting or connected")
|
||||
return peer.connected
|
||||
}
|
||||
peer.characteristics.clear()
|
||||
peer.failure = null
|
||||
peer.connectPending = true
|
||||
peer.reportedConnected = false
|
||||
peer.requiresAncs || (pendingAncs[identifier] ?: false)
|
||||
}
|
||||
dispatch_sync(queue) {
|
||||
val manager = central ?: return@dispatch_sync
|
||||
manager.connectPeripheral(
|
||||
peer.peripheral,
|
||||
if (requiresAncs) mapOf(CBConnectPeripheralOptionRequiresANCS to true) else null,
|
||||
)
|
||||
}
|
||||
val connected = cond.withLock {
|
||||
while (peer.connectPending) {
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) break
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
val ok = peer.connected
|
||||
if (!ok) peer.connectPending = false
|
||||
ok
|
||||
}
|
||||
if (!connected) {
|
||||
log("connect $identifier failed: " + (cond.withLock { peer.failure } ?: "timeout"))
|
||||
dispatch_sync(queue) { central?.cancelPeripheralConnection(peer.peripheral) }
|
||||
}
|
||||
return connected
|
||||
}
|
||||
|
||||
private fun findOrDiscover(identifier: String, deadline: Long): Peer? {
|
||||
cond.withLock { peers[identifier] }?.let { return it }
|
||||
var retrieved: CBPeripheral? = null
|
||||
dispatch_sync(queue) {
|
||||
val manager = central ?: return@dispatch_sync
|
||||
val uuid = NSUUID(uUIDString = identifier) ?: return@dispatch_sync
|
||||
retrieved = manager.retrievePeripheralsWithIdentifiers(listOf(uuid)).firstOrNull() as? CBPeripheral
|
||||
}
|
||||
retrieved?.let { return remember(it) }
|
||||
// Not known to the system: scan until the identifier shows up.
|
||||
val wasScanning = scanRequested
|
||||
startScan()
|
||||
try {
|
||||
cond.lock()
|
||||
try {
|
||||
while (true) {
|
||||
peers[identifier]?.let { return it }
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) return null
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
} finally {
|
||||
cond.unlock()
|
||||
}
|
||||
} finally {
|
||||
if (!wasScanning) stopScan()
|
||||
}
|
||||
}
|
||||
|
||||
override fun requestHighPriority(address: String) {}
|
||||
|
||||
override fun requestMtu(address: String, mtu: Int, timeoutMs: Int): Boolean = true
|
||||
|
||||
override fun prepareLink(address: String, desiredMtu: Int, timeoutMs: Int) {}
|
||||
|
||||
override fun negotiatedMtu(address: String): Int {
|
||||
val peer = cond.withLock { peers[address.uppercase()] } ?: return DEFAULT_ATT_MTU
|
||||
// CoreBluetooth reports the ATT payload; Android reports the ATT MTU (payload + 3).
|
||||
val payload = peer.peripheral.maximumWriteValueLengthForType(CBCharacteristicWriteWithoutResponse).toInt()
|
||||
return (payload + 3).coerceIn(DEFAULT_ATT_MTU, MAX_ATT_MTU)
|
||||
}
|
||||
|
||||
override fun discoverServices(address: String, timeoutMs: Int): Boolean {
|
||||
val peer = connectedPeer(address) ?: return false
|
||||
val deadline = platform.elapsedRealtimeMs() + timeoutMs
|
||||
cond.withLock {
|
||||
peer.discoverPending = true
|
||||
peer.pendingServices = 0
|
||||
peer.characteristics.clear()
|
||||
}
|
||||
dispatch_sync(queue) { peer.peripheral.discoverServices(null) }
|
||||
return cond.withLock {
|
||||
while (peer.discoverPending && peer.connected) {
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) break
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
!peer.discoverPending && peer.connected && peer.characteristics.isNotEmpty()
|
||||
}
|
||||
}
|
||||
|
||||
override fun enableNotifications(address: String, characteristicUuid: String, timeoutMs: Int): Boolean =
|
||||
enableNotifications(address, characteristicUuid, true, timeoutMs)
|
||||
|
||||
override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean {
|
||||
val peer = connectedPeer(address) ?: return false
|
||||
val key = characteristicUuid.lowercase()
|
||||
val characteristic = cond.withLock { peer.characteristics[key] } ?: run {
|
||||
log("notifications $key: characteristic unavailable")
|
||||
return false
|
||||
}
|
||||
val notifiable = (characteristic.properties and (CBCharacteristicPropertyNotify or CBCharacteristicPropertyIndicate)) != 0uL
|
||||
if (!notifiable) {
|
||||
log("notifications $key: not notifiable")
|
||||
return false
|
||||
}
|
||||
if (characteristic.isNotifying == enable) return true
|
||||
val deadline = platform.elapsedRealtimeMs() + timeoutMs
|
||||
cond.withLock {
|
||||
peer.notifyPending = key
|
||||
peer.notifyResult = null
|
||||
}
|
||||
dispatch_sync(queue) { peer.peripheral.setNotifyValue(enable, characteristic) }
|
||||
return cond.withLock {
|
||||
while (peer.notifyPending == key && peer.connected) {
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) break
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
val result = peer.notifyResult == true && peer.connected
|
||||
if (peer.notifyPending == key) peer.notifyPending = null
|
||||
result || (!enable && peer.connected)
|
||||
}
|
||||
}
|
||||
|
||||
override fun writeFrames(
|
||||
address: String,
|
||||
characteristicUuid: String,
|
||||
frames: List<ByteArray>,
|
||||
mode: GattWriteMode,
|
||||
timeoutMs: Int,
|
||||
): Boolean {
|
||||
val peer = connectedPeer(address) ?: return false
|
||||
val key = characteristicUuid.lowercase()
|
||||
val characteristic = cond.withLock { peer.characteristics[key] } ?: run {
|
||||
log("write $key: characteristic unavailable")
|
||||
return false
|
||||
}
|
||||
val writable = (characteristic.properties and (CBCharacteristicPropertyWrite or CBCharacteristicPropertyWriteWithoutResponse)) != 0uL
|
||||
if (!writable) return false
|
||||
val withoutResponseSupported = (characteristic.properties and CBCharacteristicPropertyWriteWithoutResponse) != 0uL
|
||||
val type: CBCharacteristicWriteType =
|
||||
if (mode == GattWriteMode.WITHOUT_RESPONSE && withoutResponseSupported) CBCharacteristicWriteWithoutResponse
|
||||
else CBCharacteristicWriteWithResponse
|
||||
val limit = peer.peripheral.maximumWriteValueLengthForType(type).toInt()
|
||||
val deadline = platform.elapsedRealtimeMs() + timeoutMs
|
||||
for (frame in frames) {
|
||||
if (frame.size > limit) {
|
||||
log("write $key: ${frame.size} bytes exceeds the ${limit}-byte limit")
|
||||
return false
|
||||
}
|
||||
val data = frame.data()
|
||||
if (type == CBCharacteristicWriteWithResponse) {
|
||||
cond.withLock {
|
||||
peer.writePending = true
|
||||
peer.writeError = null
|
||||
}
|
||||
dispatch_sync(queue) { peer.peripheral.writeValue(data, characteristic, type) }
|
||||
val ok = cond.withLock {
|
||||
while (peer.writePending && peer.connected) {
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) break
|
||||
cond.awaitMs(left)
|
||||
}
|
||||
val done = !peer.writePending && peer.writeError == null && peer.connected
|
||||
peer.writePending = false
|
||||
done
|
||||
}
|
||||
if (!ok) {
|
||||
log("write $key failed: " + (cond.withLock { peer.writeError } ?: "timeout"))
|
||||
return false
|
||||
}
|
||||
IosBleTraffic.recordWrite(frame.size)
|
||||
} else {
|
||||
while (true) {
|
||||
var sent = false
|
||||
var connected = true
|
||||
dispatch_sync(queue) {
|
||||
if (peer.peripheral.state != CBPeripheralStateConnected) {
|
||||
connected = false
|
||||
} else if (peer.peripheral.canSendWriteWithoutResponse) {
|
||||
peer.peripheral.writeValue(data, characteristic, type)
|
||||
sent = true
|
||||
}
|
||||
}
|
||||
if (!connected) return false
|
||||
if (sent) {
|
||||
IosBleTraffic.recordWrite(frame.size)
|
||||
break
|
||||
}
|
||||
// Pace on the controller's buffer: wait for peripheralIsReadyToSendWriteWithoutResponse.
|
||||
val ready = cond.withLock {
|
||||
peer.readyForWriteWithoutResponse = false
|
||||
while (!peer.readyForWriteWithoutResponse && peer.connected) {
|
||||
val left = deadline - platform.elapsedRealtimeMs()
|
||||
if (left <= 0) break
|
||||
cond.awaitMs(minOf(left, 50))
|
||||
// canSendWriteWithoutResponse may flip without a callback; re-check.
|
||||
if (peer.peripheral.canSendWriteWithoutResponse) break
|
||||
}
|
||||
peer.connected && (peer.readyForWriteWithoutResponse || peer.peripheral.canSendWriteWithoutResponse)
|
||||
}
|
||||
if (!ready) {
|
||||
if (platform.elapsedRealtimeMs() >= deadline) {
|
||||
log("write $key: timed out waiting for the write buffer")
|
||||
return false
|
||||
}
|
||||
if (!cond.withLock { peer.connected }) return false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
override fun isConnected(address: String): Boolean =
|
||||
cond.withLock { peers[address.uppercase()]?.connected ?: false }
|
||||
|
||||
override fun bondState(address: String): BondState = BondState.UNKNOWN
|
||||
|
||||
override fun isBonded(address: String): Boolean = true
|
||||
|
||||
override fun prepareBenchmarkLink(address: String, mode: Int) {}
|
||||
|
||||
override fun recordDisplayFrameSent() {
|
||||
IosBleTraffic.recordDisplayFrame()
|
||||
}
|
||||
|
||||
override fun disconnect(address: String) {
|
||||
val peer = cond.withLock { peers[address.uppercase()] } ?: return
|
||||
dispatch_sync(queue) {
|
||||
if (peer.peripheral.state != CBPeripheralStateDisconnected) central?.cancelPeripheralConnection(peer.peripheral)
|
||||
}
|
||||
failPeer(peer, "Disconnected", notifyListeners = false)
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
closed = true
|
||||
scanRequested = false
|
||||
val all = cond.withLock { peers.values.toList() }
|
||||
dispatch_sync(queue) {
|
||||
central?.stopScan()
|
||||
for (peer in all) if (peer.peripheral.state != CBPeripheralStateDisconnected) central?.cancelPeripheralConnection(peer.peripheral)
|
||||
}
|
||||
for (peer in all) failPeer(peer, "Closed", notifyListeners = false)
|
||||
}
|
||||
|
||||
// ----- internals ------------------------------------------------------------------
|
||||
|
||||
private fun connectedPeer(address: String): Peer? {
|
||||
val peer = cond.withLock { peers[address.uppercase()]?.takeIf { it.connected } }
|
||||
if (peer == null) log("$address is not connected")
|
||||
return peer
|
||||
}
|
||||
|
||||
private fun remember(peripheral: CBPeripheral): Peer {
|
||||
val identifier = peripheral.identifier.UUIDString.uppercase()
|
||||
return cond.withLock {
|
||||
peers.getOrPut(identifier) {
|
||||
peripheral.delegate = delegate
|
||||
Peer(peripheral).also { it.requiresAncs = pendingAncs[identifier] ?: false }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Marks the peer disconnected, wakes every waiter and (optionally) tells the listeners. */
|
||||
private fun failPeer(peer: Peer, reason: String, notifyListeners: Boolean) {
|
||||
val wasReported = cond.withLock {
|
||||
val reported = peer.reportedConnected
|
||||
peer.failure = reason
|
||||
peer.connectPending = false
|
||||
peer.connected = false
|
||||
peer.reportedConnected = false
|
||||
peer.discoverPending = false
|
||||
peer.notifyPending = null
|
||||
peer.writePending = false
|
||||
peer.readyForWriteWithoutResponse = false
|
||||
peer.characteristics.clear()
|
||||
cond.signalAll()
|
||||
reported
|
||||
}
|
||||
if (notifyListeners && wasReported) emitConnectionState(peer.identifier, false)
|
||||
}
|
||||
|
||||
private fun emitConnectionState(identifier: String, connected: Boolean) {
|
||||
sessionListener?.onConnectionStateChange(identifier, connected)
|
||||
stockListener?.onConnectionStateChange(identifier, connected)
|
||||
}
|
||||
|
||||
private fun log(message: String) = PlatformLog.i(TAG, message)
|
||||
|
||||
// ----- delegate callbacks (BLE queue) ----------------------------------------------------
|
||||
|
||||
private fun onStateUpdated(manager: CBCentralManager) {
|
||||
val state = manager.state
|
||||
bluetoothState = state
|
||||
cond.withLock { cond.signalAll() }
|
||||
val listener = scanListener
|
||||
if (listener != null) {
|
||||
val authorization = authorization()
|
||||
dispatch_async(dispatch_get_main_queue()) { listener.onBluetoothState(state.toInt(), authorization) }
|
||||
}
|
||||
if (state != CBManagerStatePoweredOn) {
|
||||
val all = cond.withLock { peers.values.toList() }
|
||||
for (peer in all) failPeer(peer, "Bluetooth is unavailable", notifyListeners = true)
|
||||
} else if (scanRequested) {
|
||||
beginScan(manager)
|
||||
}
|
||||
}
|
||||
|
||||
private fun onDiscovered(peripheral: CBPeripheral, advertisementData: Map<Any?, *>, rssi: NSNumber) {
|
||||
val peer = remember(peripheral)
|
||||
cond.withLock { cond.signalAll() } // findOrDiscover may be waiting for this identifier
|
||||
val listener = scanListener ?: return
|
||||
val manufacturer = (advertisementData[CBAdvertisementDataManufacturerDataKey] as? NSData)?.byteArray()
|
||||
val advertisedName = advertisementData[CBAdvertisementDataLocalNameKey] as? String
|
||||
val connectable = (advertisementData[CBAdvertisementDataIsConnectable] as? NSNumber)?.boolValue ?: true
|
||||
val merged = cond.withLock {
|
||||
val previous = advertisements.remove(peer.identifier)
|
||||
val name = advertisedName ?: peripheral.name ?: previous?.name ?: ""
|
||||
val hex = if (manufacturer != null) BinaryEncoding.bytesToHex(manufacturer) else previous?.manufacturerDataHex ?: ""
|
||||
if (advertisements.size >= ADVERTISEMENT_CACHE) advertisements.remove(advertisements.keys.first())
|
||||
Advertisement(name, hex).also { advertisements[peer.identifier] = it }
|
||||
}
|
||||
val identifier = peer.identifier
|
||||
val level = rssi.intValue
|
||||
dispatch_async(dispatch_get_main_queue()) {
|
||||
listener.onAdvertisement(identifier, merged.name, merged.manufacturerDataHex, level, connectable)
|
||||
}
|
||||
}
|
||||
|
||||
private fun onConnected(peripheral: CBPeripheral) {
|
||||
val peer = remember(peripheral)
|
||||
cond.withLock {
|
||||
peer.connected = true
|
||||
peer.connectPending = false
|
||||
peer.failure = null
|
||||
peer.reportedConnected = true
|
||||
cond.signalAll()
|
||||
}
|
||||
emitConnectionState(peer.identifier, true)
|
||||
}
|
||||
|
||||
private fun onDisconnected(peripheral: CBPeripheral, error: NSError?) {
|
||||
val peer = remember(peripheral)
|
||||
failPeer(peer, error?.localizedDescription ?: "Disconnected", notifyListeners = true)
|
||||
}
|
||||
|
||||
private fun onServicesDiscovered(peripheral: CBPeripheral, error: NSError?) {
|
||||
val peer = remember(peripheral)
|
||||
val services = peripheral.services?.mapNotNull { it as? CBService } ?: emptyList()
|
||||
if (error != null || services.isEmpty()) {
|
||||
cond.withLock {
|
||||
peer.discoverPending = false
|
||||
cond.signalAll()
|
||||
}
|
||||
return
|
||||
}
|
||||
cond.withLock { peer.pendingServices = services.size }
|
||||
for (service in services) peripheral.discoverCharacteristics(null, service)
|
||||
}
|
||||
|
||||
private fun onCharacteristicsDiscovered(peripheral: CBPeripheral, service: CBService, error: NSError?) {
|
||||
val peer = remember(peripheral)
|
||||
cond.withLock {
|
||||
if (error == null) {
|
||||
for (item in service.characteristics ?: emptyList<Any?>()) {
|
||||
val characteristic = item as? CBCharacteristic ?: continue
|
||||
peer.characteristics[characteristic.UUID.UUIDString.lowercase()] = characteristic
|
||||
}
|
||||
}
|
||||
peer.pendingServices--
|
||||
if (peer.pendingServices <= 0) peer.discoverPending = false
|
||||
cond.signalAll()
|
||||
}
|
||||
}
|
||||
|
||||
private fun onNotificationState(peripheral: CBPeripheral, characteristic: CBCharacteristic, error: NSError?) {
|
||||
val peer = remember(peripheral)
|
||||
val key = characteristic.UUID.UUIDString.lowercase()
|
||||
cond.withLock {
|
||||
if (peer.notifyPending == key) {
|
||||
peer.notifyResult = error == null && characteristic.isNotifying
|
||||
peer.notifyPending = null
|
||||
}
|
||||
cond.signalAll()
|
||||
}
|
||||
}
|
||||
|
||||
private fun onValue(peripheral: CBPeripheral, characteristic: CBCharacteristic, error: NSError?) {
|
||||
if (error != null) {
|
||||
log("notification error: " + error.localizedDescription)
|
||||
return
|
||||
}
|
||||
val data = characteristic.value?.byteArray() ?: return
|
||||
val identifier = peripheral.identifier.UUIDString.uppercase()
|
||||
val uuid = characteristic.UUID.UUIDString.lowercase()
|
||||
IosBleTraffic.recordRead(data.size)
|
||||
sessionListener?.onNotification(identifier, uuid, data)
|
||||
stockListener?.onNotification(identifier, uuid, data)
|
||||
}
|
||||
|
||||
private fun onWrote(peripheral: CBPeripheral, error: NSError?) {
|
||||
val peer = remember(peripheral)
|
||||
cond.withLock {
|
||||
peer.writeError = error?.localizedDescription
|
||||
peer.writePending = false
|
||||
cond.signalAll()
|
||||
}
|
||||
}
|
||||
|
||||
private fun onReadyForWriteWithoutResponse(peripheral: CBPeripheral) {
|
||||
val peer = remember(peripheral)
|
||||
cond.withLock {
|
||||
peer.readyForWriteWithoutResponse = true
|
||||
cond.signalAll()
|
||||
}
|
||||
}
|
||||
|
||||
private fun onAncsAuthorization(peripheral: CBPeripheral) {
|
||||
val identifier = peripheral.identifier.UUIDString.uppercase()
|
||||
ancsListener?.onAncsAuthorization(identifier, peripheral.ancsAuthorized)
|
||||
}
|
||||
|
||||
private class Delegate(private val owner: IosBleCentral) : NSObject(), CBCentralManagerDelegateProtocol, CBPeripheralDelegateProtocol {
|
||||
override fun centralManagerDidUpdateState(central: CBCentralManager) = owner.onStateUpdated(central)
|
||||
|
||||
override fun centralManager(central: CBCentralManager, didDiscoverPeripheral: CBPeripheral, advertisementData: Map<Any?, *>, RSSI: NSNumber) =
|
||||
owner.onDiscovered(didDiscoverPeripheral, advertisementData, RSSI)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun centralManager(central: CBCentralManager, didConnectPeripheral: CBPeripheral) = owner.onConnected(didConnectPeripheral)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun centralManager(central: CBCentralManager, didFailToConnectPeripheral: CBPeripheral, error: NSError?) =
|
||||
owner.onDisconnected(didFailToConnectPeripheral, error)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun centralManager(central: CBCentralManager, didDisconnectPeripheral: CBPeripheral, error: NSError?) =
|
||||
owner.onDisconnected(didDisconnectPeripheral, error)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun centralManager(central: CBCentralManager, didUpdateANCSAuthorizationForPeripheral: CBPeripheral) =
|
||||
owner.onAncsAuthorization(didUpdateANCSAuthorizationForPeripheral)
|
||||
|
||||
override fun peripheral(peripheral: CBPeripheral, didDiscoverServices: NSError?) = owner.onServicesDiscovered(peripheral, didDiscoverServices)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun peripheral(peripheral: CBPeripheral, didDiscoverCharacteristicsForService: CBService, error: NSError?) =
|
||||
owner.onCharacteristicsDiscovered(peripheral, didDiscoverCharacteristicsForService, error)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun peripheral(peripheral: CBPeripheral, didUpdateNotificationStateForCharacteristic: CBCharacteristic, error: NSError?) =
|
||||
owner.onNotificationState(peripheral, didUpdateNotificationStateForCharacteristic, error)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun peripheral(peripheral: CBPeripheral, didUpdateValueForCharacteristic: CBCharacteristic, error: NSError?) =
|
||||
owner.onValue(peripheral, didUpdateValueForCharacteristic, error)
|
||||
|
||||
@ObjCSignatureOverride
|
||||
override fun peripheral(peripheral: CBPeripheral, didWriteValueForCharacteristic: CBCharacteristic, error: NSError?) =
|
||||
owner.onWrote(peripheral, error)
|
||||
|
||||
override fun peripheralIsReadyToSendWriteWithoutResponse(peripheral: CBPeripheral) = owner.onReadyForWriteWithoutResponse(peripheral)
|
||||
}
|
||||
}
|
||||
|
||||
/** Process-wide BLE traffic counters (the TypeScript ios-ble-traffic counters' successor). */
|
||||
object IosBleTraffic {
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
private var bytesWritten = 0L
|
||||
private var bytesRead = 0L
|
||||
private var displayFrames = 0L
|
||||
|
||||
fun recordWrite(bytes: Int) = lock.withLock { bytesWritten += bytes }
|
||||
|
||||
fun recordRead(bytes: Int) = lock.withLock { bytesRead += bytes }
|
||||
|
||||
fun recordDisplayFrame() = lock.withLock { displayFrames++ }
|
||||
|
||||
/** [bytesWritten, bytesRead, displayFrames] and resets the counters. */
|
||||
fun sample(): LongArray = lock.withLock {
|
||||
val out = longArrayOf(bytesWritten, bytesRead, displayFrames)
|
||||
bytesWritten = 0
|
||||
bytesRead = 0
|
||||
displayFrames = 0
|
||||
out
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,245 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import platform.Foundation.NSData
|
||||
import platform.darwin.dispatch_async
|
||||
import platform.darwin.dispatch_get_main_queue
|
||||
import platform.darwin.dispatch_queue_create
|
||||
|
||||
/** iPhone-notification relay hooks; both callbacks are delivered on the main queue. */
|
||||
interface IosAncsListener {
|
||||
fun onAncsAuthorization(authorized: Boolean)
|
||||
|
||||
/** A relay frame ('A','N',...) received on the right arm's data characteristic. */
|
||||
fun onRelayFrame(data: NSData)
|
||||
}
|
||||
|
||||
/**
|
||||
* ObjC-facing facade over the shared [GlassesSessionCore] for the NativeScript app: the iOS
|
||||
* counterpart of Android's FaceclawBleCommunicator with the same method names. GATT goes
|
||||
* through [IosBleCentral], side effects through [IosSessionHost]; every listener the
|
||||
* TypeScript side installs is invoked on the main queue. Binary crossings use NSData.
|
||||
*/
|
||||
class IosGlassesSession internal constructor(
|
||||
link: SessionLink,
|
||||
private val central: IosBleCentral?,
|
||||
private val host: SessionHost,
|
||||
rightAddress: String,
|
||||
leftAddress: String,
|
||||
ringAddress: String,
|
||||
platform: ProtocolPlatform,
|
||||
) {
|
||||
/** Production constructor: CoreBluetooth link + main-queue host. Addresses are peripheral identifiers. */
|
||||
constructor(rightAddress: String, leftAddress: String, ringAddress: String) : this(
|
||||
IosBleCentral(),
|
||||
rightAddress,
|
||||
leftAddress,
|
||||
ringAddress,
|
||||
)
|
||||
|
||||
private constructor(central: IosBleCentral, rightAddress: String, leftAddress: String, ringAddress: String) : this(
|
||||
central,
|
||||
central,
|
||||
IosSessionHost(),
|
||||
rightAddress,
|
||||
leftAddress,
|
||||
ringAddress,
|
||||
IosProtocolPlatform,
|
||||
)
|
||||
|
||||
companion object {
|
||||
const val TAG = GlassesSessionCore.TAG
|
||||
}
|
||||
|
||||
private val frameTimings = IosFrameTimings.shared.core
|
||||
private val core = GlassesSessionCore(link, host, frameTimings, platform, rightAddress, leftAddress, ringAddress)
|
||||
private val rawQueue = dispatch_queue_create("com.faceclaw.session.raw", null)
|
||||
private val rightIdentifier = rightAddress.uppercase()
|
||||
|
||||
init {
|
||||
central?.setSessionListener(core)
|
||||
}
|
||||
|
||||
// ----- lifecycle ------------------------------------------------------------------
|
||||
|
||||
fun setListener(listener: FaceclawBleCommunicatorListener?) = core.setListener(listener)
|
||||
|
||||
fun start(): Boolean = core.start()
|
||||
|
||||
fun disconnect() = core.disconnect()
|
||||
|
||||
fun close() = core.close()
|
||||
|
||||
fun onPhoneLockSignal() = core.onPhoneLockSignal()
|
||||
|
||||
fun isSessionReady(): Boolean = core.isSessionReady()
|
||||
|
||||
// ----- iPhone notification relay (ANCS) -------------------------------------------------
|
||||
|
||||
/** Ask CoreBluetooth for ANCS on the right arm's next connection (call before start()). */
|
||||
fun setRequiresAncs(required: Boolean) {
|
||||
central?.setRequiresAncs(rightIdentifier, required)
|
||||
}
|
||||
|
||||
fun isAncsAuthorized(): Boolean = central?.isAncsAuthorized(rightIdentifier) ?: false
|
||||
|
||||
fun setAncsListener(listener: IosAncsListener?) {
|
||||
if (listener == null) {
|
||||
core.setRawFrameTap(null)
|
||||
central?.setAncsAuthorizationListener(null)
|
||||
return
|
||||
}
|
||||
core.setRawFrameTap { bytes ->
|
||||
val data = bytes.data()
|
||||
dispatch_async(dispatch_get_main_queue()) { listener.onRelayFrame(data) }
|
||||
}
|
||||
central?.setAncsAuthorizationListener { _, authorized ->
|
||||
dispatch_async(dispatch_get_main_queue()) { listener.onAncsAuthorization(authorized) }
|
||||
}
|
||||
}
|
||||
|
||||
/** Queue one relay packet for the right arm; never blocks the caller (writes run on a serial queue). */
|
||||
fun writeRawToRight(packet: NSData) {
|
||||
val bytes = packet.byteArray()
|
||||
dispatch_async(rawQueue) {
|
||||
if (!core.writeRawPacket("R", bytes)) PlatformLog.w(TAG, "relay packet dropped (${bytes.size} bytes)")
|
||||
}
|
||||
}
|
||||
|
||||
// ----- controls -------------------------------------------------------------------
|
||||
|
||||
fun setG2ScreenOn(screenOn: Boolean) = core.setG2ScreenOn(screenOn)
|
||||
|
||||
fun setFirmwareDebugFlags(enabled: Boolean) = core.setFirmwareDebugFlags(enabled)
|
||||
|
||||
/** The packet listener is invoked on the main queue (the core delivers on the BLE queue). */
|
||||
fun startG2AudioCapture(listener: FaceclawAudioPacketListener?): Boolean =
|
||||
core.startG2AudioCapture(listener?.let { MainQueueAudioListener(it) })
|
||||
|
||||
fun stopG2AudioCapture() = core.stopG2AudioCapture()
|
||||
|
||||
fun isAudioCaptureActive(): Boolean = core.isAudioCaptureActive()
|
||||
|
||||
fun setFaceclawWakeLeaseEnabled(enabled: Boolean): Boolean = core.setFaceclawWakeLeaseEnabled(enabled)
|
||||
|
||||
fun awaitEvenHubSessionReady(timeoutMs: Int): Boolean = core.awaitEvenHubSessionReady(timeoutMs)
|
||||
|
||||
fun setImuReportEnabled(enable: Boolean, reportFrq: Int) = core.setImuReportEnabled(enable, reportFrq)
|
||||
|
||||
fun setCompassEnabled(enable: Boolean) = core.setCompassEnabled(enable)
|
||||
|
||||
fun setCompassEnabledForOwner(owner: String?, enable: Boolean) = core.setCompassEnabled(owner, enable)
|
||||
|
||||
fun setBrightness(autoAdjust: Boolean, brightnessLevel: Int) = core.setBrightness(autoAdjust, brightnessLevel)
|
||||
|
||||
fun enableWearDetectionAndRequestState() = core.enableWearDetectionAndRequestState()
|
||||
|
||||
fun startBandwidthBenchmark(messageSize: Int, windowSize: Int, durationMs: Int): Boolean =
|
||||
core.startBandwidthBenchmark(messageSize, windowSize, durationMs)
|
||||
|
||||
fun startBandwidthBenchmarkWithLinkMode(messageSize: Int, windowSize: Int, durationMs: Int, linkMode: Int): Boolean =
|
||||
core.startBandwidthBenchmarkWithLinkMode(messageSize, windowSize, durationMs, linkMode)
|
||||
|
||||
fun cancelBandwidthBenchmark() = core.cancelBandwidthBenchmark()
|
||||
|
||||
fun getBandwidthBenchmarkStatus(): String = core.getBandwidthBenchmarkStatus()
|
||||
|
||||
fun addImuListener(listener: FaceclawImuListener?) = core.addImuListener(listener)
|
||||
|
||||
fun removeImuListener(listener: FaceclawImuListener?) = core.removeImuListener(listener)
|
||||
|
||||
fun addAmbientLightListener(listener: FaceclawAmbientLightListener?) = core.addAmbientLightListener(listener)
|
||||
|
||||
fun removeAmbientLightListener(listener: FaceclawAmbientLightListener?) = core.removeAmbientLightListener(listener)
|
||||
|
||||
fun queryAmbientLight() = core.queryAmbientLight()
|
||||
|
||||
fun setAmbientLightPolling(enable: Boolean, intervalMs: Int, minDelta: Int, heartbeatMs: Int, bindToLease: Boolean) =
|
||||
core.setAmbientLightPolling(enable, intervalMs, minDelta, heartbeatMs, bindToLease)
|
||||
|
||||
fun addMicStatusListener(listener: FaceclawMicStatusListener?) = core.addMicStatusListener(listener)
|
||||
|
||||
fun removeMicStatusListener(listener: FaceclawMicStatusListener?) = core.removeMicStatusListener(listener)
|
||||
|
||||
fun sendFaceclawMicControl(record: NSData?, label: String, rightTemple: Boolean, leftTemple: Boolean) =
|
||||
core.sendFaceclawMicControl(record?.byteArray(), label, rightTemple, leftTemple)
|
||||
|
||||
fun startG2AudioForwarding(listener: FaceclawAudioPacketListener?): Boolean =
|
||||
core.startG2AudioForwarding(listener?.let { MainQueueAudioListener(it) })
|
||||
|
||||
fun stopG2AudioForwarding() = core.stopG2AudioForwarding()
|
||||
|
||||
/** Compass events are delivered on the queue of the thread that adds the listener (main for TypeScript). */
|
||||
fun addCompassListener(listener: FaceclawCompassListener?) = core.addCompassListener(listener)
|
||||
|
||||
fun removeCompassListener(listener: FaceclawCompassListener?) = core.removeCompassListener(listener)
|
||||
|
||||
fun sendShutdown(exitMode: Int): Boolean = core.sendShutdown(exitMode)
|
||||
|
||||
fun sendCfwCleanup(): Boolean = core.sendCfwCleanup()
|
||||
|
||||
fun suspendEvenHubSession(): Boolean = core.suspendEvenHubSession()
|
||||
|
||||
fun resumeEvenHubSession(): Boolean = core.resumeEvenHubSession()
|
||||
|
||||
fun playBuzzerSequence(payload: NSData?) = core.playBuzzerSequence(payload?.byteArray())
|
||||
|
||||
// ----- surfaces -------------------------------------------------------------------
|
||||
|
||||
/** Set the compositor's output frame size. Call before configuring surfaces. */
|
||||
fun configureCompositorScreen(width: Int, height: Int) = core.configureCompositorScreen(width, height)
|
||||
|
||||
fun setSurfaceVisible(id: String, visible: Boolean) = core.setSurfaceVisible(id, visible)
|
||||
|
||||
fun setScreenBlanked(blanked: Boolean) = core.setScreenBlanked(blanked)
|
||||
|
||||
fun configureSurface(id: String, x: Int, y: Int, width: Int, height: Int, zOrder: Int, transparency: Int) =
|
||||
core.configureSurface(id, x, y, width, height, zOrder, transparency)
|
||||
|
||||
fun removeSurface(id: String) = core.removeSurface(id)
|
||||
|
||||
fun submitShellScene(bytes: NSData, paintMs: Int, frameId: Int) = core.submitShellScene(IosByteReader(bytes), paintMs, frameId)
|
||||
|
||||
fun setUnderlayDim(belowZOrder: Int, factor256: Int) = core.setUnderlayDim(belowZOrder, factor256)
|
||||
|
||||
fun submitSurfaceFrame(
|
||||
pixels8bpp: NSData,
|
||||
surfaceId: String,
|
||||
rectX: Int,
|
||||
rectY: Int,
|
||||
rectWidth: Int,
|
||||
rectHeight: Int,
|
||||
contentFingerprint: String?,
|
||||
paintMs: Int,
|
||||
frameId: Int,
|
||||
glyphs: NSData?,
|
||||
) = core.submitSurfaceFrame(
|
||||
IosByteReader(pixels8bpp), surfaceId, rectX, rectY, rectWidth, rectHeight, contentFingerprint, paintMs, frameId,
|
||||
glyphs?.let { IosByteReader(it) },
|
||||
)
|
||||
|
||||
/** The current composited screen (gray, 8bpp) or null before any surface was configured. */
|
||||
fun previewComposite(): IosTextureFrame? = core.previewComposite()?.let { IosTextureFrame(it) }
|
||||
|
||||
fun compositeWidth(): Int = core.previewComposite()?.width ?: 0
|
||||
|
||||
fun compositeHeight(): Int = core.previewComposite()?.height ?: 0
|
||||
|
||||
/** The current composite as a 4-bit grayscale PNG, or null. */
|
||||
fun screenshotPng(): NSData? {
|
||||
val composite = core.previewComposite() ?: return null
|
||||
return SharedScreenshots.encode4BitGrayPng(composite.gray, composite.width, composite.height).data()
|
||||
}
|
||||
|
||||
/** Frame-timings export text (see FrameTimingsCore), for the phone-side debug page. */
|
||||
fun frameTimingsExport(): String = frameTimings.buildExport()
|
||||
|
||||
internal fun coreForTests(): GlassesSessionCore = core
|
||||
|
||||
private class MainQueueAudioListener(private val delegate: FaceclawAudioPacketListener) : FaceclawAudioPacketListener {
|
||||
override fun onAudioPacket(data: ByteArray?, arm: String?, arrivalMs: Long) {
|
||||
dispatch_async(dispatch_get_main_queue()) { delegate.onAudioPacket(data, arm, arrivalMs) }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
import platform.Foundation.NSBundle
|
||||
import platform.Foundation.NSNotificationCenter
|
||||
import platform.Foundation.NSOperationQueue
|
||||
import platform.Foundation.NSThread
|
||||
import platform.UIKit.UIApplication
|
||||
import platform.UIKit.UIApplicationProtectedDataDidBecomeAvailable
|
||||
import platform.UIKit.UIApplicationProtectedDataWillBecomeUnavailable
|
||||
import platform.darwin.dispatch_async
|
||||
import platform.darwin.dispatch_get_main_queue
|
||||
import platform.darwin.dispatch_queue_create
|
||||
|
||||
/**
|
||||
* iOS [SessionHost]: listener callbacks go to the main queue (NativeScript's JavaScript
|
||||
* thread), the session worker is an NSThread, the "glasses screen on" wake lock maps to the
|
||||
* idle timer, and "phone locked" tracks protected-data availability (data protection kicks
|
||||
* in shortly after the passcode lock engages), observed on the main queue so the worker
|
||||
* never has to block on the main thread. There is no Even-app conflict on iOS.
|
||||
*/
|
||||
class IosSessionHost(private val platform: ProtocolPlatform = IosProtocolPlatform, private val threadName: String = "FaceclawBleCommunicator") : SessionHost {
|
||||
private val mainDispatcher = SessionDispatcher { action -> dispatch_async(dispatch_get_main_queue()) { action() } }
|
||||
|
||||
@Volatile private var phoneLocked = false
|
||||
|
||||
@Volatile private var workerDone: Latch? = null
|
||||
|
||||
/** UIApplication exists only inside a UIKit app; the Kotlin test executable has no bundle type. */
|
||||
private val uiApplicationAvailable: Boolean =
|
||||
NSBundle.mainBundle.infoDictionary?.get("CFBundlePackageType") == "APPL"
|
||||
|
||||
init {
|
||||
if (uiApplicationAvailable) {
|
||||
val center = NSNotificationCenter.defaultCenter
|
||||
center.addObserverForName(UIApplicationProtectedDataWillBecomeUnavailable, null, NSOperationQueue.mainQueue) { phoneLocked = true }
|
||||
center.addObserverForName(UIApplicationProtectedDataDidBecomeAvailable, null, NSOperationQueue.mainQueue) { phoneLocked = false }
|
||||
dispatch_async(dispatch_get_main_queue()) {
|
||||
phoneLocked = !UIApplication.sharedApplication.protectedDataAvailable
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun postToMain(action: () -> Unit) {
|
||||
dispatch_async(dispatch_get_main_queue()) { action() }
|
||||
}
|
||||
|
||||
override fun currentThreadDispatcher(): SessionDispatcher {
|
||||
if (NSThread.isMainThread) return mainDispatcher
|
||||
val queue = dispatch_queue_create("com.faceclaw.session.subscriber", null)
|
||||
return SessionDispatcher { action -> dispatch_async(queue) { action() } }
|
||||
}
|
||||
|
||||
override fun isPhoneLocked(): Boolean = phoneLocked
|
||||
|
||||
override fun setScreenWakeLock(on: Boolean) {
|
||||
if (!uiApplicationAvailable) return
|
||||
dispatch_async(dispatch_get_main_queue()) { UIApplication.sharedApplication.idleTimerDisabled = on }
|
||||
}
|
||||
|
||||
override fun isEvenAppActive(): Boolean = false
|
||||
|
||||
override fun startWorker(body: () -> Unit) {
|
||||
val latch = Latch(1, platform)
|
||||
workerDone = latch
|
||||
val thread = NSThread {
|
||||
try {
|
||||
body()
|
||||
} finally {
|
||||
latch.countDown()
|
||||
}
|
||||
}
|
||||
thread.name = threadName
|
||||
thread.start()
|
||||
}
|
||||
|
||||
override fun joinWorker(timeoutMs: Long) {
|
||||
// Kotlin/Native threads cannot be interrupted; the core wakes its own sleeper before joining.
|
||||
workerDone?.await(timeoutMs)
|
||||
workerDone = null
|
||||
}
|
||||
|
||||
override fun log(level: SessionLogLevel, tag: String, message: String, error: Throwable?) {
|
||||
when (level) {
|
||||
SessionLogLevel.DEBUG, SessionLogLevel.INFO -> PlatformLog.i(tag, message)
|
||||
SessionLogLevel.WARN -> PlatformLog.w(tag, if (error != null) "$message (${error.message})" else message)
|
||||
SessionLogLevel.ERROR -> PlatformLog.e(tag, message, error)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,173 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import platform.Foundation.NSThread
|
||||
import platform.darwin.dispatch_async
|
||||
import platform.darwin.dispatch_get_main_queue
|
||||
|
||||
private fun main(action: () -> Unit) {
|
||||
dispatch_async(dispatch_get_main_queue()) { action() }
|
||||
}
|
||||
|
||||
private fun runOnThread(name: String, body: () -> Unit) {
|
||||
val thread = NSThread { body() }
|
||||
thread.name = name
|
||||
thread.start()
|
||||
}
|
||||
|
||||
/**
|
||||
* iOS host for the shared [DeviceInfoProbeFlow]: owns a CoreBluetooth link, runs the flow on
|
||||
* its own NSThread and delivers listener callbacks on the main queue. Same surface as
|
||||
* Android's FaceclawDeviceInfoProbe. Addresses are peripheral identifiers.
|
||||
*/
|
||||
class IosDeviceInfoProbe(rightAddress: String, leftAddress: String) {
|
||||
private val link = IosBleCentral()
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
private var started = false
|
||||
private var listener: FaceclawDeviceInfoProbeListener? = null
|
||||
|
||||
private val flow = DeviceInfoProbeFlow(
|
||||
link,
|
||||
rightAddress,
|
||||
leftAddress,
|
||||
object : FaceclawDeviceInfoProbeListener {
|
||||
override fun onLog(line: String?) {
|
||||
PlatformLog.i(DeviceInfoProbeFlow.TAG, line ?: "")
|
||||
post { it.onLog(line) }
|
||||
}
|
||||
|
||||
override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") }
|
||||
|
||||
override fun onResult(leftVersion: String?, rightVersion: String?, extension: String?) =
|
||||
post { it.onResult(leftVersion, rightVersion, extension) }
|
||||
|
||||
override fun onError(message: String?) = post { it.onError(message ?: "") }
|
||||
},
|
||||
)
|
||||
|
||||
fun setListener(listener: FaceclawDeviceInfoProbeListener?) {
|
||||
lock.withLock { this.listener = listener }
|
||||
}
|
||||
|
||||
fun start() {
|
||||
lock.withLock {
|
||||
if (started) return
|
||||
started = true
|
||||
}
|
||||
runOnThread("faceclaw-device-info") { flow.run() }
|
||||
}
|
||||
|
||||
fun cancel() = flow.cancel()
|
||||
|
||||
fun close() {
|
||||
cancel()
|
||||
runCatching { link.close() }
|
||||
}
|
||||
|
||||
private fun post(action: (FaceclawDeviceInfoProbeListener) -> Unit) = main {
|
||||
lock.withLock { listener }?.let(action)
|
||||
}
|
||||
}
|
||||
|
||||
/** iOS host for the shared [FlashPromptFlow] (the on-glasses Yes/No confirmation before flashing). */
|
||||
class IosFlashPrompt(rightAddress: String, leftAddress: String, warningText: String, skipPrompt: Boolean) {
|
||||
private val link = IosBleCentral()
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
private var started = false
|
||||
private var listener: FaceclawFlashPromptListener? = null
|
||||
|
||||
private val flow = FlashPromptFlow(
|
||||
link,
|
||||
rightAddress,
|
||||
leftAddress,
|
||||
warningText,
|
||||
skipPrompt,
|
||||
object : FaceclawFlashPromptListener {
|
||||
override fun onLog(line: String?) {
|
||||
PlatformLog.i(FlashPromptFlow.TAG, line ?: "")
|
||||
post { it.onLog(line) }
|
||||
}
|
||||
|
||||
override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") }
|
||||
|
||||
override fun onBattery(rightPercent: Int, leftPercent: Int) = post { it.onBattery(rightPercent, leftPercent) }
|
||||
|
||||
override fun onResult(approved: Boolean) = post { it.onResult(approved) }
|
||||
},
|
||||
)
|
||||
|
||||
fun setListener(listener: FaceclawFlashPromptListener?) {
|
||||
lock.withLock { this.listener = listener }
|
||||
}
|
||||
|
||||
fun start() {
|
||||
lock.withLock {
|
||||
if (started) return
|
||||
started = true
|
||||
}
|
||||
runOnThread("faceclaw-flash-prompt") { flow.run() }
|
||||
}
|
||||
|
||||
fun cancel() = flow.cancel()
|
||||
|
||||
fun close() {
|
||||
cancel()
|
||||
runCatching { link.close() }
|
||||
}
|
||||
|
||||
private fun post(action: (FaceclawFlashPromptListener) -> Unit) = main {
|
||||
lock.withLock { listener }?.let(action)
|
||||
}
|
||||
}
|
||||
|
||||
/** iOS host for the shared [OtaFlashFlow] (custom-firmware OTA over the stock protocol). */
|
||||
class IosFirmwareFlasher(rightAddress: String, leftAddress: String, firmwarePath: String) {
|
||||
private val link = IosBleCentral()
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
private var started = false
|
||||
private var listener: FaceclawFirmwareFlasherListener? = null
|
||||
|
||||
private val flow = OtaFlashFlow(
|
||||
link,
|
||||
rightAddress,
|
||||
leftAddress,
|
||||
firmwarePath,
|
||||
object : FaceclawFirmwareFlasherListener {
|
||||
override fun onLog(line: String?) {
|
||||
PlatformLog.i(OtaFlashFlow.TAG, line ?: "")
|
||||
post { it.onLog(line) }
|
||||
}
|
||||
|
||||
override fun onProgress(lens: String?, componentIndex: Int, componentCount: Int, blockIndex: Int, blockCount: Int, bytesSent: Long, bytesTotal: Long) =
|
||||
post { it.onProgress(lens, componentIndex, componentCount, blockIndex, blockCount, bytesSent, bytesTotal) }
|
||||
|
||||
override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") }
|
||||
|
||||
override fun onComplete(success: Boolean, detail: String?) = post { it.onComplete(success, detail ?: "") }
|
||||
},
|
||||
)
|
||||
|
||||
fun setListener(listener: FaceclawFirmwareFlasherListener?) {
|
||||
lock.withLock { this.listener = listener }
|
||||
}
|
||||
|
||||
fun start() {
|
||||
lock.withLock {
|
||||
if (started) return
|
||||
started = true
|
||||
}
|
||||
runOnThread("faceclaw-flasher") { flow.run() }
|
||||
}
|
||||
|
||||
fun cancel() = flow.cancel()
|
||||
|
||||
fun close() {
|
||||
cancel()
|
||||
runCatching { link.close() }
|
||||
}
|
||||
|
||||
private fun post(action: (FaceclawFirmwareFlasherListener) -> Unit) = main {
|
||||
lock.withLock { listener }?.let(action)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,257 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
|
||||
import kotlinx.cinterop.addressOf
|
||||
import kotlinx.cinterop.convert
|
||||
import kotlinx.cinterop.usePinned
|
||||
import platform.Foundation.NSData
|
||||
import platform.Foundation.NSError
|
||||
import platform.Foundation.NSFileManager
|
||||
import platform.Foundation.NSHTTPURLResponse
|
||||
import platform.Foundation.NSURLResponse
|
||||
import platform.Foundation.NSURLSession
|
||||
import platform.Foundation.NSURLSessionConfiguration
|
||||
import platform.Foundation.NSURLSessionDataDelegateProtocol
|
||||
import platform.Foundation.NSURLSessionDataTask
|
||||
import platform.Foundation.NSURLSessionResponseAllow
|
||||
import platform.Foundation.NSURLSessionResponseDisposition
|
||||
import platform.Foundation.NSURLSessionTask
|
||||
import platform.darwin.NSObject
|
||||
import platform.posix.fclose
|
||||
import platform.posix.fopen
|
||||
import platform.posix.fread
|
||||
import platform.posix.fwrite
|
||||
|
||||
/**
|
||||
* iOS twin of the Android FaceclawModelDownloader: NSURLSession transport and POSIX
|
||||
* storage under the shared [ResumableDownload], run on its own thread with listener
|
||||
* callbacks on the main queue. Same constructor/start/cancel shape as Android.
|
||||
*/
|
||||
class IosModelDownloader internal constructor(
|
||||
url: String,
|
||||
destPath: String,
|
||||
expectedSha256: String?,
|
||||
expectedTotalBytes: Long,
|
||||
listener: FaceclawModelDownloaderListener,
|
||||
dispatch: (() -> Unit) -> Unit,
|
||||
) {
|
||||
constructor(url: String, destPath: String, expectedSha256: String?, expectedTotalBytes: Long, listener: FaceclawModelDownloaderListener) :
|
||||
this(url, destPath, expectedSha256, expectedTotalBytes, listener, ::dispatchToMain)
|
||||
|
||||
private val transport = IosDownloadTransport()
|
||||
private val download: ResumableDownload
|
||||
|
||||
init {
|
||||
val posted = object : FaceclawModelDownloaderListener {
|
||||
override fun onProgress(bytesDownloaded: Long, totalBytes: Long) = dispatch { listener.onProgress(bytesDownloaded, totalBytes) }
|
||||
|
||||
override fun onDone(path: String?) = dispatch { listener.onDone(path) }
|
||||
|
||||
override fun onError(message: String?) = dispatch { listener.onError(message) }
|
||||
}
|
||||
download = ResumableDownload(url, destPath, expectedSha256, expectedTotalBytes, transport, IosDownloadStorage, posted)
|
||||
}
|
||||
|
||||
fun start() = startThread("FaceclawModelDl", true) { download.run() }
|
||||
|
||||
/** Stops the download but keeps the .part file so a later start() resumes. */
|
||||
fun cancel() {
|
||||
download.cancel()
|
||||
transport.cancel()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Blocking-read view of an NSURLSession data task: the delegate queues body chunks and the
|
||||
* reader drains them, suspending the task while too much is buffered.
|
||||
*/
|
||||
internal class IosDownloadTransport : DownloadTransport {
|
||||
@Volatile
|
||||
private var current: Session? = null
|
||||
|
||||
fun cancel() {
|
||||
current?.close()
|
||||
}
|
||||
|
||||
override fun open(url: String, rangeFrom: Long): DownloadResponse {
|
||||
val target = parseUrl(url) ?: error("Invalid download URL")
|
||||
val headers = if (rangeFrom > 0) listOf("Range" to "bytes=$rangeFrom-") else emptyList()
|
||||
val request = buildRequest(target, "GET", null, headers)
|
||||
val configuration = NSURLSessionConfiguration.ephemeralSessionConfiguration
|
||||
configuration.timeoutIntervalForRequest = 60.0
|
||||
configuration.timeoutIntervalForResource = 7 * 24 * 3600.0
|
||||
val session = Session()
|
||||
current = session
|
||||
session.start(configuration, request)
|
||||
if (!session.responded.await(30_000)) {
|
||||
session.close()
|
||||
error("download timed out waiting for the server")
|
||||
}
|
||||
session.failure?.let { session.close(); error(it) }
|
||||
return session
|
||||
}
|
||||
|
||||
/** Body reader; NSURLSession callbacks arrive through [Delegate] on the session's queue. */
|
||||
private class Session : DownloadResponse {
|
||||
private val platform = IosProtocolPlatform
|
||||
val responded = Latch(1, platform)
|
||||
private val chunks = BlockingQueue<ByteArray>(platform)
|
||||
private val lock = platform.createLock()
|
||||
private var queuedBytes = 0L
|
||||
private var suspended = false
|
||||
private var pending: ByteArray? = null
|
||||
private var pendingOffset = 0
|
||||
private var ended = false
|
||||
|
||||
@Volatile
|
||||
var failure: String? = null
|
||||
private var session: NSURLSession? = null
|
||||
private var task: NSURLSessionDataTask? = null
|
||||
|
||||
override var code: Int = 0
|
||||
private set
|
||||
|
||||
override var contentLength: Long = -1
|
||||
private set
|
||||
|
||||
fun start(configuration: NSURLSessionConfiguration, request: platform.Foundation.NSURLRequest) {
|
||||
val created = NSURLSession.sessionWithConfiguration(configuration, Delegate(this), delegateQueue = null)
|
||||
session = created
|
||||
task = created.dataTaskWithRequest(request).also { it.resume() }
|
||||
}
|
||||
|
||||
fun onResponse(response: NSURLResponse) {
|
||||
code = (response as? NSHTTPURLResponse)?.statusCode?.toInt() ?: 0
|
||||
contentLength = response.expectedContentLength
|
||||
responded.countDown()
|
||||
}
|
||||
|
||||
fun onData(data: NSData, dataTask: NSURLSessionDataTask) {
|
||||
val bytes = data.byteArray()
|
||||
if (bytes.isEmpty()) return
|
||||
chunks.put(bytes)
|
||||
lock.withLock {
|
||||
queuedBytes += bytes.size
|
||||
if (queuedBytes > HIGH_WATER && !suspended) {
|
||||
suspended = true
|
||||
dataTask.suspend()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun onFinished(error: NSError?) {
|
||||
if (error != null) failure = error.localizedDescription
|
||||
responded.countDown()
|
||||
chunks.put(END)
|
||||
}
|
||||
|
||||
override fun read(buffer: ByteArray): Int {
|
||||
var source = pending
|
||||
if (source == null) {
|
||||
if (ended) return -1
|
||||
val next = chunks.poll(60_000) ?: error("download stalled")
|
||||
if (next === END) {
|
||||
ended = true
|
||||
failure?.let { error(it) }
|
||||
return -1
|
||||
}
|
||||
source = next
|
||||
pendingOffset = 0
|
||||
}
|
||||
val count = minOf(buffer.size, source.size - pendingOffset)
|
||||
source.copyInto(buffer, 0, pendingOffset, pendingOffset + count)
|
||||
pendingOffset += count
|
||||
if (pendingOffset >= source.size) {
|
||||
pending = null
|
||||
lock.withLock {
|
||||
queuedBytes -= source.size
|
||||
if (suspended && queuedBytes < LOW_WATER) {
|
||||
suspended = false
|
||||
task?.resume()
|
||||
}
|
||||
}
|
||||
} else pending = source
|
||||
return count
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
session?.invalidateAndCancel()
|
||||
session = null
|
||||
chunks.put(END)
|
||||
}
|
||||
}
|
||||
|
||||
private class Delegate(private val owner: Session) : NSObject(), NSURLSessionDataDelegateProtocol {
|
||||
override fun URLSession(
|
||||
session: NSURLSession,
|
||||
dataTask: NSURLSessionDataTask,
|
||||
didReceiveResponse: NSURLResponse,
|
||||
completionHandler: (NSURLSessionResponseDisposition) -> Unit,
|
||||
) {
|
||||
owner.onResponse(didReceiveResponse)
|
||||
completionHandler(NSURLSessionResponseAllow)
|
||||
}
|
||||
|
||||
override fun URLSession(session: NSURLSession, dataTask: NSURLSessionDataTask, didReceiveData: NSData) =
|
||||
owner.onData(didReceiveData, dataTask)
|
||||
|
||||
override fun URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError: NSError?) {
|
||||
owner.onFinished(didCompleteWithError)
|
||||
session.finishTasksAndInvalidate()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private val END = ByteArray(0)
|
||||
private const val HIGH_WATER = 4L * 1024 * 1024
|
||||
private const val LOW_WATER = 1L * 1024 * 1024
|
||||
|
||||
/** POSIX file storage for downloads; multi-GB files stream through fixed buffers. */
|
||||
internal object IosDownloadStorage : DownloadStorage {
|
||||
override fun length(path: String): Long = fileLength(path)
|
||||
|
||||
override fun prepareParent(path: String) {
|
||||
val parent = path.substringBeforeLast('/', "")
|
||||
if (parent.isNotEmpty()) NSFileManager.defaultManager.createDirectoryAtPath(parent, true, null, null)
|
||||
}
|
||||
|
||||
override fun openWrite(path: String, append: Boolean): FileSink {
|
||||
val file = fopen(path, if (append) "ab" else "wb") ?: error("Cannot write $path")
|
||||
return object : FileSink {
|
||||
override fun write(bytes: ByteArray, offset: Int, length: Int) {
|
||||
if (length <= 0) return
|
||||
bytes.usePinned {
|
||||
check(fwrite(it.addressOf(offset), 1u, length.convert(), file) == length.convert<platform.posix.size_t>()) { "Short write to $path" }
|
||||
}
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
fclose(file)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun readAll(path: String, consumer: (ByteArray, Int) -> Boolean): Long {
|
||||
val file = fopen(path, "rb") ?: return 0
|
||||
var consumed = 0L
|
||||
try {
|
||||
val buffer = ByteArray(1 shl 16)
|
||||
while (true) {
|
||||
val read = buffer.usePinned { fread(it.addressOf(0), 1u, buffer.size.convert(), file) }.toInt()
|
||||
if (read <= 0) break
|
||||
if (!consumer(buffer, read)) break
|
||||
consumed += read
|
||||
}
|
||||
} finally {
|
||||
fclose(file)
|
||||
}
|
||||
return consumed
|
||||
}
|
||||
|
||||
override fun rename(from: String, to: String): Boolean = renameFile(from, to)
|
||||
|
||||
override fun delete(path: String): Boolean = deleteFile(path)
|
||||
}
|
||||
@@ -0,0 +1,265 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
|
||||
import kotlinx.cinterop.ByteVar
|
||||
import kotlinx.cinterop.CPointer
|
||||
import kotlinx.cinterop.IntVar
|
||||
import kotlinx.cinterop.addressOf
|
||||
import kotlinx.cinterop.alloc
|
||||
import kotlinx.cinterop.allocArray
|
||||
import kotlinx.cinterop.allocPointerTo
|
||||
import kotlinx.cinterop.CFunction
|
||||
import kotlinx.cinterop.COpaquePointer
|
||||
import kotlinx.cinterop.COpaquePointerVar
|
||||
import kotlinx.cinterop.UIntVar
|
||||
import kotlinx.cinterop.invoke
|
||||
import kotlinx.cinterop.plus
|
||||
import kotlinx.cinterop.convert
|
||||
import kotlinx.cinterop.memScoped
|
||||
import kotlinx.cinterop.pointed
|
||||
import kotlinx.cinterop.ptr
|
||||
import kotlinx.cinterop.reinterpret
|
||||
import kotlinx.cinterop.sizeOf
|
||||
import kotlinx.cinterop.toKString
|
||||
import kotlinx.cinterop.usePinned
|
||||
import kotlinx.cinterop.value
|
||||
import platform.Security.SecRandomCopyBytes
|
||||
import platform.Security.kSecRandomDefault
|
||||
import platform.posix.AF_INET
|
||||
import platform.posix.AF_INET6
|
||||
import platform.posix.AI_NUMERICHOST
|
||||
import platform.posix.AI_NUMERICSERV
|
||||
import platform.posix.IFF_LOOPBACK
|
||||
import platform.posix.IFF_POINTOPOINT
|
||||
import platform.posix.IFF_UP
|
||||
import platform.posix.IPPROTO_TCP
|
||||
import platform.posix.NI_MAXHOST
|
||||
import platform.posix.NI_NUMERICHOST
|
||||
import platform.posix.POLLIN
|
||||
import platform.posix.SHUT_RDWR
|
||||
import platform.posix.SOCK_STREAM
|
||||
import platform.posix.SOL_SOCKET
|
||||
import platform.posix.SO_NOSIGPIPE
|
||||
import platform.posix.SO_REUSEADDR
|
||||
import platform.posix.TCP_NODELAY
|
||||
import platform.posix.accept
|
||||
import platform.posix.addrinfo
|
||||
import platform.posix.bind
|
||||
import platform.posix.close
|
||||
import platform.posix.dlopen
|
||||
import platform.posix.dlsym
|
||||
import platform.posix.RTLD_NOW
|
||||
import platform.posix.freeaddrinfo
|
||||
import platform.posix.getaddrinfo
|
||||
import platform.posix.getnameinfo
|
||||
import platform.posix.listen
|
||||
import platform.posix.poll
|
||||
import platform.posix.pollfd
|
||||
import platform.posix.recv
|
||||
import platform.posix.send
|
||||
import platform.posix.setsockopt
|
||||
import platform.posix.shutdown
|
||||
import platform.posix.sockaddr
|
||||
import platform.posix.socket
|
||||
|
||||
/** Numeric host text of a socket address, or null when it is not IPv4/IPv6. */
|
||||
private fun numericHost(address: CPointer<sockaddr>?): String? {
|
||||
if (address == null) return null
|
||||
val family = address.pointed.sa_family.toInt()
|
||||
if (family != AF_INET && family != AF_INET6) return null
|
||||
return memScoped {
|
||||
val host = allocArray<ByteVar>(NI_MAXHOST)
|
||||
val status = getnameinfo(address, address.pointed.sa_len.convert(), host, NI_MAXHOST.convert(), null, 0u, NI_NUMERICHOST)
|
||||
if (status != 0) null else host.toKString()
|
||||
}
|
||||
}
|
||||
|
||||
// Kotlin/Native's POSIX library for iOS does not bind <ifaddrs.h>, so the two functions are
|
||||
// resolved from libSystem at runtime and `struct ifaddrs` is read by its fixed 64-bit layout:
|
||||
// ifa_next @0, ifa_name @8, ifa_flags @16, ifa_addr @24 (netmask @32, dstaddr @40, data @48).
|
||||
private typealias GetIfAddrs = CFunction<(CPointer<COpaquePointerVar>) -> Int>
|
||||
private typealias FreeIfAddrs = CFunction<(COpaquePointer?) -> Unit>
|
||||
|
||||
private val libSystem: COpaquePointer? by lazy { dlopen(null, RTLD_NOW) }
|
||||
|
||||
private fun CPointer<*>.pointerField(offset: Int): COpaquePointer? =
|
||||
(this.reinterpret<ByteVar>() + offset)!!.reinterpret<COpaquePointerVar>().pointed.value
|
||||
|
||||
private fun CPointer<*>.uintField(offset: Int): UInt =
|
||||
(this.reinterpret<ByteVar>() + offset)!!.reinterpret<UIntVar>().pointed.value
|
||||
|
||||
/** Every address assigned to a local interface, as the shared session's [InterfaceAddress]. */
|
||||
fun iosInterfaceAddresses(): List<InterfaceAddress> {
|
||||
val result = ArrayList<InterfaceAddress>()
|
||||
val getifaddrs = dlsym(libSystem, "getifaddrs")?.reinterpret<GetIfAddrs>() ?: return result
|
||||
val freeifaddrs = dlsym(libSystem, "freeifaddrs")?.reinterpret<FreeIfAddrs>() ?: return result
|
||||
memScoped {
|
||||
val list = alloc<COpaquePointerVar>()
|
||||
if (getifaddrs(list.ptr) != 0) return result
|
||||
try {
|
||||
var item: COpaquePointer? = list.value
|
||||
while (item != null) {
|
||||
val host = numericHost(item.pointerField(24)?.reinterpret())
|
||||
if (host != null) {
|
||||
val flags = item.uintField(16).toInt()
|
||||
val bare = host.substringBefore('%')
|
||||
val loopbackFlag = flags and IFF_LOOPBACK != 0
|
||||
result.add(InterfaceAddress(
|
||||
interfaceName = item.pointerField(8)?.reinterpret<ByteVar>()?.toKString() ?: "",
|
||||
address = host,
|
||||
up = flags and IFF_UP != 0,
|
||||
pointToPoint = flags and IFF_POINTOPOINT != 0,
|
||||
loopback = loopbackFlag || bare.startsWith("127.") || bare == "::1",
|
||||
linkLocal = bare.startsWith("169.254.") || bare.lowercase().startsWith("fe80:"),
|
||||
anyLocal = bare == "0.0.0.0" || bare == "::",
|
||||
))
|
||||
}
|
||||
item = item.pointerField(0)
|
||||
}
|
||||
} finally {
|
||||
freeifaddrs(list.value)
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
private fun setIntOption(fd: Int, level: Int, option: Int, value: Int) {
|
||||
memScoped {
|
||||
val holder = alloc<IntVar>()
|
||||
holder.value = value
|
||||
setsockopt(fd, level, option, holder.ptr, sizeOf<IntVar>().convert())
|
||||
}
|
||||
}
|
||||
|
||||
/** Canonical numeric text of a literal address, or null when it is not a literal. */
|
||||
private fun canonicalAddress(address: String): String? =
|
||||
memScoped {
|
||||
val hints = alloc<addrinfo>()
|
||||
hints.ai_flags = AI_NUMERICHOST
|
||||
hints.ai_socktype = SOCK_STREAM
|
||||
val resolved = allocPointerTo<addrinfo>()
|
||||
if (getaddrinfo(address, null, hints.ptr, resolved.ptr) != 0) return null
|
||||
try {
|
||||
numericHost(resolved.value?.pointed?.ai_addr)
|
||||
} finally {
|
||||
freeaddrinfo(resolved.value)
|
||||
}
|
||||
}
|
||||
|
||||
/** POSIX sockets for the shared [RemoteInputSession]. */
|
||||
object IosLocalServerPort : LocalServerPort {
|
||||
override fun isLocalUnicastAddress(address: String): Boolean {
|
||||
val canonical = canonicalAddress(address) ?: return false
|
||||
// Wildcard and multicast addresses are never assigned to an interface.
|
||||
return iosInterfaceAddresses().any { it.address == canonical || it.address.substringBefore('%') == canonical }
|
||||
}
|
||||
|
||||
override fun bind(address: String, port: Int): RemoteInputListener {
|
||||
val fd = memScoped {
|
||||
val hints = alloc<addrinfo>()
|
||||
hints.ai_flags = AI_NUMERICHOST or AI_NUMERICSERV
|
||||
hints.ai_socktype = SOCK_STREAM
|
||||
val resolved = allocPointerTo<addrinfo>()
|
||||
if (getaddrinfo(address, port.toString(), hints.ptr, resolved.ptr) != 0) error("Invalid address")
|
||||
try {
|
||||
val info = resolved.value!!.pointed
|
||||
val socketFd = socket(info.ai_family, SOCK_STREAM, 0)
|
||||
if (socketFd < 0) error("socket failed")
|
||||
setIntOption(socketFd, SOL_SOCKET, SO_REUSEADDR, 1)
|
||||
if (bind(socketFd, info.ai_addr, info.ai_addrlen) != 0 || listen(socketFd, 8) != 0) {
|
||||
close(socketFd)
|
||||
error("bind failed")
|
||||
}
|
||||
socketFd
|
||||
} finally {
|
||||
freeaddrinfo(resolved.value)
|
||||
}
|
||||
}
|
||||
return PosixListener(fd)
|
||||
}
|
||||
}
|
||||
|
||||
private class PosixListener(private val fd: Int) : RemoteInputListener {
|
||||
@Volatile
|
||||
private var closed = false
|
||||
|
||||
override val isClosed: Boolean
|
||||
get() = closed
|
||||
|
||||
override fun accept(): RemoteInputConnection? {
|
||||
while (!closed) {
|
||||
// Polling also guarantees close() is observed where shutdown does not wake accept.
|
||||
val ready = memScoped {
|
||||
val request = alloc<pollfd>()
|
||||
request.fd = fd
|
||||
request.events = POLLIN.toShort()
|
||||
poll(request.ptr, 1u, 250)
|
||||
}
|
||||
if (closed) return null
|
||||
if (ready <= 0) continue
|
||||
val client = accept(fd, null, null)
|
||||
if (client < 0) return null
|
||||
setIntOption(client, SOL_SOCKET, SO_NOSIGPIPE, 1)
|
||||
setIntOption(client, IPPROTO_TCP, TCP_NODELAY, 1)
|
||||
return PosixConnection(client)
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
shutdown(fd, SHUT_RDWR)
|
||||
close(fd)
|
||||
}
|
||||
}
|
||||
|
||||
private class PosixConnection(private val fd: Int) : RemoteInputConnection {
|
||||
@Volatile
|
||||
private var closed = false
|
||||
|
||||
override fun readByte(timeoutMs: Long): Int {
|
||||
if (closed) return -1
|
||||
return memScoped {
|
||||
val request = alloc<pollfd>()
|
||||
request.fd = fd
|
||||
request.events = POLLIN.toShort()
|
||||
if (poll(request.ptr, 1u, timeoutMs.coerceIn(0L, Int.MAX_VALUE.toLong()).toInt()) <= 0) return -1
|
||||
val byte = alloc<ByteVar>()
|
||||
if (recv(fd, byte.ptr, 1u, 0) != 1L) -1 else byte.value.toInt() and 0xff
|
||||
}
|
||||
}
|
||||
|
||||
override fun write(bytes: ByteArray) {
|
||||
if (bytes.isEmpty() || closed) return
|
||||
bytes.usePinned { pinned ->
|
||||
var offset = 0
|
||||
while (offset < bytes.size) {
|
||||
val sent = send(fd, pinned.addressOf(offset), (bytes.size - offset).convert(), 0)
|
||||
if (sent <= 0L) error("send failed")
|
||||
offset += sent.toInt()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
shutdown(fd, SHUT_RDWR)
|
||||
close(fd)
|
||||
}
|
||||
}
|
||||
|
||||
/** Cryptographically secure bytes from the Security framework. */
|
||||
object IosSecureRandom : RandomSource {
|
||||
override fun nextBytes(count: Int): ByteArray {
|
||||
val bytes = ByteArray(count)
|
||||
if (count == 0) return bytes
|
||||
val status = bytes.usePinned { SecRandomCopyBytes(kSecRandomDefault, count.convert(), it.addressOf(0)) }
|
||||
check(status == 0) { "SecRandomCopyBytes failed: $status" }
|
||||
return bytes
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import platform.darwin.dispatch_async
|
||||
import platform.darwin.dispatch_get_main_queue
|
||||
|
||||
/** Runs [action] on the main queue, where NativeScript's JavaScript lives. */
|
||||
internal fun dispatchToMain(action: () -> Unit) {
|
||||
dispatch_async(dispatch_get_main_queue()) { action() }
|
||||
}
|
||||
|
||||
/**
|
||||
* iOS facade over the shared [RemoteInputSession] for the TypeScript side
|
||||
* (app/native/remote-input.ios.ts): POSIX sockets, Security-framework randomness and
|
||||
* main-queue request notifications. Mirrors the Android FaceclawRemoteInput API.
|
||||
*/
|
||||
class IosRemoteInput internal constructor(
|
||||
dispatch: (() -> Unit) -> Unit,
|
||||
requestTimeoutMs: Long,
|
||||
) {
|
||||
constructor() : this(::dispatchToMain, RemoteInputSession.REQUEST_TIMEOUT_MS)
|
||||
|
||||
private val session = RemoteInputSession(
|
||||
port = IosLocalServerPort,
|
||||
random = IosSecureRandom,
|
||||
dispatch = dispatch,
|
||||
platform = IosProtocolPlatform,
|
||||
requestTimeoutMs = requestTimeoutMs,
|
||||
)
|
||||
|
||||
/** Called (on the main queue) whenever a request is waiting in [nextRequest]. */
|
||||
fun setRequestListener(listener: (() -> Unit)?) = session.setRequestListener(listener)
|
||||
|
||||
fun start(port: Int): String = startAddress(port, "127.0.0.1")
|
||||
|
||||
/** Returns "" on success or a user-facing error. */
|
||||
fun startAddress(port: Int, address: String): String = session.start(port, address)
|
||||
|
||||
fun stop() = session.stop()
|
||||
|
||||
fun nextRequest(): String? = session.nextRequest()
|
||||
|
||||
fun complete(id: Long, value: String?) = session.complete(id, value)
|
||||
|
||||
fun randomSecret(): String = session.randomSecret()
|
||||
|
||||
fun tokenDigest(value: String): String = RemoteInputSession.tokenHash(value)
|
||||
|
||||
/** JSON array of {name, address, pointToPoint} for the reachable local interfaces. */
|
||||
fun interfaces(): String = RemoteInputSession.interfacesJson(iosInterfaceAddresses())
|
||||
|
||||
companion object {
|
||||
val shared: IosRemoteInput by lazy { IosRemoteInput() }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
|
||||
import platform.Foundation.NSRecursiveLock
|
||||
import platform.UIKit.UIApplication
|
||||
import platform.UIKit.UIBackgroundTaskIdentifier
|
||||
import platform.UIKit.UIBackgroundTaskInvalid
|
||||
|
||||
/**
|
||||
* iOS twin of the Android FaceclawSseRequest for app/native/sse.ios.ts: starts a streaming
|
||||
* POST immediately and pushes the shared [SseStream] events to [listener] on the main queue,
|
||||
* in order. A UIKit background task keeps the stream alive while the app is backgrounded.
|
||||
* headersJson is a JSON object of header name to value.
|
||||
*/
|
||||
class IosSseRequest internal constructor(
|
||||
url: String,
|
||||
body: String,
|
||||
headersJson: String?,
|
||||
private val listener: FaceclawSseListener,
|
||||
private val dispatch: (() -> Unit) -> Unit,
|
||||
keepAliveInBackground: Boolean,
|
||||
) {
|
||||
constructor(url: String, body: String, headersJson: String?, listener: FaceclawSseListener) :
|
||||
this(url, body, headersJson, listener, ::dispatchToMain, true)
|
||||
|
||||
private val stream = SseStream()
|
||||
private val lock = NSRecursiveLock()
|
||||
private var backgroundTask: UIBackgroundTaskIdentifier = UIBackgroundTaskInvalid
|
||||
private var keepAlive = keepAliveInBackground
|
||||
|
||||
@Volatile
|
||||
private var cancelled = false
|
||||
private val transfer: Cancellable
|
||||
|
||||
init {
|
||||
val headers = ArrayList<Pair<String, String>>()
|
||||
if (!headersJson.isNullOrBlank()) {
|
||||
runCatching { Json.parse(headersJson).asObject() }.getOrNull()?.forEach { (name, value) ->
|
||||
val text = value.asString()
|
||||
if (name.isNotEmpty() && text != null) headers.add(name to text)
|
||||
}
|
||||
}
|
||||
if (keepAlive) dispatchToMain { beginBackgroundTask() }
|
||||
val sink = object : ChunkSink {
|
||||
override fun onStatus(code: Int) = stream.onStatus(code)
|
||||
|
||||
override fun onChunk(bytes: ByteArray, offset: Int, length: Int) {
|
||||
stream.onChunk(bytes, offset, length)
|
||||
drain()
|
||||
}
|
||||
|
||||
override fun onComplete() {
|
||||
stream.onComplete()
|
||||
drain()
|
||||
}
|
||||
|
||||
override fun onFailure(message: String) {
|
||||
stream.onFailure(message)
|
||||
drain()
|
||||
}
|
||||
}
|
||||
transfer = IosStreamingHttp.post(url.trim(), body, headers, sink)
|
||||
}
|
||||
|
||||
fun cancel() {
|
||||
cancelled = true
|
||||
stream.cancel()
|
||||
transfer.cancel()
|
||||
if (keepAlive) dispatchToMain { endBackgroundTask() }
|
||||
}
|
||||
|
||||
/** Hands every queued event to the listener on the main queue, in order. */
|
||||
private fun drain() {
|
||||
val events = stream.takeEvents()
|
||||
if (events.isEmpty()) return
|
||||
dispatch {
|
||||
for (event in events) {
|
||||
if (cancelled) return@dispatch
|
||||
try {
|
||||
SseStream.deliver(event, listener)
|
||||
} catch (t: Throwable) {
|
||||
PlatformLog.w(TAG, "listener callback failed: ${t.message}")
|
||||
}
|
||||
}
|
||||
if (stream.isFinished && keepAlive) endBackgroundTask()
|
||||
}
|
||||
}
|
||||
|
||||
// Main queue only.
|
||||
private fun beginBackgroundTask() {
|
||||
lock.lock()
|
||||
try {
|
||||
if (cancelled || stream.isFinished || backgroundTask != UIBackgroundTaskInvalid) return
|
||||
backgroundTask = UIApplication.sharedApplication.beginBackgroundTaskWithName("Assistant response") {
|
||||
stream.onFailure("iOS background time expired. Open Faceclaw and retry.")
|
||||
drain()
|
||||
endBackgroundTask()
|
||||
}
|
||||
} finally {
|
||||
lock.unlock()
|
||||
}
|
||||
}
|
||||
|
||||
private fun endBackgroundTask() {
|
||||
lock.lock()
|
||||
try {
|
||||
if (backgroundTask == UIBackgroundTaskInvalid) return
|
||||
UIApplication.sharedApplication.endBackgroundTask(backgroundTask)
|
||||
backgroundTask = UIBackgroundTaskInvalid
|
||||
} finally {
|
||||
lock.unlock()
|
||||
}
|
||||
}
|
||||
|
||||
private companion object {
|
||||
const val TAG = "FaceclawSseRequest"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
|
||||
import platform.Foundation.NSData
|
||||
import platform.Foundation.NSError
|
||||
import platform.Foundation.NSHTTPURLResponse
|
||||
import platform.Foundation.NSMutableURLRequest
|
||||
import platform.Foundation.NSString
|
||||
import platform.Foundation.NSURL
|
||||
import platform.Foundation.NSURLRequest
|
||||
import platform.Foundation.NSURLResponse
|
||||
import platform.Foundation.NSURLSession
|
||||
import platform.Foundation.NSURLSessionConfiguration
|
||||
import platform.Foundation.NSURLSessionDataDelegateProtocol
|
||||
import platform.Foundation.NSURLSessionDataTask
|
||||
import platform.Foundation.NSURLSessionResponseAllow
|
||||
import platform.Foundation.NSURLSessionResponseDisposition
|
||||
import platform.Foundation.NSURLSessionTask
|
||||
import platform.Foundation.NSUTF8StringEncoding
|
||||
import platform.Foundation.create
|
||||
import platform.Foundation.dataUsingEncoding
|
||||
import platform.Foundation.setHTTPBody
|
||||
import platform.Foundation.setHTTPMethod
|
||||
import platform.Foundation.setValue
|
||||
import platform.darwin.NSObject
|
||||
|
||||
/** Builds an NSURLRequest with the shared User-Agent unless the caller supplied one. */
|
||||
internal fun buildRequest(url: NSURL, method: String, body: String?, headers: List<Pair<String, String>>): NSMutableURLRequest {
|
||||
val request = NSMutableURLRequest.requestWithURL(url)
|
||||
request.setHTTPMethod(method)
|
||||
if (body != null) request.setHTTPBody((body as NSString).dataUsingEncoding(NSUTF8StringEncoding))
|
||||
var hasUserAgent = false
|
||||
for ((name, value) in headers) {
|
||||
if (name.equals("User-Agent", ignoreCase = true)) hasUserAgent = true
|
||||
request.setValue(value, forHTTPHeaderField = name)
|
||||
}
|
||||
if (!hasUserAgent) request.setValue(HttpIdentity.getUserAgent(), forHTTPHeaderField = "User-Agent")
|
||||
return request
|
||||
}
|
||||
|
||||
internal fun parseUrl(url: String): NSURL? {
|
||||
val target = NSURL.URLWithString(url) ?: return null
|
||||
val scheme = target.scheme?.lowercase() ?: return null
|
||||
return if (scheme == "https" || scheme == "http") target else null
|
||||
}
|
||||
|
||||
/**
|
||||
* Streaming POST over NSURLSession for the shared [SseStream]. Redirects are refused so
|
||||
* provider credentials in the headers are never forwarded; a 3xx reaches the sink as a
|
||||
* status with an (empty) body. Delegate callbacks arrive on NSURLSession's own queue.
|
||||
*/
|
||||
internal object IosStreamingHttp : StreamingHttp {
|
||||
override fun post(url: String, body: String, headers: List<Pair<String, String>>, sink: ChunkSink): Cancellable {
|
||||
val target = parseUrl(url)
|
||||
if (target == null) {
|
||||
sink.onFailure("Invalid streaming URL")
|
||||
return object : Cancellable { override fun cancel() {} }
|
||||
}
|
||||
val request = buildRequest(target, "POST", body, listOf("Content-Type" to "application/json; charset=utf-8", "Accept" to "text/event-stream") + headers)
|
||||
val configuration = NSURLSessionConfiguration.ephemeralSessionConfiguration
|
||||
configuration.timeoutIntervalForRequest = 180.0
|
||||
configuration.timeoutIntervalForResource = 180.0
|
||||
val delegate = StreamingDelegate(sink)
|
||||
val session = NSURLSession.sessionWithConfiguration(configuration, delegate, delegateQueue = null)
|
||||
val task = session.dataTaskWithRequest(request)
|
||||
task.resume()
|
||||
return object : Cancellable {
|
||||
override fun cancel() {
|
||||
delegate.cancelled = true
|
||||
session.invalidateAndCancel()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class StreamingDelegate(private val sink: ChunkSink) : NSObject(), NSURLSessionDataDelegateProtocol {
|
||||
@Volatile
|
||||
var cancelled = false
|
||||
|
||||
override fun URLSession(
|
||||
session: NSURLSession,
|
||||
dataTask: NSURLSessionDataTask,
|
||||
didReceiveResponse: NSURLResponse,
|
||||
completionHandler: (NSURLSessionResponseDisposition) -> Unit,
|
||||
) {
|
||||
val code = (didReceiveResponse as? NSHTTPURLResponse)?.statusCode?.toInt() ?: 0
|
||||
if (!cancelled) sink.onStatus(code)
|
||||
completionHandler(NSURLSessionResponseAllow)
|
||||
}
|
||||
|
||||
override fun URLSession(session: NSURLSession, dataTask: NSURLSessionDataTask, didReceiveData: NSData) {
|
||||
if (cancelled) return
|
||||
val bytes = didReceiveData.byteArray()
|
||||
sink.onChunk(bytes, 0, bytes.size)
|
||||
}
|
||||
|
||||
override fun URLSession(
|
||||
session: NSURLSession,
|
||||
task: NSURLSessionTask,
|
||||
willPerformHTTPRedirection: NSHTTPURLResponse,
|
||||
newRequest: NSURLRequest,
|
||||
completionHandler: (NSURLRequest?) -> Unit,
|
||||
) {
|
||||
// Never forward provider credentials to a redirected endpoint.
|
||||
completionHandler(null)
|
||||
}
|
||||
|
||||
override fun URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError: NSError?) {
|
||||
if (cancelled) return
|
||||
if (didCompleteWithError != null) sink.onFailure(didCompleteWithError.localizedDescription)
|
||||
else sink.onComplete()
|
||||
session.finishTasksAndInvalidate()
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-1
@@ -18,7 +18,8 @@
|
||||
"release": "scripts/release.sh",
|
||||
"clean": "rm -rf platforms",
|
||||
"test": "tsc -p tests/tsconfig.json && node --test tests/*.test.cjs",
|
||||
"test:kotlin:ios": "bash scripts/test-kotlin.sh iosSimulatorArm64Test compileKotlinIosArm64"
|
||||
"test:kotlin:ios": "bash scripts/test-kotlin.sh iosSimulatorArm64Test compileKotlinIosArm64",
|
||||
"postinstall": "node scripts/install-hooks.cjs"
|
||||
},
|
||||
"dependencies": {
|
||||
"@evenrealities/pretext": "^0.1.4",
|
||||
|
||||
@@ -5,3 +5,5 @@ else
|
||||
cp build_paths.sh.template build_paths.sh
|
||||
fi
|
||||
|
||||
# Restore the Kotlin prepare hook if a package install removed it.
|
||||
node "$(dirname "${BASH_SOURCE[0]}")/install-hooks.cjs"
|
||||
@@ -0,0 +1,8 @@
|
||||
const { buildKotlin, checkAndroidRuntime } = require('../../scripts/kotlin-build.cjs');
|
||||
|
||||
module.exports = function (hookArgs) {
|
||||
// NativeScript parses hooks with an older JavaScript parser; avoid optional chaining.
|
||||
const { platform, release } = hookArgs.prepareData;
|
||||
if (platform === 'android') checkAndroidRuntime();
|
||||
return buildKotlin(platform, release ? 'release' : 'debug');
|
||||
};
|
||||
@@ -0,0 +1,31 @@
|
||||
// NativeScript runs hooks/<event>/*.js, but that directory is also managed by
|
||||
// @nativescript/hook on package (re)installs and has been observed to lose our
|
||||
// custom hook. The tracked copy under scripts/hooks/ is the source of truth;
|
||||
// this restores it on `npm install` and before every build.
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const root = path.resolve(__dirname, '..');
|
||||
const hooks = [
|
||||
{ source: 'scripts/hooks/faceclaw-kotlin.before-prepare.js', target: 'hooks/before-prepare/faceclaw-kotlin.js' },
|
||||
];
|
||||
|
||||
function installHooks() {
|
||||
const restored = [];
|
||||
for (const { source, target } of hooks) {
|
||||
const from = path.join(root, source);
|
||||
const to = path.join(root, target);
|
||||
const content = fs.readFileSync(from);
|
||||
if (fs.existsSync(to) && fs.readFileSync(to).equals(content)) continue;
|
||||
fs.mkdirSync(path.dirname(to), { recursive: true });
|
||||
fs.writeFileSync(to, content);
|
||||
restored.push(target);
|
||||
}
|
||||
return restored;
|
||||
}
|
||||
|
||||
module.exports = { installHooks };
|
||||
if (require.main === module) {
|
||||
const restored = installHooks();
|
||||
if (restored.length) console.log(`[hooks] restored ${restored.join(', ')}`);
|
||||
}
|
||||
@@ -19,4 +19,5 @@ if command -v ruby >/dev/null 2>&1; then
|
||||
export PATH="$gem_bin:$PATH"
|
||||
fi
|
||||
|
||||
node scripts/install-hooks.cjs
|
||||
exec ns "$@"
|
||||
@@ -1,142 +0,0 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const p = require('../.test-build/app/g2/ble-protocol.js');
|
||||
const { StockConnection, OTA_WRITE, OTA_NOTIFY, decodeOtaAcks } = require('../.test-build/app/g2/stock-connection.js');
|
||||
const { firmwareCrc, validateFirmware, flashLensImage } = require('../.test-build/app/g2/firmware-ota.js');
|
||||
const { createFlashPrompt, flashPromptSelection } = require('../.test-build/app/g2/flash-prompt-protocol.js');
|
||||
const hex = bytes => Buffer.from(bytes).toString('hex');
|
||||
function fixture() {
|
||||
const sizes = [9000, 20, 20, 20, 20], image = new Uint8Array(0x40 + 5 * 16 + sizes.reduce((n, size) => n + size + 128, 0));
|
||||
const view = new DataView(image.buffer), u32 = (off, value) => view.setUint32(off, value, true);
|
||||
u32(8, 5); let offset = 0x40 + 5 * 16;
|
||||
sizes.forEach((size, index) => {
|
||||
u32(0x40 + index * 16 + 4, offset); u32(offset + 8, size);
|
||||
image.set(Buffer.from(index ? `ota/part${index}.bin` : 'ota/s200_firmware_ota.bin'), offset + 48);
|
||||
image.fill(index + 1, offset + 128, offset + 128 + size);
|
||||
if (!index) { u32(offset + 128, size); u32(offset + 128 + 0x14, 0x00438000); }
|
||||
const crc = firmwareCrc(image.subarray(offset + 128, offset + 128 + size));
|
||||
u32(offset + 12, crc); u32(0x40 + index * 16 + 12, crc); offset += size + 128;
|
||||
});
|
||||
return image;
|
||||
}
|
||||
class Transport {
|
||||
listeners = new Set(); writes = []; messages = []; chunks = []; seq = 0; held = false; respond = null; closed = [];
|
||||
onEvent(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn); }
|
||||
emit(event) { for (const fn of this.listeners) fn(event); }
|
||||
async resolveDevices() { return { left: 'L', right: 'R' }; }
|
||||
async connect() { return { characteristics: [p.G2_WRITE, p.G2_NOTIFY, OTA_WRITE, OTA_NOTIFY], maxWrite: 60 }; }
|
||||
async subscribe() {}
|
||||
stopScan() {}
|
||||
disconnect(id) { this.closed.push(id); this.emit({ kind: 'disconnected', identifier: id }); }
|
||||
notify(id, sid, payload, characteristic = p.G2_NOTIFY, flag = 0) {
|
||||
this.emit({ kind: 'notification', identifier: id, characteristic, data: hex(p.concat(...p.frameMessage(payload, sid, flag, 10))) });
|
||||
}
|
||||
async write(id, characteristic, bytes) {
|
||||
this.writes.push({ id, characteristic, bytes });
|
||||
if (bytes[5] === 1) this.chunks = [];
|
||||
this.chunks.push(bytes.subarray(8));
|
||||
if (bytes[5] !== bytes[4]) return;
|
||||
const all = p.concat(...this.chunks), payload = all.slice(0, -2);
|
||||
assert.equal(p.crc16(payload), all.at(-2) | all.at(-1) << 8);
|
||||
const message = { id, characteristic, sid: bytes[6], seq: bytes[2], payload };
|
||||
this.messages.push(message);
|
||||
if (this.respond) return this.respond(message);
|
||||
if (this.held) return;
|
||||
if (characteristic === OTA_WRITE) {
|
||||
if (message.sid === 0xc0 && payload[0] === 2) { this.seq = message.seq; return; }
|
||||
if (message.sid === 0xc1) assert.equal(message.seq, this.seq, 'marker/data sequence must match');
|
||||
this.notify(id, 0xc0, new Uint8Array([message.sid === 0xc1 ? 2 : payload[0], 0]), OTA_NOTIFY);
|
||||
} else {
|
||||
this.notify(id, message.sid, p.concat(p.integer(1, p.readInteger(payload, 1)), p.integer(2, p.readInteger(payload, 2)), p.bytes(3, new Uint8Array())));
|
||||
}
|
||||
}
|
||||
}
|
||||
async function connection(t, transport = new Transport()) {
|
||||
const link = new StockConnection(transport); t.after(() => link.close());
|
||||
await link.resolve({ left: 'a', right: 'b', ring: '' }); await link.connect('left', true);
|
||||
return { link, transport };
|
||||
}
|
||||
|
||||
test('OTA validator checks CRCs, bounds, overlap and the main-app preamble before transfer', () => {
|
||||
const image = fixture(), segments = validateFirmware(image);
|
||||
assert.equal(segments.length, 5);
|
||||
const corrupt = image.slice(); corrupt[segments[0].offset + 200] ^= 1;
|
||||
assert.throws(() => validateFirmware(corrupt), /CRC32C/);
|
||||
assert.throws(() => validateFirmware(image.slice(0, -1)), /truncated/);
|
||||
const bad = image.slice(), view = new DataView(bad.buffer);
|
||||
view.setUint32(0x44, 0xfffffff0, true); assert.throws(() => validateFirmware(bad), /bounds/);
|
||||
const overlap = image.slice(); new DataView(overlap.buffer).setUint32(0x54, segments[0].offset, true);
|
||||
assert.throws(() => validateFirmware(overlap), /overlap/);
|
||||
const wrongLoad = image.slice(), w = new DataView(wrongLoad.buffer), main = segments[0];
|
||||
w.setUint32(main.offset + 128 + 0x14, 0, true);
|
||||
const crc = firmwareCrc(wrongLoad.subarray(main.offset + 128, main.offset + 128 + main.size));
|
||||
w.setUint32(main.offset + 12, crc, true); w.setUint32(0x4c, crc, true);
|
||||
assert.throws(() => validateFirmware(wrongLoad), /preamble/);
|
||||
});
|
||||
|
||||
test('OTA framing streams every verified byte in 4KB blocks with shared marker/data sequences', async t => {
|
||||
const { link, transport } = await connection(t); await link.authenticate('left');
|
||||
const image = fixture(), segments = validateFirmware(image), progress = [];
|
||||
await flashLensImage(link, 'left', image, segments, value => progress.push(value), () => {}, async () => {});
|
||||
const controls = transport.messages.filter(m => m.sid === 0xc0);
|
||||
assert.equal(controls[0].payload[0], 0);
|
||||
assert.equal(controls.filter(m => m.payload[0] === 1).length, 5);
|
||||
assert.equal(controls.filter(m => m.payload[0] === 3).length, 5);
|
||||
const streamed = p.concat(...transport.messages.filter(m => m.sid === 0xc1).map(m => m.payload));
|
||||
assert.deepEqual(streamed, p.concat(...segments.map(s => image.slice(s.offset + 128, s.offset + 128 + s.size))));
|
||||
assert.equal(progress.at(-1).bytesSent, progress.at(-1).bytesTotal);
|
||||
assert.ok(transport.writes.every(w => w.bytes.length <= 60));
|
||||
});
|
||||
|
||||
test('OTA retries NAKed blocks and failed END verification, but never accepts a rejected FILE_CHECK', async () => {
|
||||
const image = fixture(), segments = validateFirmware(image); let blockAttempts = 0, endAttempts = 0, checks = 0;
|
||||
const fake = { check() {}, async exchange(_role, _sid, payload, _match, _timeout, _write, _notify, _flag, _seq, data) {
|
||||
const op = payload[0]; let status = 0;
|
||||
if (op === 1) checks++;
|
||||
if (op === 2 && ++blockAttempts === 1) status = 1;
|
||||
if (op === 3 && ++endAttempts === 1) status = 2;
|
||||
return { payload: new Uint8Array([op, status]) };
|
||||
} };
|
||||
await flashLensImage(fake, 'left', image, segments, () => {}, () => {}, async () => {});
|
||||
assert.equal(checks, 6); assert.equal(blockAttempts, 11);
|
||||
let dataWrites = 0;
|
||||
fake.exchange = async (_role, _sid, payload, ...args) => { if (args.at(-1)) dataWrites++; return { payload: new Uint8Array([payload[0], payload[0] === 1 ? 4 : 0]) }; };
|
||||
await assert.rejects(flashLensImage(fake, 'left', image, segments, () => {}, () => {}, async () => {}), /failed after 3 attempts/);
|
||||
assert.equal(dataWrites, 0);
|
||||
});
|
||||
|
||||
test('onboarding requests ignore wrong peers, magic and pre-encryption authentication failures', async t => {
|
||||
const { link, transport } = await connection(t); let resolved = false;
|
||||
transport.respond = message => {
|
||||
const magic = p.readInteger(message.payload, 2);
|
||||
const good = p.concat(p.integer(1, 4), p.integer(2, magic), p.bytes(3, new Uint8Array()));
|
||||
transport.notify('stranger', p.SID.auth, good);
|
||||
transport.notify('R', p.SID.auth, good);
|
||||
transport.notify('L', p.SID.auth, p.concat(p.integer(1, 4), p.integer(2, magic), p.bytes(3, p.integer(1, 1))));
|
||||
transport.notify('L', p.SID.auth, p.concat(p.integer(1, 4), p.integer(2, magic + 1), p.bytes(3, new Uint8Array())));
|
||||
setImmediate(() => { assert.equal(resolved, false); transport.notify('L', p.SID.auth, good); });
|
||||
};
|
||||
await link.authenticate('left'); resolved = true;
|
||||
});
|
||||
|
||||
test('OTA ACK parsing rejects bad CRC and truncation; cancellation rejects an outstanding transaction', async t => {
|
||||
const { link, transport } = await connection(t); transport.held = true;
|
||||
const payload = new Uint8Array([2, 0]), packet = p.frameMessage(payload, 0xc0, 0, 1)[0];
|
||||
assert.equal(decodeOtaAcks(packet)[0].payload[1], 0);
|
||||
assert.deepEqual(decodeOtaAcks(packet.slice(0, -1)), []);
|
||||
packet[8] ^= 1; assert.deepEqual(decodeOtaAcks(packet), []);
|
||||
const pending = link.exchange('left', 0xc0, new Uint8Array([0]), m => m.command === 0, 8000, OTA_WRITE, OTA_NOTIFY, 0);
|
||||
link.close(); await assert.rejects(pending, /Cancelled/);
|
||||
assert.equal(transport.listeners.size, 0);
|
||||
});
|
||||
|
||||
test('stock confirmation keeps No first and accepts only a confirmed flashmenu selection', () => {
|
||||
const page = createFlashPrompt(42, 'Warning'); const body = p.readBytes(page, 3);
|
||||
const list = p.readBytes(body, 2), label = p.readBytes(body, 3);
|
||||
assert.equal(p.readInteger(list, 3), 280); assert.equal(p.readInteger(label, 4), 130);
|
||||
assert.equal(p.readString(list, 10), 'flashmenu'); assert.equal(p.readString(label, 12), 'Warning');
|
||||
const event = (index, type = 0, name = 'flashmenu') => ({ sid: 0xe0, flag: 1,
|
||||
payload: p.bytes(13, p.bytes(1, p.concat(p.bytes(2, new Uint8Array(Buffer.from(name))), p.integer(4, index), p.integer(5, type)))) });
|
||||
assert.equal(flashPromptSelection(event(0)), false); assert.equal(flashPromptSelection(event(1)), true);
|
||||
assert.equal(flashPromptSelection(event(1, 1)), null); assert.equal(flashPromptSelection(event(1, 0, 'other')), null);
|
||||
});
|
||||
@@ -0,0 +1,314 @@
|
||||
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
|
||||
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertContentEquals
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertNull
|
||||
import kotlin.test.assertTrue
|
||||
import kotlinx.cinterop.ByteVar
|
||||
import kotlinx.cinterop.addressOf
|
||||
import kotlinx.cinterop.alloc
|
||||
import kotlinx.cinterop.allocPointerTo
|
||||
import kotlinx.cinterop.memScoped
|
||||
import kotlinx.cinterop.pointed
|
||||
import kotlinx.cinterop.ptr
|
||||
import kotlinx.cinterop.usePinned
|
||||
import kotlinx.cinterop.value
|
||||
import platform.Foundation.NSTemporaryDirectory
|
||||
import platform.posix.AI_NUMERICHOST
|
||||
import platform.posix.AI_NUMERICSERV
|
||||
import platform.posix.SOCK_STREAM
|
||||
import platform.posix.addrinfo
|
||||
import platform.posix.close
|
||||
import platform.posix.connect
|
||||
import platform.posix.freeaddrinfo
|
||||
import platform.posix.getaddrinfo
|
||||
import platform.posix.recv
|
||||
import platform.posix.send
|
||||
import platform.posix.socket
|
||||
|
||||
private var nextPort = 43000 + (currentTimeMillis() % 9000).toInt()
|
||||
|
||||
/** Binds the next free loopback port; returns the listener and its port. */
|
||||
private fun bindFreePort(): Pair<RemoteInputListener, Int> {
|
||||
repeat(50) {
|
||||
val port = nextPort++
|
||||
val listener = runCatching { IosLocalServerPort.bind("127.0.0.1", port) }.getOrNull() ?: return@repeat
|
||||
return listener to port
|
||||
}
|
||||
error("no free loopback port")
|
||||
}
|
||||
|
||||
/** Blocking POSIX client: connects to loopback, sends [request], reads until the peer closes. */
|
||||
private fun loopbackExchange(port: Int, request: ByteArray, readTimeoutMs: Int = 8000): ByteArray = memScoped {
|
||||
val hints = alloc<addrinfo>()
|
||||
hints.ai_flags = AI_NUMERICHOST or AI_NUMERICSERV
|
||||
hints.ai_socktype = SOCK_STREAM
|
||||
val resolved = allocPointerTo<addrinfo>()
|
||||
check(getaddrinfo("127.0.0.1", port.toString(), hints.ptr, resolved.ptr) == 0)
|
||||
val info = resolved.value!!.pointed
|
||||
val fd = socket(info.ai_family, SOCK_STREAM, 0)
|
||||
check(fd >= 0)
|
||||
try {
|
||||
check(connect(fd, info.ai_addr, info.ai_addrlen) == 0) { "connect failed" }
|
||||
request.usePinned { check(send(fd, it.addressOf(0), request.size.toULong(), 0) == request.size.toLong()) }
|
||||
val out = ByteSink()
|
||||
val buffer = ByteArray(4096)
|
||||
val deadline = IosProtocolPlatform.elapsedRealtimeMs() + readTimeoutMs
|
||||
while (IosProtocolPlatform.elapsedRealtimeMs() < deadline) {
|
||||
val n = buffer.usePinned { recv(fd, it.addressOf(0), buffer.size.toULong(), 0) }
|
||||
if (n <= 0L) break
|
||||
out.write(buffer, 0, n.toInt())
|
||||
if (out.toByteArray().last() == '\n'.code.toByte()) break
|
||||
}
|
||||
out.toByteArray()
|
||||
} finally {
|
||||
freeaddrinfo(resolved.value)
|
||||
close(fd)
|
||||
}
|
||||
}
|
||||
|
||||
/** Minimal loopback HTTP/1.1 server for the NSURLSession facades; one request per connection. */
|
||||
private class LoopbackHttpServer(private val handler: (path: String, headers: Map<String, String>) -> Reply) {
|
||||
class Reply(val status: Int, val headers: List<Pair<String, String>>, val pieces: List<ByteArray>, val pieceDelayMs: Long = 0)
|
||||
|
||||
private val listener: RemoteInputListener
|
||||
val port: Int
|
||||
val requests = ArrayList<Map<String, String>>()
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
|
||||
init {
|
||||
val bound = bindFreePort()
|
||||
listener = bound.first
|
||||
port = bound.second
|
||||
startThread("loopback-http", true) {
|
||||
while (!listener.isClosed) {
|
||||
val connection = listener.accept() ?: continue
|
||||
startThread("loopback-http-conn", true) { serve(connection) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun url(path: String) = "http://127.0.0.1:$port$path"
|
||||
|
||||
fun close() = listener.close()
|
||||
|
||||
fun requestsFor(path: String): List<Map<String, String>> = lock.withLock { requests.filter { it["path"] == path } }
|
||||
|
||||
private fun serve(connection: RemoteInputConnection) {
|
||||
try {
|
||||
val head = ByteSink()
|
||||
while (true) {
|
||||
val b = connection.readByte(5000)
|
||||
if (b < 0) return
|
||||
head.write(b)
|
||||
val bytes = head.toByteArray()
|
||||
val n = bytes.size
|
||||
if (n >= 4 && bytes[n - 4] == '\r'.code.toByte() && bytes[n - 3] == '\n'.code.toByte() &&
|
||||
bytes[n - 2] == '\r'.code.toByte() && bytes[n - 1] == '\n'.code.toByte()) break
|
||||
}
|
||||
val lines = head.toByteArray().decodeToString().split("\r\n").filter { it.isNotEmpty() }
|
||||
val path = lines.first().split(' ')[1]
|
||||
val headers = lines.drop(1).associate { it.substringBefore(':').trim().lowercase() to it.substringAfter(':').trim() }
|
||||
val bodyLength = headers["content-length"]?.toIntOrNull() ?: 0
|
||||
repeat(bodyLength) { connection.readByte(5000) }
|
||||
lock.withLock { requests.add(headers + ("path" to path)) }
|
||||
val reply = handler(path, headers)
|
||||
val total = reply.pieces.sumOf { it.size }
|
||||
val response = buildString {
|
||||
append("HTTP/1.1 ${reply.status} X\r\n")
|
||||
for ((name, value) in reply.headers) append("$name: $value\r\n")
|
||||
append("Content-Length: $total\r\nConnection: close\r\n\r\n")
|
||||
}
|
||||
connection.write(response.encodeToByteArray())
|
||||
for (piece in reply.pieces) {
|
||||
connection.write(piece)
|
||||
if (reply.pieceDelayMs > 0) sleepMs(reply.pieceDelayMs)
|
||||
}
|
||||
} catch (ignored: Exception) {
|
||||
} finally {
|
||||
connection.close()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun waitUntil(timeoutMs: Long, condition: () -> Boolean): Boolean {
|
||||
val deadline = IosProtocolPlatform.elapsedRealtimeMs() + timeoutMs
|
||||
while (IosProtocolPlatform.elapsedRealtimeMs() < deadline) {
|
||||
if (condition()) return true
|
||||
sleepMs(20)
|
||||
}
|
||||
return condition()
|
||||
}
|
||||
|
||||
private class RecordingSseListener : FaceclawSseListener {
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
val lines = ArrayList<String>()
|
||||
var httpError: Pair<Int, String>? = null
|
||||
var failure: String? = null
|
||||
var completed = false
|
||||
val finished: Boolean get() = lock.withLock { completed || httpError != null || failure != null }
|
||||
|
||||
override fun onLine(line: String?) { lock.withLock { lines.add(line ?: "") } }
|
||||
override fun onHttpError(code: Int, body: String?) { lock.withLock { httpError = code to (body ?: "") } }
|
||||
override fun onComplete() { lock.withLock { completed = true } }
|
||||
override fun onFailure(message: String?) { lock.withLock { failure = message ?: "" } }
|
||||
}
|
||||
|
||||
private class RecordingDownloadListener : FaceclawModelDownloaderListener {
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
var progress = 0
|
||||
var done: String? = null
|
||||
var error: String? = null
|
||||
val finished: Boolean get() = lock.withLock { done != null || error != null }
|
||||
|
||||
override fun onProgress(bytesDownloaded: Long, totalBytes: Long) { lock.withLock { progress++ } }
|
||||
override fun onDone(path: String?) { lock.withLock { done = path } }
|
||||
override fun onError(message: String?) { lock.withLock { error = message } }
|
||||
}
|
||||
|
||||
class IosNetworkingTest {
|
||||
private val immediate: (() -> Unit) -> Unit = { it() }
|
||||
|
||||
/** Like the main queue: never runs on the caller's thread, so the session's lock is not re-entered. */
|
||||
private val hop: (() -> Unit) -> Unit = { action -> startThread("test-dispatch", true, action) }
|
||||
|
||||
@Test
|
||||
fun remoteInputRoundTripsOverLoopbackAndTimesOut() {
|
||||
val (probe, port) = bindFreePort()
|
||||
probe.close()
|
||||
val remote = IosRemoteInput(hop, requestTimeoutMs = 1200)
|
||||
val ready = BlockingQueue<String>(IosProtocolPlatform)
|
||||
remote.setRequestListener { ready.put("ready") }
|
||||
assertEquals("Invalid local address.", remote.startAddress(port, "example.com"))
|
||||
assertEquals("Address is not assigned to a local interface.", remote.startAddress(port, "0.0.0.0"))
|
||||
assertEquals("", remote.startAddress(port, "127.0.0.1"))
|
||||
try {
|
||||
val replies = BlockingQueue<ByteArray>(IosProtocolPlatform)
|
||||
startThread("remote-client", true) { replies.put(loopbackExchange(port, "hello world\n".encodeToByteArray())) }
|
||||
assertEquals("ready", ready.poll(5000))
|
||||
val request = Json.parseObject(assertNotNull(remote.nextRequest()))
|
||||
assertEquals("hello world", request["body"].asString())
|
||||
assertNull(remote.nextRequest())
|
||||
remote.complete(request["id"].asLong()!!, "{\"ok\":true}")
|
||||
assertEquals("{\"ok\":true}\n", assertNotNull(replies.poll(5000)).decodeToString())
|
||||
|
||||
startThread("remote-client-2", true) { replies.put(loopbackExchange(port, "later\n".encodeToByteArray())) }
|
||||
assertEquals("ready", ready.poll(5000))
|
||||
assertNotNull(remote.nextRequest())
|
||||
assertEquals(RemoteInputSession.TIMEOUT_RESPONSE + "\n", assertNotNull(replies.poll(8000)).decodeToString())
|
||||
|
||||
assertEquals(64, remote.randomSecret().length)
|
||||
assertEquals(RemoteInputSession.tokenHash("abc"), remote.tokenDigest("abc"))
|
||||
val all = iosInterfaceAddresses()
|
||||
assertTrue(all.any { it.loopback && it.address == "127.0.0.1" }, all.toString())
|
||||
assertTrue(Json.parseArray(remote.interfaces()).none { it.asObject()!!["address"].asString() == "127.0.0.1" })
|
||||
assertTrue(IosLocalServerPort.isLocalUnicastAddress("::1"))
|
||||
assertFalse(IosLocalServerPort.isLocalUnicastAddress("224.0.0.1"))
|
||||
} finally {
|
||||
remote.stop()
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun sseStreamsLinesRefusesRedirectsAndReportsErrors() {
|
||||
val body = "event: a\r\ndata: one\n\ndata: two\r\n".encodeToByteArray()
|
||||
val server = LoopbackHttpServer { path, _ ->
|
||||
when (path) {
|
||||
"/sse" -> LoopbackHttpServer.Reply(200, listOf("Content-Type" to "text/event-stream"),
|
||||
listOf(body.copyOfRange(0, 13), body.copyOfRange(13, body.size)), pieceDelayMs = 50)
|
||||
"/limited" -> LoopbackHttpServer.Reply(429, listOf("Content-Type" to "text/plain"), listOf("slow down".encodeToByteArray()))
|
||||
else -> LoopbackHttpServer.Reply(302, listOf("Location" to "http://127.0.0.1:1/never"), listOf(ByteArray(0)))
|
||||
}
|
||||
}
|
||||
try {
|
||||
val ok = RecordingSseListener()
|
||||
IosSseRequest(server.url("/sse"), "{\"q\":1}", "{\"X-Test\":\"yes\"}", ok, immediate, false)
|
||||
assertTrue(waitUntil(10_000) { ok.finished }, "sse did not finish: ${ok.failure}")
|
||||
assertEquals(listOf("event: a", "data: one", "", "data: two"), ok.lines)
|
||||
assertTrue(ok.completed)
|
||||
val request = server.requestsFor("/sse").single()
|
||||
assertEquals("yes", request["x-test"])
|
||||
assertEquals("text/event-stream", request["accept"])
|
||||
assertTrue(request["user-agent"]!!.isNotEmpty())
|
||||
|
||||
val limited = RecordingSseListener()
|
||||
IosSseRequest(server.url("/limited"), "{}", null, limited, immediate, false)
|
||||
assertTrue(waitUntil(10_000) { limited.finished })
|
||||
assertEquals(429 to "slow down", limited.httpError)
|
||||
|
||||
val redirected = RecordingSseListener()
|
||||
IosSseRequest(server.url("/moved"), "{}", "{}", redirected, immediate, false)
|
||||
assertTrue(waitUntil(10_000) { redirected.finished })
|
||||
assertEquals(302, redirected.httpError?.first)
|
||||
assertTrue(server.requestsFor("/never").isEmpty())
|
||||
} finally {
|
||||
server.close()
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun downloaderFetchesAndResumesWithRange() {
|
||||
val payload = ByteArray(200_000) { (it * 31 + it / 977).toByte() }
|
||||
val sha = sha256Hex(payload)
|
||||
val server = LoopbackHttpServer { _, headers ->
|
||||
val range = headers["range"]
|
||||
if (range != null && range.startsWith("bytes=")) {
|
||||
val from = range.removePrefix("bytes=").removeSuffix("-").toInt()
|
||||
LoopbackHttpServer.Reply(206, listOf("Content-Range" to "bytes $from-${payload.size - 1}/${payload.size}"),
|
||||
listOf(payload.copyOfRange(from, payload.size)))
|
||||
} else LoopbackHttpServer.Reply(200, emptyList(), listOf(payload.copyOfRange(0, 70_000), payload.copyOfRange(70_000, payload.size)), pieceDelayMs = 30)
|
||||
}
|
||||
val dir = NSTemporaryDirectory().trimEnd('/') + "/faceclaw-dl-" + currentTimeMillis()
|
||||
val dest = "$dir/model.bin"
|
||||
try {
|
||||
val first = RecordingDownloadListener()
|
||||
IosModelDownloader(server.url("/model.bin"), dest, sha, payload.size.toLong(), first, immediate).start()
|
||||
assertTrue(waitUntil(20_000) { first.finished }, "download did not finish: ${first.error}")
|
||||
assertEquals(dest, first.done, first.error)
|
||||
assertContentEquals(payload, readFileData(dest))
|
||||
assertTrue(first.progress >= 1)
|
||||
assertNull(server.requestsFor("/model.bin").single()["range"])
|
||||
|
||||
deleteFile(dest)
|
||||
writeFileData("$dest.part", payload.copyOfRange(0, 50_000))
|
||||
val second = RecordingDownloadListener()
|
||||
IosModelDownloader(server.url("/model.bin"), dest, sha, payload.size.toLong(), second, immediate).start()
|
||||
assertTrue(waitUntil(20_000) { second.finished }, "resume did not finish: ${second.error}")
|
||||
assertEquals(dest, second.done, second.error)
|
||||
assertContentEquals(payload, readFileData(dest))
|
||||
assertEquals("bytes=50000-", server.requestsFor("/model.bin").last()["range"])
|
||||
assertEquals(-1L, fileLength("$dest.part"))
|
||||
} finally {
|
||||
server.close()
|
||||
deleteFile(dest)
|
||||
deleteFile("$dest.part")
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun frameTimingsExportsToAFile() {
|
||||
val dir = NSTemporaryDirectory().trimEnd('/') + "/faceclaw-ft-" + currentTimeMillis()
|
||||
platform.Foundation.NSFileManager.defaultManager.createDirectoryAtPath(dir, true, null, null)
|
||||
val timings = IosFrameTimings(IosProtocolPlatform)
|
||||
assertNull(timings.exportNow())
|
||||
timings.startExport(dir)
|
||||
val frame = timings.startFrame("test:frame")
|
||||
timings.spanStart(frame, "work")
|
||||
timings.log(frame, "hello")
|
||||
timings.spanEnd(frame, "work")
|
||||
timings.finishFrame(frame, "sent")
|
||||
val path = assertNotNull(timings.exportNow())
|
||||
assertEquals("$dir/${IosFrameTimings.EXPORT_FILE_NAME}", path)
|
||||
val text = readFileData(path).decodeToString()
|
||||
assertTrue(text.contains("test:frame"), text)
|
||||
assertTrue(text.contains("hello"), text)
|
||||
assertNull(timings.exportNow())
|
||||
assertTrue(timings.statsSummary().isNotEmpty())
|
||||
deleteFile(path)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
import kotlin.concurrent.Volatile
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
import platform.Foundation.NSDate
|
||||
import platform.Foundation.NSDefaultRunLoopMode
|
||||
import platform.Foundation.NSRunLoop
|
||||
import platform.Foundation.NSThread
|
||||
import platform.Foundation.dateWithTimeIntervalSinceNow
|
||||
import platform.Foundation.runMode
|
||||
|
||||
private const val RIGHT = "11111111-2222-3333-4444-555555555501"
|
||||
private const val LEFT = "11111111-2222-3333-4444-555555555502"
|
||||
|
||||
/** Pump the main run loop (which drains the main dispatch queue) until [condition] or timeout. */
|
||||
private fun pumpMainUntil(timeoutMs: Long, condition: () -> Boolean): Boolean {
|
||||
val deadline = IosProtocolPlatform.elapsedRealtimeMs() + timeoutMs
|
||||
while (IosProtocolPlatform.elapsedRealtimeMs() < deadline) {
|
||||
if (condition()) return true
|
||||
NSRunLoop.mainRunLoop.runMode(NSDefaultRunLoopMode, NSDate.dateWithTimeIntervalSinceNow(0.02))
|
||||
}
|
||||
return condition()
|
||||
}
|
||||
|
||||
/** A GATT link that acks EvenHub/settings/auth requests and CFW stream messages like the firmware. */
|
||||
private class FakeIosLink : SessionLink {
|
||||
lateinit var core: GlassesSessionCore
|
||||
private val lock = IosProtocolPlatform.createLock()
|
||||
val connected = HashSet<String>()
|
||||
val disconnected = ArrayList<String>()
|
||||
@Volatile var closed = false
|
||||
@Volatile var writes = 0
|
||||
private var seq = 0
|
||||
|
||||
override fun connect(address: String, timeoutMs: Int): Boolean {
|
||||
connected.add(address)
|
||||
return true
|
||||
}
|
||||
|
||||
override fun requestHighPriority(address: String) {}
|
||||
|
||||
override fun requestMtu(address: String, mtu: Int, timeoutMs: Int): Boolean = true
|
||||
|
||||
override fun negotiatedMtu(address: String): Int = 247
|
||||
|
||||
override fun discoverServices(address: String, timeoutMs: Int): Boolean = true
|
||||
|
||||
override fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean = true
|
||||
|
||||
override fun writeFrames(address: String, characteristicUuid: String, frames: List<ByteArray>, mode: GattWriteMode, timeoutMs: Int): Boolean {
|
||||
writes++
|
||||
val sid = frames[0][6].toInt() and 255
|
||||
val magic = if (sid == CfwTransport.SID) frames[0][2].toInt() and 255 else BleProtocol.parseFrame(frames[0]).msgSeq
|
||||
val inFlight = core.monitor.withLock { core.inFlightMessages.firstOrNull { it.sid == sid && it.magic == magic && magic != 0 } }
|
||||
if (inFlight != null) {
|
||||
if (sid == CfwTransport.SID) {
|
||||
for (lens in 1..2) core.onNotification(address, BleProtocol.NOTIFY_CHAR_UUID, cfwAck(magic, lens, inFlight.message.size, inFlight.cfwChecksum))
|
||||
} else {
|
||||
val joined = frames.flatMap { frame -> frame.slice(8 until 8 + (frame[3].toInt() and 255)) }.toByteArray()
|
||||
val pb = joined.copyOf(maxOf(0, joined.size - 2))
|
||||
core.onNotification(address, BleProtocol.NOTIFY_CHAR_UUID, ackFrame(sid, magic, pb))
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
private fun ackFrame(sid: Int, magic: Int, request: ByteArray): ByteArray {
|
||||
val body = if (sid == BleProtocol.SID_SECURITY_AUTH)
|
||||
BleProtocol.encodeVarintField(1, 4) + BleProtocol.encodeVarintField(2, magic) + byteArrayOf(0x1a, 0x00)
|
||||
else
|
||||
BleProtocol.encodeVarintField(1, 1) + BleProtocol.encodeVarintField(2, magic)
|
||||
return lock.withLock { BleProtocol.framePb(body, sid, 0x00, seq++)[0] }
|
||||
}
|
||||
|
||||
private fun cfwAck(streamId: Int, lens: Int, size: Int, checksum: Int): ByteArray {
|
||||
val packet = ByteArray(19)
|
||||
packet[0] = 0xaa.toByte()
|
||||
packet[1] = 0x12
|
||||
packet[3] = 11
|
||||
packet[4] = 1
|
||||
packet[5] = 1
|
||||
packet[6] = CfwTransport.SID.toByte()
|
||||
packet[8] = 1
|
||||
packet[9] = streamId.toByte()
|
||||
packet[12] = lens.toByte()
|
||||
packet[13] = size.toByte()
|
||||
packet[14] = (size ushr 8).toByte()
|
||||
packet[15] = checksum.toByte()
|
||||
packet[16] = (checksum ushr 8).toByte()
|
||||
val crc = CfwTransport.crc(packet.copyOfRange(8, 17))
|
||||
packet[17] = crc.toByte()
|
||||
packet[18] = (crc ushr 8).toByte()
|
||||
return packet
|
||||
}
|
||||
|
||||
override fun disconnect(address: String) {
|
||||
disconnected.add(address)
|
||||
connected.remove(address)
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
closed = true
|
||||
}
|
||||
|
||||
override fun isBonded(address: String): Boolean = true
|
||||
|
||||
override fun prepareBenchmarkLink(address: String, mode: Int) {}
|
||||
|
||||
override fun recordDisplayFrameSent() {}
|
||||
}
|
||||
|
||||
private class MainThreadListener : FaceclawBleCommunicatorListener {
|
||||
val phases = ArrayList<String>()
|
||||
var offMainCallbacks = 0
|
||||
|
||||
private fun record(phase: String) {
|
||||
if (!NSThread.isMainThread) offMainCallbacks++
|
||||
phases.add(phase)
|
||||
}
|
||||
|
||||
override fun onStateChange(phase: String?, status: String?) = record(phase ?: "")
|
||||
|
||||
override fun onRingEvent(kind: String?, containerName: String?, eventType: Int, eventSource: Int, systemExitReasonCode: Int, frameId: Int, ringTick: Long, ringType: Int, ringAux: Int, ringSpeed: Int) {}
|
||||
|
||||
override fun onBatteryState(headsetBattery: Int, headsetCharging: Int, ringBattery: Int, ringCharging: Int) {
|
||||
if (!NSThread.isMainThread) offMainCallbacks++
|
||||
}
|
||||
|
||||
override fun onSilentMode(silent: Boolean) {}
|
||||
|
||||
override fun onWearState(wearing: Boolean) {}
|
||||
|
||||
override fun onPhoneLockState(locked: Boolean) {}
|
||||
|
||||
override fun onEvenAppConflict(message: String?) {}
|
||||
|
||||
override fun onFrameMetrics(paintMs: Int, transmitMs: Int, tileCount: Int) {}
|
||||
|
||||
override fun onFrameFinished(frameId: Int, outcome: String?) {}
|
||||
|
||||
override fun onFirmwareInfo(leftVersion: String?, rightVersion: String?, extension: String?) {}
|
||||
}
|
||||
|
||||
class IosSessionFacadeTest {
|
||||
@Test
|
||||
fun facadeSessionConnectsOverAnInjectedLinkAndReportsOnTheMainQueue() {
|
||||
assertTrue(NSThread.isMainThread, "tests drive the main run loop")
|
||||
val link = FakeIosLink()
|
||||
val host = IosSessionHost(threadName = "test-session")
|
||||
val session = IosGlassesSession(link, null, host, RIGHT, LEFT, "", IosProtocolPlatform)
|
||||
link.core = session.coreForTests()
|
||||
val listener = MainThreadListener()
|
||||
session.setListener(listener)
|
||||
assertTrue(session.start())
|
||||
assertFalse(session.start(), "already running")
|
||||
assertTrue(pumpMainUntil(5_000) { listener.phases.contains("connected") }, "phases=${listener.phases}")
|
||||
assertTrue(session.isSessionReady())
|
||||
assertEquals(0, listener.offMainCallbacks, "listener callbacks must arrive on the main queue")
|
||||
assertTrue(pumpMainUntil(5_000) { link.writes > 3 }, "auth, prelude, settings and layout writes (saw ${link.writes})")
|
||||
session.disconnect()
|
||||
assertTrue(pumpMainUntil(2_000) { listener.phases.lastOrNull() == "disconnected" }, "phases=${listener.phases}")
|
||||
assertFalse(session.isSessionReady())
|
||||
assertTrue(link.closed)
|
||||
assertEquals(listOf(RIGHT, LEFT), link.disconnected.takeLast(2))
|
||||
assertEquals(0, listener.offMainCallbacks)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun relayFramesReachTheAncsListenerOnMainAndOtherFramesDoNot() {
|
||||
val link = FakeIosLink()
|
||||
val host = IosSessionHost(threadName = "test-session-ancs")
|
||||
val session = IosGlassesSession(link, null, host, RIGHT, LEFT, "", IosProtocolPlatform)
|
||||
val core = session.coreForTests()
|
||||
link.core = core
|
||||
val relayed = ArrayList<ByteArray>()
|
||||
var offMain = 0
|
||||
session.setAncsListener(object : IosAncsListener {
|
||||
override fun onAncsAuthorization(authorized: Boolean) {}
|
||||
|
||||
override fun onRelayFrame(data: platform.Foundation.NSData) {
|
||||
if (!NSThread.isMainThread) offMain++
|
||||
relayed.add(data.byteArray())
|
||||
}
|
||||
})
|
||||
val relay = byteArrayOf(65, 78, 1, 0, 9, 9, 9, 9, 0, 0, 0)
|
||||
core.onNotification(RIGHT, BleProtocol.NOTIFY_CHAR_UUID, relay)
|
||||
core.onNotification(LEFT, BleProtocol.NOTIFY_CHAR_UUID, relay) // wrong arm: ignored by the tap
|
||||
assertTrue(pumpMainUntil(2_000) { relayed.size == 1 })
|
||||
assertEquals(relay.toList(), relayed[0].toList())
|
||||
assertEquals(0, offMain)
|
||||
session.setAncsListener(null)
|
||||
core.onNotification(RIGHT, BleProtocol.NOTIFY_CHAR_UUID, relay)
|
||||
assertFalse(pumpMainUntil(200) { relayed.size > 1 })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun hostDispatchesToTheCallingQueueAndRunsTheWorker() {
|
||||
val host = IosSessionHost(threadName = "test-host")
|
||||
var onMain = false
|
||||
host.currentThreadDispatcher().post { onMain = NSThread.isMainThread }
|
||||
assertTrue(pumpMainUntil(1_000) { onMain })
|
||||
var workerThread = ""
|
||||
host.startWorker { workerThread = NSThread.currentThread.name ?: "" }
|
||||
host.joinWorker(2_000)
|
||||
assertEquals("test-host", workerThread)
|
||||
var posted = false
|
||||
host.postToMain { posted = NSThread.isMainThread }
|
||||
assertTrue(pumpMainUntil(1_000) { posted })
|
||||
assertFalse(host.isEvenAppActive())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun stockFlowFacadesConstructWithoutBluetooth() {
|
||||
// No CoreBluetooth on the simulator; construction and cancel/close must still be safe.
|
||||
val probe = IosDeviceInfoProbe(RIGHT, LEFT)
|
||||
probe.setListener(null)
|
||||
probe.close()
|
||||
val prompt = IosFlashPrompt(RIGHT, LEFT, "warn", true)
|
||||
prompt.close()
|
||||
val flasher = IosFirmwareFlasher(RIGHT, LEFT, "/nonexistent.bin")
|
||||
flasher.close()
|
||||
assertNotNull(IosFrameTimings.shared.core.buildExport())
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user