forked from Blendman974/faceclaw
Compare commits
44
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1d230a4014
|
||
|
|
cfa5a5a2bf
|
||
|
|
49099d5efe
|
||
|
|
eae11ffa9c
|
||
|
|
c705fc2222
|
||
|
|
772d5e0fe7
|
||
|
|
964aa88c54
|
||
|
|
3bba69ff56
|
||
|
|
5b3a4fa747
|
||
|
|
c7225752dd
|
||
|
|
3124ae852a
|
||
|
|
7ba73c7659
|
||
|
|
badebb0a17
|
||
|
|
da8d5c1960
|
||
|
|
30e436488f
|
||
|
|
c5b57e85b0
|
||
|
|
1441d1015c
|
||
|
|
44e4cd7300
|
||
|
|
b1b53d1f79
|
||
|
|
85a5a041f2
|
||
|
|
b9ff58271d
|
||
|
|
2b14ea38b4
|
||
|
|
a9b0644217
|
||
|
|
be939f401b
|
||
|
|
e0887f9968
|
||
|
|
9df5bd1598
|
||
|
|
ed3508ebfe
|
||
|
|
299bf470c3
|
||
|
|
5820c3c441
|
||
|
|
ec0be434ad
|
||
|
|
68c9dc7ae9
|
||
|
|
40cd9eb5ba
|
||
|
|
61c017a0b0
|
||
|
|
e915608b1a
|
||
|
|
e1e48ec038
|
||
|
|
66f4147e38
|
||
|
|
096510f5ad
|
||
|
|
0786657441
|
||
|
|
de318a7714
|
||
|
|
398c62af9a
|
||
|
|
6397928c60
|
||
|
|
1f12237dfe
|
||
|
|
62ae01a4f1
|
||
|
|
19cf564251
|
No files matched your search
@@ -0,0 +1,3 @@
|
||||
watch_file devenv.nix devenv.yaml devenv.lock
|
||||
eval "$(devenv direnvrc)"
|
||||
use devenv
|
||||
+5
-6
@@ -49,6 +49,11 @@ faceclaw_settings.xml
|
||||
faceclaw_settings*.json
|
||||
|
||||
# Developer configs
|
||||
.devenv*
|
||||
.direnv/
|
||||
.android/
|
||||
devenv.local.nix
|
||||
local.properties
|
||||
build_paths.sh
|
||||
**/xcuserdata/
|
||||
|
||||
@@ -70,9 +75,3 @@ tests/kotlin/build/
|
||||
|
||||
# tools/health-preview.cjs output (rendered PNGs, regenerate with the tool)
|
||||
preview/
|
||||
|
||||
# Apple Watch app: build output, and the settings build_apple_watch.sh writes from build_paths.sh
|
||||
apple-watch/build/
|
||||
apple-watch/Local.xcconfig
|
||||
App_Resources/iOS/watchapp/
|
||||
xcuserdata/
|
||||
@@ -162,6 +162,14 @@ tasks.register("prepareFaceclawNativeLibs") {
|
||||
def faceclawLlamaCppTag = "b10333"
|
||||
|
||||
def faceclawFindSdkCmakeDir = {
|
||||
// NixOS and other managed environments can provide patched host tools.
|
||||
def explicitCmake = System.getenv("ANDROID_CMAKE_HOME")
|
||||
if (explicitCmake != null) {
|
||||
def explicitDir = file(explicitCmake)
|
||||
if (faceclawHostExecutable(file("$explicitDir/bin"), "cmake").exists()
|
||||
&& faceclawHostExecutable(file("$explicitDir/bin"), "ninja").exists()) return explicitDir
|
||||
throw new GradleException("ANDROID_CMAKE_HOME must contain bin/cmake and bin/ninja: $explicitDir")
|
||||
}
|
||||
def sdkRoot = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
|
||||
if (sdkRoot == null) return null
|
||||
def cmakeRoot = file("$sdkRoot/cmake")
|
||||
|
||||
@@ -25,18 +25,21 @@ internal object AndroidSpeechEngines {
|
||||
private const val FEATURE_DIM = 80
|
||||
|
||||
/** Sherpa-onnx configuration for the on-device model files in [modelDir]. */
|
||||
fun recognizerConfig(modelDir: File, kind: VoiceModelKind): OfflineRecognizerConfig {
|
||||
fun recognizerConfig(
|
||||
modelDir: File, kind: VoiceModelKind,
|
||||
whisper: WhisperModelFiles = WhisperModelFiles.forLanguage(null),
|
||||
): OfflineRecognizerConfig {
|
||||
val modelConfig = OfflineModelConfig.builder()
|
||||
.setNumThreads(1)
|
||||
if (kind == VoiceModelKind.WHISPER) {
|
||||
modelConfig
|
||||
.setWhisper(OfflineWhisperModelConfig.builder()
|
||||
.setEncoder(File(modelDir, "base.en-encoder.int8.onnx").absolutePath)
|
||||
.setDecoder(File(modelDir, "base.en-decoder.int8.onnx").absolutePath)
|
||||
.setLanguage("en")
|
||||
.setEncoder(File(modelDir, whisper.encoder).absolutePath)
|
||||
.setDecoder(File(modelDir, whisper.decoder).absolutePath)
|
||||
.setLanguage(whisper.language)
|
||||
.setTask("transcribe")
|
||||
.build())
|
||||
.setTokens(File(modelDir, "base.en-tokens.txt").absolutePath)
|
||||
.setTokens(File(modelDir, whisper.tokens).absolutePath)
|
||||
} else {
|
||||
modelConfig
|
||||
.setMoonshine(OfflineMoonshineModelConfig.builder()
|
||||
|
||||
@@ -54,7 +54,8 @@ class FaceclawCalendarProvider private constructor() {
|
||||
* boundaries the provider stores them as.
|
||||
*/
|
||||
@JvmStatic
|
||||
fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long): String {
|
||||
@JvmOverloads
|
||||
fun getUpcomingEventsJson(context: Context?, maxEvents: Int, windowMs: Long, selectedCalendarIdsJson: String = "null"): String {
|
||||
if (context == null || maxEvents <= 0) {
|
||||
return "[]"
|
||||
}
|
||||
@@ -73,11 +74,21 @@ class FaceclawCalendarProvider private constructor() {
|
||||
val events = ArrayList<Event>()
|
||||
var cursor: Cursor? = null
|
||||
try {
|
||||
// Filter instances before the cutoff/limit so excluded calendars
|
||||
// cannot crowd out selected calendars, including recurrences.
|
||||
val ids = if (selectedCalendarIdsJson == "null") null else JSONArray(selectedCalendarIdsJson)
|
||||
if (ids != null && ids.length() == 0) return "[]"
|
||||
val args = ids?.let { values -> Array(values.length()) { index ->
|
||||
values.getString(index).also { require(it.matches(Regex("[0-9]+"))) }
|
||||
} }
|
||||
val selection = args?.let {
|
||||
CalendarContract.Instances.CALENDAR_ID + " IN (" + it.joinToString(",") { "?" } + ")"
|
||||
}
|
||||
cursor = context.contentResolver.query(
|
||||
uri,
|
||||
PROJECTION,
|
||||
null,
|
||||
null,
|
||||
selection,
|
||||
args,
|
||||
CalendarContract.Instances.BEGIN + " ASC")
|
||||
if (cursor != null) {
|
||||
val utc = Calendar.getInstance(TimeZone.getTimeZone("UTC"))
|
||||
@@ -118,6 +129,33 @@ class FaceclawCalendarProvider private constructor() {
|
||||
return out.toString()
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
fun getCalendarsJson(context: Context?): String {
|
||||
if (context == null) return "[]"
|
||||
val out = JSONArray()
|
||||
try {
|
||||
context.contentResolver.query(
|
||||
CalendarContract.Calendars.CONTENT_URI,
|
||||
arrayOf(CalendarContract.Calendars._ID, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,
|
||||
CalendarContract.Calendars.ACCOUNT_NAME, CalendarContract.Calendars.ACCOUNT_TYPE),
|
||||
null, null, CalendarContract.Calendars.CALENDAR_DISPLAY_NAME + " ASC",
|
||||
)?.use { cursor ->
|
||||
while (cursor.moveToNext()) {
|
||||
out.put(JSONObject().apply {
|
||||
put("id", cursor.getLong(0).toString())
|
||||
put("name", cursor.getString(1) ?: "")
|
||||
put("accountName", cursor.getString(2) ?: "")
|
||||
put("accountType", cursor.getString(3) ?: "")
|
||||
})
|
||||
}
|
||||
}
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "failed to read calendars", t)
|
||||
return "[]"
|
||||
}
|
||||
return out.toString()
|
||||
}
|
||||
|
||||
private fun readEvent(cursor: Cursor, utc: Calendar, local: Calendar): Event {
|
||||
val allDay = cursor.getInt(4) != 0
|
||||
var startMs = cursor.getLong(2)
|
||||
|
||||
+12
@@ -504,6 +504,18 @@ class FaceclawMediaNotificationListenerService : NotificationListenerService() {
|
||||
}
|
||||
}
|
||||
|
||||
@JvmStatic
|
||||
fun dismissAllNotifications(): Boolean {
|
||||
val service = activeService ?: return false
|
||||
return try {
|
||||
service.cancelAllNotifications()
|
||||
true
|
||||
} catch (t: Throwable) {
|
||||
Log.w(TAG, "failed to dismiss all notifications", t)
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
private fun emitNotificationPosted(key: String?) {
|
||||
emitNotificationEvent(key) { listener, eventKey -> listener.onNotificationPosted(eventKey) }
|
||||
}
|
||||
|
||||
@@ -32,17 +32,6 @@ class FaceclawVoiceController(context: Context) {
|
||||
"decoder_model_merged.ort",
|
||||
"tokens.txt"
|
||||
)
|
||||
// Second on-device model: sherpa-onnx's offline Whisper backend (base.en,
|
||||
// int8-quantized -- see the model-choice note in asr-model.ts). Directory
|
||||
// shared with the TS-side download flow, same convention as ASR_MODEL_DIR.
|
||||
// Whisper re-encodes the whole buffer on every call, so the shared session
|
||||
// skips live partials for it; see VoiceCaptureSession.processRecognizer.
|
||||
private const val ASR_WHISPER_MODEL_DIR = "sherpa-onnx-whisper-base-en-int8"
|
||||
private val ASR_WHISPER_MODEL_FILES = arrayOf(
|
||||
"base.en-encoder.int8.onnx",
|
||||
"base.en-decoder.int8.onnx",
|
||||
"base.en-tokens.txt"
|
||||
)
|
||||
// 50 ms chunks match the G2 packet cadence the rest of the pipeline
|
||||
// (endpointing, transcript pacing) is tuned for.
|
||||
private const val PHONE_MIC_CHUNK_SAMPLES = SAMPLE_RATE / 20
|
||||
@@ -84,6 +73,7 @@ class FaceclawVoiceController(context: Context) {
|
||||
private val mainHandler = Handler(Looper.getMainLooper())
|
||||
@Volatile
|
||||
private var communicator: FaceclawBleCommunicator? = null
|
||||
private var whisperModel = WhisperModelFiles.forLanguage(null)
|
||||
|
||||
private val host = object : VoiceCaptureHost {
|
||||
override val dispatcher = CallbackDispatcher { action -> mainHandler.post { action() } }
|
||||
@@ -122,7 +112,7 @@ class FaceclawVoiceController(context: Context) {
|
||||
|
||||
override fun loadTranscriber(kind: VoiceModelKind): OfflineTranscriber {
|
||||
val modelDir = findAsrModelDir(kind) ?: throw IllegalStateException("voice model missing")
|
||||
return AndroidSpeechEngines.SherpaTranscriber(AndroidSpeechEngines.recognizerConfig(modelDir, kind))
|
||||
return AndroidSpeechEngines.SherpaTranscriber(AndroidSpeechEngines.recognizerConfig(modelDir, kind, whisperModel))
|
||||
}
|
||||
|
||||
override fun speakerEmbedder(modelPath: String): SpeakerEmbedder {
|
||||
@@ -168,6 +158,11 @@ class FaceclawVoiceController(context: Context) {
|
||||
session.setOnboardModelKind(kind)
|
||||
}
|
||||
|
||||
/** Language for the next on-device Whisper capture; empty enables auto-detection. */
|
||||
fun setOnboardLanguage(language: String?) {
|
||||
whisperModel = WhisperModelFiles.forLanguage(language)
|
||||
}
|
||||
|
||||
/**
|
||||
* When true, watch the decoded PCM and fire {@code onSpeechEnd} once the
|
||||
* speaker stops. Used by hands-free ("Hey Even") capture, which has no
|
||||
@@ -263,8 +258,8 @@ class FaceclawVoiceController(context: Context) {
|
||||
*/
|
||||
private fun findAsrModelDir(kind: VoiceModelKind): File? {
|
||||
val whisper = kind == VoiceModelKind.WHISPER
|
||||
val dirName = if (whisper) ASR_WHISPER_MODEL_DIR else ASR_MODEL_DIR
|
||||
val fileNames = if (whisper) ASR_WHISPER_MODEL_FILES else ASR_MODEL_FILES
|
||||
val dirName = if (whisper) whisperModel.dirName else ASR_MODEL_DIR
|
||||
val fileNames = if (whisper) whisperModel.files else ASR_MODEL_FILES.toList()
|
||||
val modelDir = File(appContext.filesDir, ASR_ROOT + File.separator + dirName)
|
||||
for (fileName in fileNames) {
|
||||
val file = File(modelDir, fileName)
|
||||
|
||||
@@ -29,3 +29,8 @@ add_subdirectory(${LLAMA_CPP_SOURCE_DIR} llama.cpp-build EXCLUDE_FROM_ALL)
|
||||
|
||||
add_library(faceclaw_llama SHARED faceclaw_llama.cpp)
|
||||
target_link_libraries(faceclaw_llama PRIVATE llama android log)
|
||||
# NDK r27 defaults to 4 KiB. Align both LOAD segments and RELRO boundaries
|
||||
# for Android devices using 16 KiB pages, including debug APKs.
|
||||
target_link_options(faceclaw_llama PRIVATE
|
||||
"-Wl,-z,max-page-size=16384"
|
||||
"-Wl,-z,common-page-size=16384")
|
||||
@@ -57,26 +57,6 @@
|
||||
<string>Faceclaw connects to the terminal servers and developer app URLs you configure on your local network.</string>
|
||||
<key>UILaunchScreen</key>
|
||||
<dict/>
|
||||
<!-- Required: an app built with the iOS 27 SDK crashes at launch without the scene
|
||||
life cycle. @nativescript/core switches to it when it sees this key. Its side effect:
|
||||
the root page only loads once a scene connects, not on a background launch. -->
|
||||
<key>UIApplicationSceneManifest</key>
|
||||
<dict>
|
||||
<key>UIApplicationSupportsMultipleScenes</key>
|
||||
<false/>
|
||||
<key>UISceneConfigurations</key>
|
||||
<dict>
|
||||
<key>UIWindowSceneSessionRoleApplication</key>
|
||||
<array>
|
||||
<dict>
|
||||
<key>UISceneConfigurationName</key>
|
||||
<string>Default Configuration</string>
|
||||
<key>UISceneDelegateClassName</key>
|
||||
<string>SceneDelegate</string>
|
||||
</dict>
|
||||
</array>
|
||||
</dict>
|
||||
</dict>
|
||||
<key>UISupportedInterfaceOrientations</key>
|
||||
<array>
|
||||
<string>UIInterfaceOrientationPortrait</string>
|
||||
|
||||
@@ -5,7 +5,7 @@ CODE_SIGN_STYLE = Automatic;
|
||||
// Set IOS_TEAM_ID in build_paths.sh (or pass --teamId) to choose the signing team.
|
||||
// FoundationModels (the on-phone LLM, FaceclawSystemLanguageModel.swift) only exists on iOS 26+,
|
||||
// so it is weak-linked: the app still launches on older iOS and reports the model unavailable.
|
||||
OTHER_LDFLAGS = $(inherited) -framework CoreBluetooth -framework CoreLocation -framework CoreText -framework Speech -framework AVFoundation -framework WebKit -framework SafariServices -framework UniformTypeIdentifiers -framework ImageIO -framework EventKit -framework MediaPlayer -framework AuthenticationServices -framework Security -framework WatchConnectivity -weak_framework FoundationModels
|
||||
OTHER_LDFLAGS = $(inherited) -framework CoreBluetooth -framework CoreLocation -framework CoreText -framework Speech -framework AVFoundation -framework WebKit -framework SafariServices -framework UniformTypeIdentifiers -framework ImageIO -framework EventKit -framework MediaPlayer -framework AuthenticationServices -framework Security -weak_framework FoundationModels
|
||||
|
||||
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
|
||||
|
||||
|
||||
@@ -1,43 +0,0 @@
|
||||
#import <Foundation/Foundation.h>
|
||||
|
||||
NS_ASSUME_NONNULL_BEGIN
|
||||
|
||||
/**
|
||||
* Phone side of the Apple Watch remote: the single place that talks to
|
||||
* WatchConnectivity, so JS only ever sees path + JSON strings. The twin of the
|
||||
* Android FaceclawWearBridge; the messages are in wear/PROTOCOL.md.
|
||||
*
|
||||
* The session activates during launch, ahead of JS, because the watch can wake
|
||||
* this app in the background and messages arriving before a delegate exists
|
||||
* are lost. Until JS registers its handlers, messages are answered with
|
||||
* jsReady:NO so the watch can say "open Faceclaw on the phone".
|
||||
*
|
||||
* The public methods and both handlers belong to the main thread.
|
||||
*/
|
||||
@interface FaceclawWatchBridge : NSObject
|
||||
+ (instancetype)shared;
|
||||
/** WCSession works on this device (every iPhone; no iPad). */
|
||||
- (BOOL)isAvailable;
|
||||
/** A paired Apple Watch has the Faceclaw app. It needn't be running. */
|
||||
- (BOOL)isWatchAppAvailable;
|
||||
/**
|
||||
* Register JS. messageHandler gets every watch message; connectionHandler fires
|
||||
* when isWatchAppAvailable or the watch app's live reachability changes.
|
||||
*/
|
||||
- (void)setMessageHandler:(void (^)(NSString *path, NSString *json))messageHandler
|
||||
connectionHandler:(void (^)(void))connectionHandler;
|
||||
/**
|
||||
* Mirror the dashboard state: kept in the application context for the app's
|
||||
* next launch, and sent live too while it's in front. An unchanged state is
|
||||
* dropped unless `force`.
|
||||
*/
|
||||
- (void)publishState:(NSString *)json force:(BOOL)force;
|
||||
/** Send an event live. A sticky one also stays in the application context for a suspended app. */
|
||||
- (void)sendEvent:(NSString *)json sticky:(BOOL)sticky;
|
||||
/** A live message on any phone -> watch path; dropped if the watch app isn't in front. */
|
||||
- (void)sendToWatch:(NSString *)path json:(NSString *)json;
|
||||
/** Reply to a watch message; `seq` echoes the watch's sequence number. */
|
||||
- (void)sendAck:(double)seq ok:(BOOL)ok jsReady:(BOOL)jsReady message:(NSString *)message;
|
||||
@end
|
||||
|
||||
NS_ASSUME_NONNULL_END
|
||||
@@ -1,272 +0,0 @@
|
||||
#import "FaceclawWatchBridge.h"
|
||||
#import <UIKit/UIKit.h>
|
||||
#import <WatchConnectivity/WatchConnectivity.h>
|
||||
|
||||
// Live messages are {path, json, ...}; the watch app's Protocol.swift mirrors these keys.
|
||||
static NSString *const kKeyPath = @"path";
|
||||
static NSString *const kKeyJson = @"json";
|
||||
static NSString *const kKeyUpdatedAt = @"updatedAt";
|
||||
static NSString *const kKeyEvent = @"event";
|
||||
static NSString *const kKeyEventAt = @"eventAt";
|
||||
static NSString *const kKeyAt = @"at";
|
||||
static NSString *const kKeyBattery = @"battery";
|
||||
|
||||
static NSString *const kPathState = @"/faceclaw/state";
|
||||
static NSString *const kPathStateRequest = @"/faceclaw/state/request";
|
||||
static NSString *const kPathBattery = @"/faceclaw/battery";
|
||||
static NSString *const kPathPress = @"/faceclaw/press";
|
||||
static NSString *const kPathAck = @"/faceclaw/ack";
|
||||
static NSString *const kPathEvent = @"/faceclaw/event";
|
||||
|
||||
/** State requests kept for a JS handler that isn't registered yet. */
|
||||
static const NSUInteger kPendingLimit = 16;
|
||||
static const NSTimeInterval kPendingMaxAge = 30;
|
||||
|
||||
static long long NowMs(void) {
|
||||
return (long long)(NSDate.date.timeIntervalSince1970 * 1000);
|
||||
}
|
||||
|
||||
static double ReadSeq(NSString *json) {
|
||||
NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
|
||||
id parsed = data ? [NSJSONSerialization JSONObjectWithData:data options:0 error:nil] : nil;
|
||||
id seq = [parsed isKindOfClass:NSDictionary.class] ? parsed[@"seq"] : nil;
|
||||
return [seq isKindOfClass:NSNumber.class] ? [seq doubleValue] : 0;
|
||||
}
|
||||
|
||||
@interface FaceclawWatchPendingMessage : NSObject
|
||||
@property(nonatomic, copy) NSString *path;
|
||||
@property(nonatomic, copy) NSString *json;
|
||||
@property(nonatomic, strong) NSDate *receivedAt;
|
||||
@end
|
||||
@implementation FaceclawWatchPendingMessage
|
||||
@end
|
||||
|
||||
@interface FaceclawWatchBridge () <WCSessionDelegate>
|
||||
@property(nonatomic, copy, nullable) void (^messageHandler)(NSString *, NSString *);
|
||||
@property(nonatomic, copy, nullable) void (^connectionHandler)(void);
|
||||
@property(nonatomic, strong) NSMutableArray<FaceclawWatchPendingMessage *> *pending;
|
||||
@property(nonatomic, copy, nullable) NSString *lastState;
|
||||
@property(nonatomic) long long lastStateAt;
|
||||
@property(nonatomic, copy, nullable) NSString *heldEvent;
|
||||
@property(nonatomic) long long heldEventAt;
|
||||
/** Sends and context updates run here: they cost IPC, and the main thread also runs BLE. */
|
||||
@property(nonatomic, strong) dispatch_queue_t sendQueue;
|
||||
/** Latest context waiting for sendQueue; nil when none is queued. Guarded by @synchronized(self). */
|
||||
@property(nonatomic, copy, nullable) NSDictionary *queuedContext;
|
||||
@end
|
||||
|
||||
@implementation FaceclawWatchBridge
|
||||
|
||||
+ (void)load {
|
||||
// Registering here is what puts the delegate in place during launch, ahead of JS.
|
||||
[NSNotificationCenter.defaultCenter addObserverForName:UIApplicationDidFinishLaunchingNotification
|
||||
object:nil
|
||||
queue:NSOperationQueue.mainQueue
|
||||
usingBlock:^(NSNotification *note) {
|
||||
[[FaceclawWatchBridge shared] activate];
|
||||
}];
|
||||
}
|
||||
|
||||
+ (instancetype)shared {
|
||||
static FaceclawWatchBridge *instance;
|
||||
static dispatch_once_t once;
|
||||
dispatch_once(&once, ^{ instance = [FaceclawWatchBridge new]; });
|
||||
return instance;
|
||||
}
|
||||
|
||||
- (instancetype)init {
|
||||
if ((self = [super init])) {
|
||||
_pending = [NSMutableArray new];
|
||||
_sendQueue = dispatch_queue_create("com.faceclaw.watch.send", DISPATCH_QUEUE_SERIAL);
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
- (void)activate {
|
||||
if (!WCSession.isSupported) return;
|
||||
WCSession *session = WCSession.defaultSession;
|
||||
if (session.delegate == self) return;
|
||||
session.delegate = self;
|
||||
[session activateSession];
|
||||
}
|
||||
|
||||
#pragma mark - Public API (main thread)
|
||||
|
||||
- (BOOL)isAvailable {
|
||||
return WCSession.isSupported;
|
||||
}
|
||||
|
||||
- (BOOL)isWatchAppAvailable {
|
||||
if (!WCSession.isSupported) return NO;
|
||||
WCSession *session = WCSession.defaultSession;
|
||||
if (session.activationState != WCSessionActivationStateActivated) return NO;
|
||||
return session.isReachable || (session.isPaired && session.isWatchAppInstalled);
|
||||
}
|
||||
|
||||
- (void)setMessageHandler:(void (^)(NSString *, NSString *))messageHandler
|
||||
connectionHandler:(void (^)(void))connectionHandler {
|
||||
self.messageHandler = messageHandler;
|
||||
self.connectionHandler = connectionHandler;
|
||||
[self activate];
|
||||
NSArray<FaceclawWatchPendingMessage *> *replay = [self.pending copy];
|
||||
[self.pending removeAllObjects];
|
||||
for (FaceclawWatchPendingMessage *message in replay) {
|
||||
if (-message.receivedAt.timeIntervalSinceNow <= kPendingMaxAge) messageHandler(message.path, message.json);
|
||||
}
|
||||
// The watch's last battery report may have arrived while no one was listening.
|
||||
if (WCSession.isSupported && WCSession.defaultSession.activationState == WCSessionActivationStateActivated) {
|
||||
[self deliverBatteryFrom:WCSession.defaultSession.receivedApplicationContext];
|
||||
}
|
||||
}
|
||||
|
||||
- (void)publishState:(NSString *)json force:(BOOL)force {
|
||||
if (!force && [json isEqualToString:self.lastState]) return;
|
||||
self.lastState = json;
|
||||
self.lastStateAt = NowMs();
|
||||
[self pushContext];
|
||||
[self sendLive:@{kKeyPath: kPathState, kKeyJson: json, kKeyUpdatedAt: @(self.lastStateAt)}];
|
||||
}
|
||||
|
||||
- (void)sendEvent:(NSString *)json sticky:(BOOL)sticky {
|
||||
long long at = NowMs();
|
||||
if (sticky) {
|
||||
self.heldEvent = json;
|
||||
self.heldEventAt = at;
|
||||
[self pushContext];
|
||||
}
|
||||
[self sendLive:@{kKeyPath: kPathEvent, kKeyJson: json, kKeyAt: @(at)}];
|
||||
}
|
||||
|
||||
- (void)sendToWatch:(NSString *)path json:(NSString *)json {
|
||||
[self sendLive:@{kKeyPath: path, kKeyJson: json}];
|
||||
}
|
||||
|
||||
- (void)sendAck:(double)seq ok:(BOOL)ok jsReady:(BOOL)jsReady message:(NSString *)message {
|
||||
NSDictionary *ack = @{@"seq": @(seq), @"ok": @(ok), @"jsReady": @(jsReady), @"message": message ?: @""};
|
||||
NSData *data = [NSJSONSerialization dataWithJSONObject:ack options:0 error:nil];
|
||||
if (!data) return;
|
||||
[self sendToWatch:kPathAck json:[[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]];
|
||||
}
|
||||
|
||||
#pragma mark - Sending
|
||||
|
||||
- (void)sendLive:(NSDictionary *)message {
|
||||
if (!WCSession.isSupported) return;
|
||||
dispatch_async(self.sendQueue, ^{
|
||||
WCSession *session = WCSession.defaultSession;
|
||||
if (session.activationState != WCSessionActivationStateActivated || !session.isReachable) return;
|
||||
[session sendMessage:message replyHandler:nil errorHandler:^(NSError *error) {
|
||||
NSLog(@"[FaceclawWatch] send %@ failed: %@", message[kKeyPath], error);
|
||||
}];
|
||||
});
|
||||
}
|
||||
|
||||
/** Queue the current state and held event as the application context; only the latest matters. */
|
||||
- (void)pushContext {
|
||||
if (!WCSession.isSupported) return;
|
||||
NSMutableDictionary *context = [NSMutableDictionary new];
|
||||
if (self.lastState) {
|
||||
context[kKeyJson] = self.lastState;
|
||||
context[kKeyUpdatedAt] = @(self.lastStateAt);
|
||||
}
|
||||
if (self.heldEvent) {
|
||||
context[kKeyEvent] = self.heldEvent;
|
||||
context[kKeyEventAt] = @(self.heldEventAt);
|
||||
}
|
||||
BOOL alreadyQueued;
|
||||
@synchronized (self) {
|
||||
alreadyQueued = self.queuedContext != nil;
|
||||
self.queuedContext = context;
|
||||
}
|
||||
if (alreadyQueued) return;
|
||||
dispatch_async(self.sendQueue, ^{
|
||||
NSDictionary *next;
|
||||
@synchronized (self) {
|
||||
next = self.queuedContext;
|
||||
self.queuedContext = nil;
|
||||
}
|
||||
WCSession *session = WCSession.defaultSession;
|
||||
if (!next || session.activationState != WCSessionActivationStateActivated) return;
|
||||
if (!session.isPaired || !session.isWatchAppInstalled) return;
|
||||
NSError *error = nil;
|
||||
if (![session updateApplicationContext:next error:&error]) {
|
||||
NSLog(@"[FaceclawWatch] application context update failed: %@", error);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
#pragma mark - Receiving
|
||||
|
||||
- (void)handleMessage:(NSString *)path json:(NSString *)json {
|
||||
if (self.messageHandler) {
|
||||
self.messageHandler(path, json);
|
||||
return;
|
||||
}
|
||||
// A battery report is status and a touch-down only matters live; neither expects an ack.
|
||||
if ([path isEqualToString:kPathBattery] || [path isEqualToString:kPathPress]) return;
|
||||
// Gestures and commands are refused rather than replayed: the watch reports them as failed,
|
||||
// and running them later would act on whatever the glasses happen to show by then.
|
||||
if ([path isEqualToString:kPathStateRequest]) {
|
||||
NSDate *now = NSDate.date;
|
||||
while (self.pending.count > 0 && [now timeIntervalSinceDate:self.pending.firstObject.receivedAt] > kPendingMaxAge) {
|
||||
[self.pending removeObjectAtIndex:0];
|
||||
}
|
||||
if (self.pending.count >= kPendingLimit) [self.pending removeObjectAtIndex:0];
|
||||
FaceclawWatchPendingMessage *message = [FaceclawWatchPendingMessage new];
|
||||
message.path = path;
|
||||
message.json = json;
|
||||
message.receivedAt = now;
|
||||
[self.pending addObject:message];
|
||||
}
|
||||
[self sendAck:ReadSeq(json) ok:NO jsReady:NO message:@"Faceclaw is not running on the phone. Open it to connect the glasses."];
|
||||
}
|
||||
|
||||
/** The watch leaves its battery in the application context while it can't message us live. */
|
||||
- (void)deliverBatteryFrom:(NSDictionary<NSString *, id> *)context {
|
||||
id json = context[kKeyBattery];
|
||||
if ([json isKindOfClass:NSString.class] && self.messageHandler) self.messageHandler(kPathBattery, json);
|
||||
}
|
||||
|
||||
- (void)notifyConnection {
|
||||
if (self.connectionHandler) self.connectionHandler();
|
||||
}
|
||||
|
||||
#pragma mark - WCSessionDelegate (any thread)
|
||||
|
||||
- (void)session:(WCSession *)session activationDidCompleteWithState:(WCSessionActivationState)state error:(NSError *)error {
|
||||
if (error) NSLog(@"[FaceclawWatch] activation failed: %@", error);
|
||||
dispatch_async(dispatch_get_main_queue(), ^{
|
||||
// Anything published before activation couldn't be delivered.
|
||||
if (self.lastState || self.heldEvent) [self pushContext];
|
||||
[self deliverBatteryFrom:session.receivedApplicationContext];
|
||||
[self notifyConnection];
|
||||
});
|
||||
}
|
||||
|
||||
- (void)sessionDidBecomeInactive:(WCSession *)session {}
|
||||
|
||||
- (void)sessionDidDeactivate:(WCSession *)session {
|
||||
// The user switched watches: the session must be reactivated for the new one.
|
||||
[session activateSession];
|
||||
}
|
||||
|
||||
- (void)sessionWatchStateDidChange:(WCSession *)session {
|
||||
dispatch_async(dispatch_get_main_queue(), ^{ [self notifyConnection]; });
|
||||
}
|
||||
|
||||
- (void)sessionReachabilityDidChange:(WCSession *)session {
|
||||
dispatch_async(dispatch_get_main_queue(), ^{ [self notifyConnection]; });
|
||||
}
|
||||
|
||||
- (void)session:(WCSession *)session didReceiveMessage:(NSDictionary<NSString *, id> *)message {
|
||||
id path = message[kKeyPath], json = message[kKeyJson];
|
||||
if (![path isKindOfClass:NSString.class]) return;
|
||||
NSString *body = [json isKindOfClass:NSString.class] ? json : @"{}";
|
||||
dispatch_async(dispatch_get_main_queue(), ^{ [self handleMessage:path json:body]; });
|
||||
}
|
||||
|
||||
- (void)session:(WCSession *)session didReceiveApplicationContext:(NSDictionary<NSString *, id> *)context {
|
||||
dispatch_async(dispatch_get_main_queue(), ^{ [self deliverBatteryFrom:context]; });
|
||||
}
|
||||
|
||||
@end
|
||||
@@ -14,6 +14,5 @@ module FaceclawGraphics {
|
||||
header "FaceclawLoopbackRedirect.h"
|
||||
header "FaceclawWebSignIn.h"
|
||||
header "FaceclawResourceUsage.h"
|
||||
header "FaceclawWatchBridge.h"
|
||||
export *
|
||||
}
|
||||
@@ -13,14 +13,7 @@ remote that drives Faceclaw over the Wearable Data Layer. Its phone-side
|
||||
counterparts are FaceclawWearBridge.kt, app/native/wear-bridge.ts and
|
||||
app/g2/wear-remote.ts; the message format is in wear/PROTOCOL.md.
|
||||
|
||||
apple-watch/ is the same remote for Apple Watch (Swift + SwiftUI), driving the iOS
|
||||
app over WatchConnectivity. Its phone-side counterparts are
|
||||
App_Resources/iOS/src/FaceclawWatchBridge.m, app/native/wear-bridge.ios.ts and the
|
||||
same app/g2/wear-remote.ts. It only links to a phone app that embeds it
|
||||
(FACECLAW_EMBED_WATCH=1); see apple-watch/README.md.
|
||||
|
||||
`build.sh`, `build_wear.sh` and `build_apple_watch.sh` build the Android, Wear OS
|
||||
and Apple Watch apps respectively.
|
||||
`build.sh` and `build_wear.sh` build the Android and Wear OS apps respectively.
|
||||
`build_and_run.sh` builds the Android app then also installs it on a phone
|
||||
paired with `adb`. Building may require configuring environment variables
|
||||
(JAVA_HOME, ANDROID_HOME, PATH, ANDROID_KEYSTORE, ANDROID_KEYSTORE) to point at
|
||||
|
||||
@@ -163,9 +163,6 @@ section has the phone-side switches. See [wear/README.md](wear/README.md) for
|
||||
building and installing it; it is a separate Gradle build, sideloaded over
|
||||
adb, and needs no Play Store. The phone side requires Google Play services.
|
||||
|
||||
The iOS app has the same remote for Apple Watch, with the same pad and screens;
|
||||
see [apple-watch/README.md](apple-watch/README.md).
|
||||
|
||||
## Connecting an external agent (OpenClaw)
|
||||
|
||||
Instead of calling an LLM API directly from the phone, the voice assistant
|
||||
|
||||
@@ -3,6 +3,7 @@ import { invalidateCalendarCache, onCalendarChanged } from "../../native/calenda
|
||||
import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer";
|
||||
import { CalendarLayer } from "./calendar";
|
||||
import { renderCalendarDateIcon } from "./calendar-icon";
|
||||
import { calendarSelectionMenuItems } from "./calendar-filter";
|
||||
import {
|
||||
createInProcessWindow,
|
||||
YieldAtRootLayer,
|
||||
@@ -44,6 +45,10 @@ export function createCalendarAppWindow(options: InProcessAppOptions): InProcess
|
||||
icon: "calendar",
|
||||
drawIcon: makeImageWindowIcon(renderCalendarDateIcon, windowIcon("calendar", "Ca")),
|
||||
closeable: true,
|
||||
menuItems: () => calendarSelectionMenuItems().map(item => ({ ...item, onSelect: (ctx, menu) => {
|
||||
ctx.stack.pop();
|
||||
return item.onSelect(ctx, menu);
|
||||
} })),
|
||||
actions: options.actions,
|
||||
baseLayer: new YieldAtRootLayer(new CalendarLayer(requestPermission)),
|
||||
submitFrame: options.submitFrame,
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
import { getDefaultSmallFont } from "../../graphics/ui-fonts";
|
||||
import { type GrayImage } from "../../graphics/image";
|
||||
import { truncateText } from "../../graphics/textwrap";
|
||||
import { readCalendarSelection, setCalendarSelection } from "../../native/calendar-selection";
|
||||
import { readAvailableCalendars } from "../../native/calendar-sources";
|
||||
import { hasCalendarPermission } from "../../native/calendar-permissions";
|
||||
import { type InputEvent } from "../../ui/gestures";
|
||||
import { type Layer, type LayerContext, type PaintBelow } from "../../ui/layers";
|
||||
import { drawToggleMenuItem, MenuLayer, type MenuItem } from "../../ui/menu";
|
||||
|
||||
/** Shared preference for every Android calendar reader. */
|
||||
export class CalendarFilterLayer implements Layer {
|
||||
private menu: MenuLayer | null = null;
|
||||
private width = 0;
|
||||
private keys: string[] = [];
|
||||
|
||||
private currentMenu(ctx: LayerContext): MenuLayer {
|
||||
const calendars = readAvailableCalendars().sort((a, b) =>
|
||||
a.name.localeCompare(b.name) || a.accountName.localeCompare(b.accountName) || a.id.localeCompare(b.id));
|
||||
const selection = readCalendarSelection();
|
||||
const known = new Set(calendars.map(calendar => calendar.id));
|
||||
const keys = ["all", "none"];
|
||||
const toggle = (id: string) => {
|
||||
// Leaving all mode snapshots the current calendars. Newly added calendars
|
||||
// then stay excluded until selected individually or all mode is restored.
|
||||
const ids = new Set(readCalendarSelection() ?? calendars.map(calendar => calendar.id));
|
||||
if (ids.has(id)) ids.delete(id); else ids.add(id);
|
||||
setCalendarSelection(Array.from(ids));
|
||||
};
|
||||
const items: MenuItem[] = [{
|
||||
label: "All calendars",
|
||||
description: "Include all calendars, including calendars added later.",
|
||||
onSelect: () => setCalendarSelection(null),
|
||||
render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width,
|
||||
"All calendars", readCalendarSelection() === null, selected),
|
||||
}, {
|
||||
label: "No calendars",
|
||||
onSelect: () => setCalendarSelection([]),
|
||||
render: ({ image, x, y, width, selected }) => drawToggleMenuItem(image, getDefaultSmallFont(), x, y, width,
|
||||
"No calendars", readCalendarSelection()?.length === 0, selected),
|
||||
}];
|
||||
const rows = [
|
||||
...calendars.map(calendar => ({ id: calendar.id,
|
||||
label: `${calendar.name || "(unnamed)"} / ${calendar.accountName || "Local"} (${calendar.accountType || "local"}) #${calendar.id}` })),
|
||||
...(selection ?? []).filter(id => !known.has(id)).map(id => ({ id, label: `Unavailable calendar #${id}` })),
|
||||
];
|
||||
for (const row of rows) {
|
||||
keys.push(`calendar:${row.id}`);
|
||||
items.push({
|
||||
label: row.label,
|
||||
description: row.label,
|
||||
onSelect: () => toggle(row.id),
|
||||
render: ({ image, x, y, width, selected }) => {
|
||||
const font = getDefaultSmallFont();
|
||||
const ids = readCalendarSelection();
|
||||
drawToggleMenuItem(image, font, x, y, width, truncateText(font, row.label, width - 48),
|
||||
ids === null || ids.includes(row.id), selected);
|
||||
},
|
||||
});
|
||||
}
|
||||
if (!calendars.length) items.push({
|
||||
label: hasCalendarPermission() ? "No calendars available" : "Grant calendar permission on your phone",
|
||||
disabled: true, onSelect: () => {},
|
||||
});
|
||||
const key = this.menu?.selectedIndex != null ? this.keys[this.menu.selectedIndex] : "all";
|
||||
const index = Math.max(0, keys.indexOf(key ?? "all"));
|
||||
this.keys = keys;
|
||||
const width = ctx.stack.getBaseSize().width;
|
||||
if (!this.menu || this.width !== width) {
|
||||
this.width = width;
|
||||
this.menu = new MenuLayer("Calendars displayed", items, {
|
||||
x: 8, y: 8, width: width - 16, opaque: true, showBorder: false,
|
||||
footer: "Shared by Calendar and Glanceboard",
|
||||
}).selectItem(index);
|
||||
} else this.menu.setItems(items, index);
|
||||
return this.menu;
|
||||
}
|
||||
|
||||
paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage {
|
||||
return this.currentMenu(ctx).paint(ctx, paintBelow);
|
||||
}
|
||||
|
||||
async handleInput(event: InputEvent, ctx: LayerContext): Promise<void> {
|
||||
await this.currentMenu(ctx).handleInput(event, ctx);
|
||||
}
|
||||
}
|
||||
|
||||
export function calendarSelectionMenuItems(): MenuItem[] {
|
||||
return global.isAndroid ? [{
|
||||
label: "Calendars displayed",
|
||||
description: "Choose the calendars used by Calendar, Glanceboard and other calendar views.",
|
||||
onSelect: ctx => ctx.stack.push(new CalendarFilterLayer()),
|
||||
}] : [];
|
||||
}
|
||||
@@ -4,7 +4,7 @@
|
||||
* makes the content area exactly the 576x288 surface EvenHub apps expect.
|
||||
*/
|
||||
import { GrayImage } from "../../graphics/image";
|
||||
import { EVENHUB_SCREEN_WIDTH } from "./compositor";
|
||||
import { EVENHUB_SCREEN_WIDTH, EVENHUB_SCREEN_HEIGHT } from "./compositor";
|
||||
import { directionalFallback, isDirectionalInput, type InputEvent } from "../../ui/gestures";
|
||||
import { type Layer, type LayerContext } from "../../ui/layers";
|
||||
import {
|
||||
@@ -24,21 +24,26 @@ class EvenHubAppLayer implements Layer {
|
||||
* extension's source field should see that they came from the watch.
|
||||
*/
|
||||
readonly acceptsDirectional = true;
|
||||
private tallCanvas = false;
|
||||
|
||||
constructor(private readonly session: EvenHubSession) {}
|
||||
|
||||
setTallCanvas(tall: boolean): void {
|
||||
this.tallCanvas = tall;
|
||||
}
|
||||
|
||||
paint(ctx: LayerContext): GrayImage {
|
||||
const size = ctx.stack.getBaseSize();
|
||||
// EvenHub apps lay out for the stock 576-wide surface. In the Full
|
||||
// Screen display mode the window is 640 wide; paint at stock width and
|
||||
// centre it rather than leaving all the slack on the right.
|
||||
if (size.width > EVENHUB_SCREEN_WIDTH) {
|
||||
const content = this.session.paint({ width: EVENHUB_SCREEN_WIDTH, height: size.height }, ctx.stack.isFocused());
|
||||
const image = new GrayImage(size.width, size.height, 0);
|
||||
content.composeInto(image, Math.floor((size.width - EVENHUB_SCREEN_WIDTH) / 2), 0);
|
||||
return image;
|
||||
}
|
||||
return this.session.paint(size, ctx.stack.isFocused());
|
||||
// Host full screen hides chrome; it does not enlarge the stock app canvas.
|
||||
// Only the app's explicit Faceclaw extended-layout request opts into height.
|
||||
const canvas = { width: EVENHUB_SCREEN_WIDTH, height: this.tallCanvas ? size.height : EVENHUB_SCREEN_HEIGHT };
|
||||
const content = this.session.paint(canvas, ctx.stack.isFocused());
|
||||
if (size.width === canvas.width && size.height === canvas.height) return content;
|
||||
const image = new GrayImage(size.width, size.height, 0);
|
||||
// Clip text to its logical canvas before placing it in the larger host window.
|
||||
image.bitBlt(content.withDrawsBaked(), Math.max(0, Math.floor((size.width - canvas.width) / 2)),
|
||||
Math.max(0, Math.floor((size.height - canvas.height) / 2)));
|
||||
return image;
|
||||
}
|
||||
|
||||
handleInput(event: InputEvent): void {
|
||||
@@ -60,6 +65,7 @@ export function createEvenHubWindow(
|
||||
requestShellRender: () => void,
|
||||
): InProcessWindow {
|
||||
const fallbackIcon = windowIcon("package", session.manifest.name.charAt(0).toUpperCase() || "E");
|
||||
const appLayer = new EvenHubAppLayer(session);
|
||||
const created = createInProcessWindow({
|
||||
appId,
|
||||
windowId,
|
||||
@@ -91,7 +97,7 @@ export function createEvenHubWindow(
|
||||
{ label: "Show phone UI", onSelect: (ctx: LayerContext) => { ctx.stack.pop(); onShowPhone(); } },
|
||||
],
|
||||
actions: options.actions,
|
||||
baseLayer: new EvenHubAppLayer(session),
|
||||
baseLayer: appLayer,
|
||||
submitFrame: options.submitFrame,
|
||||
setSurfaceVisible: options.setSurfaceVisible,
|
||||
removeSurface: options.removeSurface,
|
||||
@@ -109,7 +115,10 @@ export function createEvenHubWindow(
|
||||
pushOverlay: (layer) => created.stack.push(layer),
|
||||
// The extended layout uses the full 576x452 app area ("max"); stock apps
|
||||
// stay in the 576x288 band ("medium").
|
||||
setTallCanvas: (tall) => created.setHeightMode(tall ? "max" : "medium"),
|
||||
setTallCanvas: (tall) => {
|
||||
appLayer.setTallCanvas(tall);
|
||||
created.setHeightMode(tall ? "max" : "medium");
|
||||
},
|
||||
setAttention: (attention) => shell.setWindowAttention(windowId, attention),
|
||||
// Only while the app listens for text: otherwise the shell's Type Into App
|
||||
// destinations (voice dialog, phone keyboard, watch) would send into a void.
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { type GlanceWidgetDefinition, type GlanceWidgetId } from "../widget";
|
||||
import { CalendarWidget } from "./calendar-widget";
|
||||
import { calendarSelectionMenuItems } from "../../calendar/calendar-filter";
|
||||
import { CompassWidget } from "./compass-widget";
|
||||
import { MusicWidget, musicSettingsMenuItems } from "./music-widget";
|
||||
import { NightscoutWidget } from "./nightscout-widget";
|
||||
@@ -11,7 +12,7 @@ import { HealthWidget } from "./health-widget";
|
||||
/** Every widget a board slot can hold. */
|
||||
export const GLANCE_WIDGETS: readonly GlanceWidgetDefinition[] = [
|
||||
{ id: "system-card", label: "System card", settingsMenuItems: systemCardSettingsMenuItems, create: () => new SystemCardWidget() },
|
||||
{ id: "calendar", label: "Calendar", tall: true, create: () => new CalendarWidget() },
|
||||
{ id: "calendar", label: "Calendar", tall: true, settingsMenuItems: calendarSelectionMenuItems, create: () => new CalendarWidget() },
|
||||
{ id: "terminal", label: "Terminal", tall: true, create: () => new TerminalWidget() },
|
||||
{ id: "t3code", label: "T3 Code", tall: true, create: () => new T3CodeWidget() },
|
||||
{ id: "nightscout", label: "Nightscout", create: () => new NightscoutWidget() },
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { NotificationsListLayer } from "../../ui/notifications";
|
||||
import { NotificationFilterLayer } from "../../ui/notification-filter";
|
||||
import { onAndroidNotificationsChanged } from "../../native/notification-icons";
|
||||
import { ALL_NOTIFICATIONS, dismissAllNotifications, onAndroidNotificationsChanged, readActiveNotifications } from "../../native/notification-icons";
|
||||
import {
|
||||
createInProcessWindow,
|
||||
YieldAtRootLayer,
|
||||
@@ -32,6 +32,15 @@ export function createNotificationsAppWindow(options: InProcessAppOptions): InPr
|
||||
ctx.stack.pop();
|
||||
ctx.stack.push(new NotificationFilterLayer());
|
||||
},
|
||||
}, {
|
||||
label: "Dismiss all notifications",
|
||||
description: "Dismiss notifications on the phone and glasses. System-protected notifications may remain.",
|
||||
disabled: () => readActiveNotifications(ALL_NOTIFICATIONS).length === 0,
|
||||
onSelect: (ctx) => {
|
||||
ctx.stack.pop();
|
||||
dismissAllNotifications();
|
||||
created.requestRender();
|
||||
},
|
||||
}],
|
||||
actions: options.actions,
|
||||
baseLayer: new YieldAtRootLayer(new NotificationsListLayer()),
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { startRemoteInput } from "../remote/service";
|
||||
import { getHeadUpPreferences,appSwitcherPositionSetting,statusBarPositionSetting,statusBarVisibilitySetting,windowBorderSetting,assistantAllowProactiveSetting,assistantBackendSetting,assistantBridgeHostSetting,assistantBridgePortSetting,assistantBridgeTokenSetting,getBrightnessPreferences,displayLayoutSetting,navigateDisplayLayoutSetting,terminalDisplayLayoutSetting,elevenLabsApiKeySetting,getStringSettingById,openAiApiKeySetting,nightscoutApiTokenSetting,firmwareDebugFlagsSetting,whisperServerApiKeySetting,getVoiceTranscriptionLanguage,whisperServerModelSetting,whisperServerUrlSetting,lockScreenEnabledSetting,nightscoutSiteUrlSetting,onAnySettingChanged,previewColorSetting,ringConnectionModeSetting,type RingConnectionMode,saveVoiceRecordingsSetting,sonioxApiKeySetting,screenTimeoutSetting,screenTimeoutSettingToMs,suspendEvenHubWhenScreenOffSetting,voiceProviderSetting,wakeWordActionSetting,type ConfigSettingString } from "../ui/dashboard-settings";
|
||||
import { acceptInput, resetRingInputFilter } from "../ui/input-monitor";
|
||||
import { Application, Dialogs, ImageSource } from "@nativescript/core";
|
||||
import { EvenAIStatus, EvenAIStatusName, EventSourceType, EventSourceTypeName, OsEventTypeList, OsEventTypeName, WatchGestureType, WatchGestureTypeName } from "./events";
|
||||
@@ -78,7 +79,6 @@ import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-a
|
||||
import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry";
|
||||
import { type ContinuousCaptureOptions, type LayerActions, type TextSettingsEditToggle, type TranscriptionChoice } from "../ui/layers";
|
||||
import { type KeyboardInputSession } from "../ui/shell/keyboard-input";
|
||||
import { appSwitcherPositionSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, getHeadUpPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, ringConnectionModeSetting, type RingConnectionMode, saveVoiceRecordingsSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings";
|
||||
import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization";
|
||||
import {
|
||||
getInstalledEvenHubAppById,
|
||||
@@ -452,6 +452,8 @@ class DashboardController {
|
||||
openNotificationsWindow: () =>
|
||||
this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow),
|
||||
onSwitcherBarHeightChanged: () => this.applySwitcherBarHeight(),
|
||||
onWindowLayoutChanged: () => this.applySwitcherBarHeight(),
|
||||
isLocked: () => this.glassesLocked,
|
||||
onScreenStateChanged: (on) => {
|
||||
// Any wake of the regular UI replaces a showing Glanceboard.
|
||||
if (on) this.glance.dismiss();
|
||||
@@ -485,6 +487,7 @@ class DashboardController {
|
||||
this.applyVerticalPositionIfChanged();
|
||||
this.applyAppLayoutsIfChanged();
|
||||
this.syncAssistantBridgeIfChanged();
|
||||
this.retargetContinuousCapture();
|
||||
this.syncLockScreenSettingIfChanged();
|
||||
// A Preview color or scaling change should show on the mirror at once,
|
||||
// not at the next composited frame (cheap: floor-limited, dedup'd on
|
||||
@@ -2214,14 +2217,14 @@ class DashboardController {
|
||||
private voiceCaptureOptions(communicator: FaceclawCommunicatorBridge | null) {
|
||||
// A window that needs its own provider and language sets them for every
|
||||
// capture while it is open, so push-to-talk still shares its stream.
|
||||
// Otherwise only Whisper server is told a language (its own setting).
|
||||
// Otherwise use the shared transcription-language preference.
|
||||
const choice = this.transcriptionChoice();
|
||||
const provider = choice?.provider ?? voiceProviderSetting.get();
|
||||
return {
|
||||
communicator: communicator?.getNativeCommunicator() ?? null,
|
||||
usePhoneMic: communicator === null,
|
||||
provider,
|
||||
language: choice ? choice.language : provider === "whisper-server" ? whisperServerLanguageSetting.get() : "",
|
||||
language: choice ? choice.language : getVoiceTranscriptionLanguage(provider),
|
||||
elevenLabsApiKey: elevenLabsApiKeySetting.get(),
|
||||
openAiApiKey: openAiApiKeySetting.get(),
|
||||
sonioxApiKey: sonioxApiKeySetting.get(),
|
||||
|
||||
@@ -29,8 +29,7 @@ import { OsEventTypeList } from './events'
|
||||
import { loadDeviceAddresses } from './device-addresses'
|
||||
import { updateGlassesPresence } from './glasses-presence'
|
||||
import { firmwareIncompatibilityMessage, hasCompatibleFirmware } from './firmware-compat'
|
||||
import { isHaltedSessionPhase, resumeAutoReconnect, suppressAutoReconnect } from './reconnect-policy'
|
||||
import { WearRemote, type WearRemoteInputKind } from './wear-remote'
|
||||
import { isHaltedSessionPhase, suppressAutoReconnect } from './reconnect-policy'
|
||||
import { deviceAddressError } from './ios-peripheral-identity'
|
||||
import { createLauncherWindow, LAUNCHER_SURFACE_ID } from '../apps/launcher/launcher-app'
|
||||
import { createNotificationsAppWindow, NOTIFICATIONS_SURFACE_ID, NOTIFICATIONS_WINDOW_ID } from '../apps/notifications/notifications-app'
|
||||
@@ -52,7 +51,7 @@ import { mirrorToPanelFraction, phonePreviewCrop } from './phone-preview-crop'
|
||||
import { onAnySettingChanged,
|
||||
previewColorSetting, lockScreenEnabledSetting, getBrightnessPreferences, getStringSettingById,
|
||||
nightscoutSiteUrlSetting, nightscoutApiTokenSetting, voiceProviderSetting, elevenLabsApiKeySetting,
|
||||
openAiApiKeySetting, sonioxApiKeySetting, whisperServerApiKeySetting, whisperServerLanguageSetting,
|
||||
openAiApiKeySetting, sonioxApiKeySetting, whisperServerApiKeySetting, getVoiceTranscriptionLanguage,
|
||||
whisperServerModelSetting, whisperServerUrlSetting, ringConnectionModeSetting, saveTranscribeAudioSetting } from '../ui/dashboard-settings'
|
||||
import { transcriptionKey, type VoiceProviderSelection } from '../native/cloud-stt-provider'
|
||||
import type { PhoneGesture } from '../phone-ui/phone-gestures'
|
||||
@@ -168,8 +167,6 @@ export class IosPreviewController {
|
||||
private continuousPending = false
|
||||
private continuousCaptureToken = 0
|
||||
private sessionConnected = false
|
||||
/** The Apple Watch remote; constructed last so it sees a fully wired shell. */
|
||||
private wearRemote: WearRemote | null = null
|
||||
private readonly actions: LayerActions = {
|
||||
...noopLayerActions,
|
||||
playBuzzerSequence: payload => this.communicator?.playBuzzerSequence(payload),
|
||||
@@ -213,7 +210,7 @@ export class IosPreviewController {
|
||||
prepareVoiceCapture: () => this.prepareVoiceCapture(),
|
||||
getScreenTimeoutMs: () => null,
|
||||
requestShellRender: () => this.requestShellRender(),
|
||||
onWindowsChanged: () => { this.requestShellRender(); this.syncEvenHubPhoneUi(); this.wearRemote?.schedulePublish() },
|
||||
onWindowsChanged: () => { this.requestShellRender(); this.syncEvenHubPhoneUi() },
|
||||
openNotificationsWindow: () =>
|
||||
this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow),
|
||||
onSwitcherBarHeightChanged: () => {
|
||||
@@ -221,6 +218,12 @@ export class IosPreviewController {
|
||||
shell.foregroundWindow()?.requestRender()
|
||||
this.requestShellRender()
|
||||
},
|
||||
onWindowLayoutChanged: () => {
|
||||
this.relayout()
|
||||
shell.foregroundWindow()?.requestRender()
|
||||
this.requestShellRender()
|
||||
},
|
||||
isLocked: () => this.glassesLocked,
|
||||
onScreenStateChanged: on => {
|
||||
if (on) this.glance.dismiss()
|
||||
// A wake unblanks only once the next shell render has staged an awake
|
||||
@@ -230,7 +233,6 @@ export class IosPreviewController {
|
||||
this.unblankAfterShellRender = on
|
||||
if (!on) void this.display?.setScreenBlanked(true).catch(error => this.fail(error))
|
||||
this.requestShellRender()
|
||||
this.wearRemote?.schedulePublish()
|
||||
},
|
||||
})
|
||||
const launcher = createLauncherWindow({
|
||||
@@ -279,20 +281,6 @@ export class IosPreviewController {
|
||||
// Every capture end (drained, failed, replaced) may leave continuous capture to restart.
|
||||
iosVoiceInput.onSpeechEnd(() => this.syncContinuousCapture())
|
||||
for (const app of ALL_APPS) if (app.appId !== 'launcher' && !iosAppUnavailableReason(app.appId)) app.boot?.(this.buildAppContext(app))
|
||||
this.wearRemote = new WearRemote({
|
||||
apps: ALL_APPS.filter(app => app.showInLauncher !== false && !iosAppUnavailableReason(app.appId)),
|
||||
injectInput: kind => this.injectWatchInput(kind),
|
||||
launchApp: id => this.launchApp(id),
|
||||
// The watch's Connect/Disconnect are explicit user choices, like the phone's own buttons.
|
||||
connect: () => { resumeAutoReconnect(); return this.connect(true) },
|
||||
disconnect: () => { suppressAutoReconnect(); return this.disconnect() },
|
||||
setGlassesLocked: locked => this.setGlassesLocked(locked),
|
||||
requestShellRender: () => this.requestShellRender(),
|
||||
previewInputActive: () => !this.communicator && this.runtimeRunning,
|
||||
getState: () => ({ phase: this.state.phase, status: this.state.status, glassesLocked: this.glassesLocked,
|
||||
glassesWorn: this.glassesWorn, silentMode: false, lastHeadsetBattery: this.state.battery }),
|
||||
appendLog: line => this.logBluetooth(line),
|
||||
})
|
||||
}
|
||||
|
||||
/** The compositor frames go to: the live session, else the headless preview. */
|
||||
@@ -416,6 +404,7 @@ export class IosPreviewController {
|
||||
const phone = readPhoneBatteryState()
|
||||
this.logBluetooth(`Phone battery ${phone.battery ?? "unknown"}% charging=${phone.charging}`)
|
||||
this.offSettings = onAnySettingChanged(() => {
|
||||
this.syncContinuousCapture()
|
||||
this.syncLockSetting()
|
||||
this.pushBrightness()
|
||||
this.relayout()
|
||||
@@ -461,7 +450,6 @@ export class IosPreviewController {
|
||||
// a session's first snapshot) wakes the screen, to the lock notice if locked.
|
||||
const putOn = wearing && this.glassesWorn === false
|
||||
this.glassesWorn = wearing
|
||||
this.wearRemote?.schedulePublish()
|
||||
this.syncPresence()
|
||||
this.logBluetooth(`Glasses wear state: ${wearing ? 'ON_HEAD' : 'OFF_HEAD'}`)
|
||||
if (!wearing && this.phoneLocked && this.lockEnabled) this.setGlassesLocked(true)
|
||||
@@ -470,7 +458,6 @@ export class IosPreviewController {
|
||||
private setGlassesLocked(locked: boolean): void {
|
||||
if (locked === this.glassesLocked) return
|
||||
this.glassesLocked = locked
|
||||
this.wearRemote?.schedulePublish()
|
||||
if (locked) {
|
||||
this.glance.dismiss()
|
||||
if (iosVoiceInput.continuousSource === 'glasses') this.continuousPending = true
|
||||
@@ -619,25 +606,7 @@ export class IosPreviewController {
|
||||
console.log(`[ios-preview] ${origin} ${gesture}: ${shell.describeInputTarget()}`)
|
||||
}).catch(error => this.fail(error))
|
||||
}
|
||||
/** Input from the Apple Watch: shares the controller queue with physical input. */
|
||||
private injectWatchInput(kind: WearRemoteInputKind): Promise<void> {
|
||||
const task = this.inputQueue.then(async () => {
|
||||
this.onActivity()
|
||||
// As on Android, and because the watch may be acting on a stale state snapshot: a dark
|
||||
// display takes a double-click (wake) or a tap/hold (Glanceboard), and scrolls mean nothing.
|
||||
if (!shell.isScreenOn() && (kind === 'scroll-up' || kind === 'scroll-down' || kind === 'short-then-long-press')) return
|
||||
// A real hold releases when the finger lifts; a discrete long-press releases at once.
|
||||
const type = kind === 'long-press-start' ? 'long-press' : kind
|
||||
await this.receiveInput(makeInputEvent({ type, source: 'watch' } as InputEventPayload))
|
||||
if (kind === 'long-press') await this.receiveInput(makeInputEvent({ type: 'long-press-release', source: 'watch' }))
|
||||
console.log(`[ios-preview] apple-watch ${kind}: ${shell.describeInputTarget()}`)
|
||||
})
|
||||
this.inputQueue = task.catch(error => this.fail(error))
|
||||
return task
|
||||
}
|
||||
private async receiveInput(event: InputEvent, headTilt = false): Promise<void> {
|
||||
// Input can change the foreground app or the display state, and the shell doesn't announce those.
|
||||
this.wearRemote?.schedulePublish()
|
||||
if (!acceptInput(event)) return
|
||||
if (this.glassesLocked) {
|
||||
// Preserve the locked display's sleep/wake controls without dispatching
|
||||
@@ -845,7 +814,6 @@ export class IosPreviewController {
|
||||
this.syncRuntime()
|
||||
if (this.active) this.onConnectionState({ ...this.state })
|
||||
this.requestShellRender()
|
||||
this.wearRemote?.schedulePublish()
|
||||
}
|
||||
/** The ring level arrives through the glasses, so like Android it is shown only while connected. */
|
||||
private pushBatteryLevels(): void {
|
||||
@@ -853,16 +821,11 @@ export class IosPreviewController {
|
||||
shell.setBatteryLevels({ headset: this.state.battery, headsetCharging: this.state.charging,
|
||||
ring: connected ? this.state.ringBattery : null, ringCharging: connected ? this.state.ringCharging : null })
|
||||
}
|
||||
/** `fromBackground`: the watch asked, and the phone may be in a pocket with the app suspended. */
|
||||
async connect(fromBackground = false): Promise<void> {
|
||||
if ((!this.active && !fromBackground) || this.connecting || this.stopping) return
|
||||
async connect(): Promise<void> {
|
||||
if (!this.active || this.connecting || this.stopping) return
|
||||
if (this.communicator && ['connecting', 'connected', 'retrying', 'disconnecting'].includes(this.state.phase)) return
|
||||
const addresses = loadDeviceAddresses(), error = deviceAddressError(addresses)
|
||||
if (error) {
|
||||
if (this.active) this.onError(error)
|
||||
else this.logBluetooth(error)
|
||||
return
|
||||
}
|
||||
if (error) { this.onError(error); return }
|
||||
this.connecting = true
|
||||
this.sessionCreated = true
|
||||
try {
|
||||
@@ -926,7 +889,6 @@ export class IosPreviewController {
|
||||
this.pushBatteryLevels()
|
||||
if (this.active) this.onConnectionState({ ...this.state })
|
||||
this.requestShellRender()
|
||||
this.wearRemote?.schedulePublish()
|
||||
}),
|
||||
communicator.onCaseState(state => {
|
||||
if (this.communicator !== communicator) return
|
||||
@@ -934,7 +896,6 @@ export class IosPreviewController {
|
||||
// the case's own charging is only known while the glasses are docked.
|
||||
shell.setBatteryLevels({ ...(state.battery !== null ? { case: state.battery } : {}),
|
||||
caseCharging: state.docked ? state.charging : null })
|
||||
this.wearRemote?.schedulePublish()
|
||||
}),
|
||||
communicator.onFirmwareInfo(info => {
|
||||
if (this.communicator !== communicator) return
|
||||
@@ -1198,13 +1159,12 @@ export class IosPreviewController {
|
||||
/**
|
||||
* The transcription provider setting and the keys the cloud ones need. A
|
||||
* window that needs its own provider and language (Translate) sets them for
|
||||
* every capture while it is open; otherwise only Whisper server is told a
|
||||
* language (its own setting).
|
||||
* every capture while it is open; otherwise use the shared language preference.
|
||||
*/
|
||||
private voiceProvider(): VoiceProviderSelection {
|
||||
const choice = [...this.continuousClients.values()].find(options => options.transcription)?.transcription
|
||||
const provider = choice?.provider ?? voiceProviderSetting.get()
|
||||
return { provider, language: choice ? choice.language : provider === 'whisper-server' ? whisperServerLanguageSetting.get() : '',
|
||||
return { provider, language: choice ? choice.language : getVoiceTranscriptionLanguage(provider),
|
||||
elevenLabsApiKey: elevenLabsApiKeySetting.get(), openAiApiKey: openAiApiKeySetting.get(), sonioxApiKey: sonioxApiKeySetting.get(),
|
||||
whisperServerUrl: whisperServerUrlSetting.get(), whisperServerModel: whisperServerModelSetting.get(),
|
||||
whisperServerApiKey: whisperServerApiKeySetting.get() }
|
||||
|
||||
+13
-51
@@ -1,6 +1,5 @@
|
||||
/**
|
||||
* The watch (Wear OS or Apple Watch) as an input device and status mirror for
|
||||
* the glasses.
|
||||
* The Wear OS watch as an input device and status mirror for the glasses.
|
||||
*
|
||||
* Inbound, the watch sends ring-style gestures (tap, double-tap, hold,
|
||||
* swipe/crown scrolls, "Hey Even") which feed the exact synthetic-ring path
|
||||
@@ -18,14 +17,11 @@
|
||||
* The watch's own battery flows the other way for the glasses' top-bar and
|
||||
* Glanceboard indicators: the phone polls it (the watch answers from a
|
||||
* listener service even while its app is closed) and the open watch app
|
||||
* pushes changes unprompted. An Apple Watch app can't be woken to answer, so
|
||||
* it reports when it can instead (see wear/PROTOCOL.md). The level lives in
|
||||
* shell.getBatteryLevels() beside the G2 and R1 ones and is cleared when no
|
||||
* watch is reachable or the last report has gone stale.
|
||||
* pushes changes unprompted. The level lives in shell.getBatteryLevels()
|
||||
* beside the G2 and R1 ones and is cleared when no watch is reachable.
|
||||
*
|
||||
* Transport is app/native/wear-bridge.ts (Java FaceclawWearBridge) or
|
||||
* wear-bridge.ios.ts (FaceclawWatchBridge); the message shapes are documented
|
||||
* in wear/PROTOCOL.md.
|
||||
* Transport is app/native/wear-bridge.ts (Java FaceclawWearBridge); the
|
||||
* message shapes are documented in wear/PROTOCOL.md.
|
||||
*/
|
||||
import { flagAnalyticsEvent } from "../analytics/analytics";
|
||||
import { type AppDefinition } from "../apps/app-definition";
|
||||
@@ -37,8 +33,6 @@ import {
|
||||
watchCrownClockwiseNextSetting,
|
||||
watchMirrorAssistantSetting,
|
||||
watchRemoteEnabledSetting,
|
||||
watchSoundEffectsSetting,
|
||||
watchVibrateOnInputSetting,
|
||||
} from "../ui/dashboard-settings";
|
||||
import { shell, type AssistantActivityEvent } from "../ui/shell/shell";
|
||||
import { voiceActivity } from "../ui/shell/voice-activity";
|
||||
@@ -108,10 +102,6 @@ const WATCH_BATTERY_POLL_INTERVAL_MS = 5 * 60_000;
|
||||
// glasses connecting) would otherwise trigger back to back.
|
||||
const WATCH_BATTERY_POLL_MIN_GAP_MS = 20_000;
|
||||
const WATCH_BATTERY_URGENT_POLL_LIMIT = 3;
|
||||
// Wear OS answers every poll. A closed Apple Watch app only reports when the
|
||||
// system gives it background time, which can be hours apart, so a level this
|
||||
// old says more about the watch being gone than about its charge.
|
||||
const WATCH_BATTERY_MAX_AGE_MS = 4 * 60 * 60_000;
|
||||
|
||||
/** What the dashboard controller lends the watch remote. */
|
||||
export type WearRemoteHost = {
|
||||
@@ -123,11 +113,6 @@ export type WearRemoteHost = {
|
||||
disconnect: () => Promise<void>;
|
||||
setGlassesLocked: (locked: boolean, reason: string) => void;
|
||||
requestShellRender: () => void;
|
||||
/**
|
||||
* The shell is running on the phone's preview with no glasses involved, so
|
||||
* gestures have somewhere to go even though nothing is connected.
|
||||
*/
|
||||
previewInputActive?: () => boolean;
|
||||
getState: () => {
|
||||
phase: string;
|
||||
status: string;
|
||||
@@ -151,7 +136,6 @@ export class WearRemote {
|
||||
private lastAssistantSentAtMs = 0;
|
||||
private lastWatchBatteryPollAtMs = 0;
|
||||
private watchBatteryKnown = false;
|
||||
private watchBatteryReportedAtMs = 0;
|
||||
// Urgent polls that got no answer; a watch app too old to answer them
|
||||
// must not be poked every publish, so after a few the cadence drops back.
|
||||
private watchBatteryPollsUnanswered = 0;
|
||||
@@ -159,7 +143,7 @@ export class WearRemote {
|
||||
constructor(private readonly host: WearRemoteHost) {
|
||||
this.active = wearBridge.isAvailable();
|
||||
if (!this.active) {
|
||||
host.appendLog(`watch: ${global.isIOS ? "WatchConnectivity" : "Google Play services"} unavailable; watch remote disabled`);
|
||||
host.appendLog("watch: Google Play services unavailable; watch remote disabled");
|
||||
return;
|
||||
}
|
||||
wearBridge.onMessage((message) => {
|
||||
@@ -199,25 +183,10 @@ export class WearRemote {
|
||||
// Catch-all refresh for state the controller does not announce (cheap:
|
||||
// identical states are dropped on the Java side).
|
||||
setInterval(() => this.schedulePublish(), STATE_REFRESH_INTERVAL_MS);
|
||||
setInterval(() => {
|
||||
this.expireWatchBattery();
|
||||
this.pollWatchBattery(false);
|
||||
}, WATCH_BATTERY_POLL_INTERVAL_MS);
|
||||
setInterval(() => this.pollWatchBattery(false), WATCH_BATTERY_POLL_INTERVAL_MS);
|
||||
this.schedulePublish();
|
||||
}
|
||||
|
||||
/** Gestures have a display to act on: the glasses, or the phone's preview without them. */
|
||||
private takesInput(): boolean {
|
||||
const phase = this.host.getState().phase;
|
||||
return phase === "connected" || phase === "charging" || this.host.previewInputActive?.() === true;
|
||||
}
|
||||
|
||||
private expireWatchBattery(): void {
|
||||
if (this.watchBatteryKnown && Date.now() - this.watchBatteryReportedAtMs > WATCH_BATTERY_MAX_AGE_MS) {
|
||||
this.setWatchBattery(null, null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ask the reachable watch for its battery. `urgent` skips the poll gap for
|
||||
* a level that is not known yet (the glasses just connected, the watch
|
||||
@@ -288,7 +257,6 @@ export class WearRemote {
|
||||
phase: state.phase,
|
||||
status: state.status,
|
||||
connected: state.phase === "connected" || state.phase === "charging",
|
||||
preview: this.host.previewInputActive?.() === true,
|
||||
screenOn: shell.isScreenOn(),
|
||||
locked: state.glassesLocked,
|
||||
worn: state.glassesWorn,
|
||||
@@ -310,8 +278,6 @@ export class WearRemote {
|
||||
apps: this.listApps(),
|
||||
remoteEnabled: watchRemoteEnabledSetting.get(),
|
||||
crownClockwiseNext: watchCrownClockwiseNextSetting.get(),
|
||||
vibrateOnInput: watchVibrateOnInputSetting.get(),
|
||||
soundEffects: watchSoundEffectsSetting.get(),
|
||||
canUnlock: watchCanUnlockSetting.get(),
|
||||
mirrorAssistant: watchMirrorAssistantSetting.get(),
|
||||
assistantAvailable: shell.isAssistantAvailable(),
|
||||
@@ -341,11 +307,7 @@ export class WearRemote {
|
||||
// acked (the watch sends it fire-and-forget, without a seq).
|
||||
this.watchBatteryPollsUnanswered = 0;
|
||||
const battery = readNumber(message.payload.battery, -1);
|
||||
// A report the watch left behind earlier says when it was taken; a live one is current.
|
||||
const reportedAtMs = readNumber(message.payload.at, Date.now());
|
||||
const valid = Number.isInteger(battery) && battery >= 0 && battery <= 100 &&
|
||||
Date.now() - reportedAtMs <= WATCH_BATTERY_MAX_AGE_MS;
|
||||
this.watchBatteryReportedAtMs = reportedAtMs;
|
||||
const valid = Number.isInteger(battery) && battery >= 0 && battery <= 100;
|
||||
this.setWatchBattery(valid ? battery : null, valid ? message.payload.charging === true : null);
|
||||
return;
|
||||
}
|
||||
@@ -353,7 +315,8 @@ export class WearRemote {
|
||||
// Touch-down ahead of the gesture that follows it. Fire-and-forget like
|
||||
// the battery (no seq, never acked): wherever that gesture would be
|
||||
// refused, the press is dropped silently and the gesture's ack says why.
|
||||
if (watchRemoteEnabledSetting.get() && this.takesInput()) {
|
||||
const phase = this.host.getState().phase;
|
||||
if (watchRemoteEnabledSetting.get() && (phase === "connected" || phase === "charging")) {
|
||||
await this.host.injectInput("ring-press");
|
||||
}
|
||||
return;
|
||||
@@ -415,7 +378,8 @@ export class WearRemote {
|
||||
return;
|
||||
}
|
||||
const kind = gesture as WearRemoteInputKind;
|
||||
if (!this.takesInput()) {
|
||||
const state = this.host.getState();
|
||||
if (state.phase !== "connected" && state.phase !== "charging") {
|
||||
ack(false, "The glasses are not connected.");
|
||||
return;
|
||||
}
|
||||
@@ -458,7 +422,7 @@ export class WearRemote {
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (!this.takesInput()) {
|
||||
if (!connected) {
|
||||
ack(false, "The glasses are not connected.");
|
||||
return;
|
||||
}
|
||||
@@ -597,8 +561,6 @@ export class WearRemote {
|
||||
}
|
||||
|
||||
function readNumber(value: unknown, fallback: number): number {
|
||||
// Number(null) is 0: a watch reporting an unknown battery would read as empty.
|
||||
if (value === null) return fallback;
|
||||
const numeric = typeof value === "number" ? value : Number(value);
|
||||
return Number.isFinite(numeric) ? numeric : fallback;
|
||||
}
|
||||
|
||||
+32
-2
@@ -9,7 +9,7 @@ declare const java: any;
|
||||
* than bundled in the APK; FaceclawVoiceController reads the files from the
|
||||
* directory each model's `dirName` names.
|
||||
*
|
||||
* Two models, same shape:
|
||||
* Downloadable models, same shape:
|
||||
* - "moonshine": the original on-device option (three files). The model is
|
||||
* no longer bundled in the APK; it is fetched into the same filesDir
|
||||
* location that earlier releases copied the bundled files to, so
|
||||
@@ -29,12 +29,17 @@ declare const java: any;
|
||||
* used for Moonshine below. Every hash here was computed locally from a
|
||||
* freshly downloaded copy of the file, not copied from a doc page.
|
||||
*
|
||||
* - "whisper-base": multilingual base, int8-quantized. Used for non-English
|
||||
* speech and auto-detection; English-only downloads remain untouched.
|
||||
* SHA-256/size values come from the maintainer's LFS metadata, with the
|
||||
* vocabulary hash computed locally. URLs pin the source revision.
|
||||
*
|
||||
* Mirrors the on-phone assistant model flow in llama.ts, except each model
|
||||
* here is multiple files rather than one; they download sequentially through
|
||||
* FaceclawModelDownloader (resume + pinned sha256 per file).
|
||||
*/
|
||||
|
||||
export type AsrModelId = "moonshine" | "whisper-base-en";
|
||||
export type AsrModelId = "moonshine" | "whisper-base-en" | "whisper-base";
|
||||
|
||||
type AsrModelFile = {
|
||||
name: string;
|
||||
@@ -105,6 +110,30 @@ export const ASR_MODELS: Record<AsrModelId, AsrModelDef> = {
|
||||
],
|
||||
totalBytes: 160626066,
|
||||
},
|
||||
|
||||
"whisper-base": {
|
||||
label: "Whisper (multilingual, base)",
|
||||
dirName: "sherpa-onnx-whisper-base-int8",
|
||||
baseUrl: "https://huggingface.co/csukuangfj/sherpa-onnx-whisper-base/resolve/bb53ee204431c90d314c1cc08d28d23e5b7927cc/",
|
||||
files: [
|
||||
{
|
||||
name: "base-encoder.int8.onnx",
|
||||
sha256: "0b8fb1304b6109976038efff5ace81720e00386f3ff6b54ee8c75291ca0a1e11",
|
||||
sizeBytes: 29120534,
|
||||
},
|
||||
{
|
||||
name: "base-decoder.int8.onnx",
|
||||
sha256: "9759d217388a01b3a4c7c15533201067b48ae819c4daafc8624e64b9409dc02d",
|
||||
sizeBytes: 130672026,
|
||||
},
|
||||
{
|
||||
name: "base-tokens.txt",
|
||||
sha256: "b34b360dbb493e781e479794586d661700670d65564001f23024971d1f2fa126",
|
||||
sizeBytes: 816730,
|
||||
},
|
||||
],
|
||||
totalBytes: 160609290,
|
||||
},
|
||||
};
|
||||
|
||||
export type AsrModelState = {
|
||||
@@ -129,6 +158,7 @@ function freshRuntime(): ModelRuntime {
|
||||
const runtimes: Record<AsrModelId, ModelRuntime> = {
|
||||
moonshine: freshRuntime(),
|
||||
"whisper-base-en": freshRuntime(),
|
||||
"whisper-base": freshRuntime(),
|
||||
};
|
||||
|
||||
function modelDirPath(id: AsrModelId): string {
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
import { getStringSetting, setStringSetting } from "./settings-store";
|
||||
|
||||
export const CALENDAR_SELECTION_KEY = "calendar.selectedIds";
|
||||
/** null means all calendars (including future ones); [] explicitly means none. */
|
||||
export function readCalendarSelection(): string[] | null {
|
||||
try {
|
||||
const value = JSON.parse(getStringSetting(CALENDAR_SELECTION_KEY, "null"));
|
||||
if (value === null) return null;
|
||||
if (!Array.isArray(value) || !value.every(id => typeof id === "string" && /^\d+$/.test(id))) return null;
|
||||
return Array.from(new Set<string>(value));
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
export function setCalendarSelection(ids: readonly string[] | null): void {
|
||||
if (ids !== null && !ids.every(id => /^\d+$/.test(id))) throw new Error("Invalid calendar ID");
|
||||
setStringSetting(CALENDAR_SELECTION_KEY, JSON.stringify(ids === null ? null : Array.from(new Set(ids))));
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import { Utils } from "@nativescript/core";
|
||||
import { hasCalendarPermission } from "./calendar-permissions";
|
||||
|
||||
declare const com: any;
|
||||
|
||||
export type CalendarSource = { id: string; name: string; accountName: string; accountType: string };
|
||||
|
||||
/** Android calendar IDs survive renames and distinguish equal display names. */
|
||||
export function readAvailableCalendars(): CalendarSource[] {
|
||||
if (!global.isAndroid || !hasCalendarPermission()) return [];
|
||||
try {
|
||||
const context = Utils.android.getApplicationContext();
|
||||
if (!context) return [];
|
||||
const parsed = JSON.parse(String(com.faceclaw.app.FaceclawCalendarProvider.getCalendarsJson(context)));
|
||||
if (!Array.isArray(parsed)) return [];
|
||||
return parsed.filter(row => row && typeof row.id === "string" && /^\d+$/.test(row.id))
|
||||
.map(row => ({ id: row.id, name: String(row.name ?? ""),
|
||||
accountName: String(row.accountName ?? ""), accountType: String(row.accountType ?? "") }));
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
+15
-3
@@ -2,6 +2,8 @@ import { Utils } from "@nativescript/core";
|
||||
import { hasCalendarPermission } from "../g2/android-permissions";
|
||||
import { spanCurrent } from "./frame-timings";
|
||||
import { type CalendarEvent, type CalendarReadState } from "./calendar-types";
|
||||
import { CALENDAR_SELECTION_KEY, readCalendarSelection } from "./calendar-selection";
|
||||
import { onSettingsStoreChanged } from "./settings-store";
|
||||
export type { CalendarEvent } from "./calendar-types";
|
||||
|
||||
declare const com: any;
|
||||
@@ -13,14 +15,21 @@ declare const com: any;
|
||||
*/
|
||||
|
||||
// Android reads synchronously; iOS notifies subscribers after background reads.
|
||||
export function onCalendarChanged(_listener: () => void): () => void { return () => {}; }
|
||||
export function onCalendarChanged(listener: () => void): () => void {
|
||||
return onSettingsStoreChanged(key => {
|
||||
if (key === CALENDAR_SELECTION_KEY || key == null) {
|
||||
invalidateCalendarCache();
|
||||
listener();
|
||||
}
|
||||
});
|
||||
}
|
||||
export function getCalendarReadState(): CalendarReadState { return "ready"; }
|
||||
|
||||
const DEFAULT_MAX_EVENTS = 50;
|
||||
const DEFAULT_WINDOW_MS = 14 * 24 * 60 * 60 * 1000;
|
||||
const CACHE_MS = 30_000;
|
||||
|
||||
let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number } | null = null;
|
||||
let cache: { events: CalendarEvent[]; atMs: number; maxEvents: number; windowMs: number; selection: string } | null = null;
|
||||
|
||||
/**
|
||||
* Upcoming events from now through the given window, ordered by start time.
|
||||
@@ -35,9 +44,11 @@ export function readUpcomingEvents(
|
||||
if (!global.isAndroid || !hasCalendarPermission()) return [];
|
||||
|
||||
const now = Date.now();
|
||||
const selection = JSON.stringify(readCalendarSelection());
|
||||
if (
|
||||
!forceRefresh &&
|
||||
cache &&
|
||||
cache.selection === selection &&
|
||||
cache.maxEvents === maxEvents &&
|
||||
cache.windowMs === windowMs &&
|
||||
now - cache.atMs < CACHE_MS
|
||||
@@ -55,6 +66,7 @@ export function readUpcomingEvents(
|
||||
context,
|
||||
Math.max(0, Math.round(maxEvents)),
|
||||
Math.max(0, Math.round(windowMs)),
|
||||
selection,
|
||||
),
|
||||
),
|
||||
);
|
||||
@@ -62,7 +74,7 @@ export function readUpcomingEvents(
|
||||
const events = Array.isArray(parsed)
|
||||
? parsed.map(normalizeEvent).filter((event): event is CalendarEvent => Boolean(event))
|
||||
: [];
|
||||
cache = { events, atMs: now, maxEvents, windowMs };
|
||||
cache = { events, atMs: now, maxEvents, windowMs, selection };
|
||||
return events;
|
||||
} catch {
|
||||
return [];
|
||||
|
||||
@@ -14,7 +14,7 @@ export type VoiceProviderSelection = {
|
||||
provider: VoiceProviderKind;
|
||||
/**
|
||||
* Spoken language the provider should expect (ISO 639-1); empty lets it
|
||||
* detect the language. Cloud providers only.
|
||||
* detect the language. Also used by on-device Whisper.
|
||||
*/
|
||||
language?: string;
|
||||
elevenLabsApiKey: string;
|
||||
@@ -77,7 +77,8 @@ function isConfigured(provider: CloudProvider, selection: VoiceProviderSelection
|
||||
* to expect. A running capture is shared only by holders asking for the same.
|
||||
*/
|
||||
export function transcriptionKey(selection: Pick<VoiceProviderSelection, "provider" | "language">): string {
|
||||
return `${selection.provider}:${(selection.language ?? "").trim().toLowerCase()}`;
|
||||
const fallback = selection.provider === "onboard-whisper" ? "en" : "";
|
||||
return `${selection.provider}:${(selection.language ?? fallback).trim().toLowerCase()}`;
|
||||
}
|
||||
|
||||
/** Whether createCloudSttClient would return a cloud client for this selection. */
|
||||
|
||||
@@ -26,6 +26,16 @@ export function iosNotificationState(): AncsState { return active?.state ?? 'dis
|
||||
export function readActiveNotifications(maxNotifications = 50) { return active?.read(maxNotifications) ?? [] }
|
||||
export function invokeNotificationAction(key: string, index: number): boolean { return active?.action(key,index) ?? false }
|
||||
export function dismissNotification(key: string): boolean { return active?.dismiss(key) ?? false }
|
||||
export function dismissAllNotifications(): boolean {
|
||||
const client = active
|
||||
if (!client) return false
|
||||
// Snapshot: removals may arrive while dismissal requests are being sent.
|
||||
let accepted = true
|
||||
for (const notification of [...client.read(ALL_NOTIFICATIONS)]) {
|
||||
if (!client.dismiss(notification.key)) accepted = false
|
||||
}
|
||||
return accepted
|
||||
}
|
||||
export function onAndroidNotificationPosted(listener: (key: string) => void): () => void {
|
||||
listeners.add(listener); return () => { listeners.delete(listener) }
|
||||
}
|
||||
|
||||
@@ -337,6 +337,13 @@ export function dismissNotification(notificationKey: string): boolean {
|
||||
);
|
||||
}
|
||||
|
||||
/** Explicit user action: dismiss on the phone as well as on the glasses. */
|
||||
export function dismissAllNotifications(): boolean {
|
||||
if (!global.isAndroid) return false;
|
||||
invalidateIconCaches();
|
||||
return Boolean(com.faceclaw.app.FaceclawMediaNotificationListenerService.dismissAllNotifications());
|
||||
}
|
||||
|
||||
export function onAndroidNotificationPosted(listener: (notificationKey: string) => void): () => void {
|
||||
return addNotificationListener(notificationPostedListeners, listener);
|
||||
}
|
||||
|
||||
@@ -1,6 +1,16 @@
|
||||
import { getStringSetting, setStringSetting } from "./settings-store";
|
||||
|
||||
const SOURCES_KEY = "notifications.sources";
|
||||
const DEFAULT_KEY = "notifications.newAppsEnabledByDefault";
|
||||
|
||||
/** Unset preserves the behavior of existing installations. */
|
||||
export function newNotificationAppsEnabledByDefault(): boolean {
|
||||
return getStringSetting(DEFAULT_KEY, "true") !== "false";
|
||||
}
|
||||
|
||||
export function setNewNotificationAppsEnabledByDefault(enabled: boolean): void {
|
||||
setStringSetting(DEFAULT_KEY, String(enabled));
|
||||
}
|
||||
|
||||
export type NotificationSource = {
|
||||
packageName: string;
|
||||
@@ -8,8 +18,15 @@ export type NotificationSource = {
|
||||
showOnGlasses: boolean;
|
||||
};
|
||||
|
||||
type SavedSource = Omit<NotificationSource, "showOnGlasses"> & { showOnGlasses?: boolean };
|
||||
|
||||
/** Sources outlive their active notifications so a muted app can always be re-enabled. */
|
||||
export function readNotificationSources(): NotificationSource[] {
|
||||
const enabled = newNotificationAppsEnabledByDefault();
|
||||
return readSavedSources().map((source) => ({ ...source, showOnGlasses: source.showOnGlasses ?? enabled }));
|
||||
}
|
||||
|
||||
function readSavedSources(): SavedSource[] {
|
||||
try {
|
||||
const parsed = JSON.parse(getStringSetting(SOURCES_KEY, "[]"));
|
||||
if (!Array.isArray(parsed)) return [];
|
||||
@@ -17,7 +34,7 @@ export function readNotificationSources(): NotificationSource[] {
|
||||
.map((source) => ({
|
||||
packageName: source.packageName,
|
||||
appName: typeof source.appName === "string" && source.appName ? source.appName : source.packageName,
|
||||
showOnGlasses: source.showOnGlasses !== false,
|
||||
showOnGlasses: typeof source.showOnGlasses === "boolean" ? source.showOnGlasses : undefined,
|
||||
}));
|
||||
} catch {
|
||||
return [];
|
||||
@@ -25,7 +42,7 @@ export function readNotificationSources(): NotificationSource[] {
|
||||
}
|
||||
|
||||
export function rememberNotificationSources(notifications: { packageName: string; appName: string }[]): void {
|
||||
const sources = new Map(readNotificationSources().map((source) => [source.packageName, source]));
|
||||
const sources = new Map(readSavedSources().map((source) => [source.packageName, source]));
|
||||
let changed = false;
|
||||
for (const notification of notifications) {
|
||||
if (!notification.packageName) continue;
|
||||
@@ -35,7 +52,7 @@ export function rememberNotificationSources(notifications: { packageName: string
|
||||
sources.set(notification.packageName, {
|
||||
packageName: notification.packageName,
|
||||
appName,
|
||||
showOnGlasses: previous?.showOnGlasses ?? true,
|
||||
showOnGlasses: previous?.showOnGlasses,
|
||||
});
|
||||
changed = true;
|
||||
}
|
||||
@@ -44,12 +61,13 @@ export function rememberNotificationSources(notifications: { packageName: string
|
||||
}
|
||||
|
||||
export function shouldShowNotificationOnGlasses(packageName: string): boolean {
|
||||
return readNotificationSources().find((source) => source.packageName === packageName)?.showOnGlasses ?? true;
|
||||
return readNotificationSources().find((source) => source.packageName === packageName)?.showOnGlasses
|
||||
?? newNotificationAppsEnabledByDefault();
|
||||
}
|
||||
|
||||
export function setNotificationSourceEnabled(source: { packageName: string; appName: string }, enabled: boolean): void {
|
||||
if (!source.packageName) return;
|
||||
const sources = new Map(readNotificationSources().map((item) => [item.packageName, item]));
|
||||
const sources = new Map(readSavedSources().map((item) => [item.packageName, item]));
|
||||
sources.set(source.packageName, {
|
||||
packageName: source.packageName,
|
||||
appName: source.appName || source.packageName,
|
||||
@@ -57,3 +75,10 @@ export function setNotificationSourceEnabled(source: { packageName: string; appN
|
||||
});
|
||||
setStringSetting(SOURCES_KEY, JSON.stringify(Array.from(sources.values())));
|
||||
}
|
||||
|
||||
/** Set explicit choices only for sources already discovered; leave the future default alone. */
|
||||
export function setAllNotificationSourcesEnabled(enabled: boolean): void {
|
||||
setStringSetting(SOURCES_KEY, JSON.stringify(readSavedSources().map((source) => ({
|
||||
...source, showOnGlasses: enabled,
|
||||
}))));
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
/** Languages supported by both Whisper backends, in picker order. */
|
||||
export const TRANSCRIPTION_LANGUAGES = {
|
||||
en: "English", fr: "French", de: "German", es: "Spanish", it: "Italian",
|
||||
pt: "Portuguese", nl: "Dutch", ar: "Arabic", zh: "Chinese", cs: "Czech",
|
||||
da: "Danish", fi: "Finnish", el: "Greek", he: "Hebrew", hi: "Hindi",
|
||||
hu: "Hungarian", id: "Indonesian", ja: "Japanese", ko: "Korean",
|
||||
no: "Norwegian", pl: "Polish", ro: "Romanian", ru: "Russian", sk: "Slovak",
|
||||
sv: "Swedish", th: "Thai", tr: "Turkish", uk: "Ukrainian", vi: "Vietnamese",
|
||||
} as const;
|
||||
|
||||
export type TranscriptionLanguage = "default" | "auto" | keyof typeof TRANSCRIPTION_LANGUAGES;
|
||||
|
||||
/** An empty language asks Whisper to detect it; default preserves each engine's old behavior. */
|
||||
export function resolveTranscriptionLanguage(
|
||||
choice: TranscriptionLanguage, provider: string, serverLanguage = "",
|
||||
): string {
|
||||
// Moonshine is English-only; Apple's on-device recognizer retains its own locale.
|
||||
if (provider === "onboard") return "";
|
||||
if (choice === "default") {
|
||||
if (provider === "onboard-whisper") return "en";
|
||||
return provider === "whisper-server" ? serverLanguage.trim().toLowerCase() : "";
|
||||
}
|
||||
return choice === "auto" ? "" : choice;
|
||||
}
|
||||
@@ -58,7 +58,7 @@ export type PushToTalkOptions = {
|
||||
whisperServerUrl?: string;
|
||||
whisperServerModel?: string;
|
||||
whisperServerApiKey?: string;
|
||||
/** Spoken language for cloud providers (see VoiceProviderSelection.language). */
|
||||
/** Spoken language for cloud providers and on-device Whisper; empty detects, absent keeps local English. */
|
||||
language?: string;
|
||||
saveRecording: boolean;
|
||||
/**
|
||||
@@ -396,6 +396,7 @@ export class FaceclawVoiceControlBridge {
|
||||
// Which on-device model to load; a no-op setter for every provider except
|
||||
// "onboard-whisper" (FaceclawVoiceController defaults to Moonshine).
|
||||
this.controller?.setOnboardModelKind(options.provider === "onboard-whisper" ? "whisper" : "moonshine");
|
||||
this.controller?.setOnboardLanguage(options.language ?? "en");
|
||||
const captureId = this.nextNativeCaptureId++;
|
||||
this.nativeCaptureFinished = new Promise((resolve) => { this.nativeCaptureResolvers.set(captureId, resolve); });
|
||||
this.controller?.start("onboard", captureId);
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
/**
|
||||
* The watch transport's wire names and shapes, shared by the Wear OS bridge
|
||||
* (wear-bridge.ts) and the Apple Watch one (wear-bridge.ios.ts). See
|
||||
* wear/PROTOCOL.md for the messages themselves.
|
||||
*/
|
||||
|
||||
/** Message paths shared with the watch apps (wear/app/.../Protocol.kt, apple-watch/Faceclaw/Protocol.swift). */
|
||||
export const WEAR_PATHS = {
|
||||
/** Watch -> phone: a ring-style gesture. */
|
||||
input: "/faceclaw/input",
|
||||
/** Watch -> phone: a finger landed on the pad (the ring-press ahead of a gesture); never acked. */
|
||||
press: "/faceclaw/press",
|
||||
/** Watch -> phone: a shell command (launch app, wake, lock, ...). */
|
||||
command: "/faceclaw/command",
|
||||
/** Watch -> phone: a text query for the assistant. */
|
||||
assistant: "/faceclaw/assistant",
|
||||
/** Watch -> phone: text to type into the foreground app. */
|
||||
text: "/faceclaw/text",
|
||||
/** Watch -> phone: please re-publish the state item. */
|
||||
stateRequest: "/faceclaw/state/request",
|
||||
/** Watch -> phone: the watch's own battery ({battery, charging}); never acked. */
|
||||
battery: "/faceclaw/battery",
|
||||
/** Phone -> watch: please report the watch battery (answered even while the watch app is closed). */
|
||||
batteryRequest: "/faceclaw/battery/request",
|
||||
/** Phone -> watch: reply to any of the above. */
|
||||
ack: "/faceclaw/ack",
|
||||
/** Phone -> watch: assistant activity, alerts, voice-dialog transcripts. */
|
||||
event: "/faceclaw/event",
|
||||
/** Phone -> watch Data Layer item: the mirrored dashboard state. */
|
||||
state: "/faceclaw/state",
|
||||
} as const;
|
||||
|
||||
export type WearMessage = {
|
||||
path: string;
|
||||
/** Parsed JSON payload ({} when the watch sent none or it was malformed). */
|
||||
payload: Record<string, unknown>;
|
||||
nodeId: string;
|
||||
};
|
||||
|
||||
export type WearWatchConnection = {
|
||||
reachable: boolean;
|
||||
watchName: string;
|
||||
};
|
||||
|
||||
export function parseWearPayload(json: string): Record<string, unknown> {
|
||||
try {
|
||||
const parsed = JSON.parse(json);
|
||||
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
|
||||
} catch {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
@@ -1,123 +0,0 @@
|
||||
/**
|
||||
* iOS twin of wear-bridge.ts: the phone side of the Apple Watch remote, over
|
||||
* WatchConnectivity (App_Resources/iOS/src/FaceclawWatchBridge). It has the
|
||||
* same surface and carries the same (path, JSON) messages, so
|
||||
* app/g2/wear-remote.ts gives them their meaning on both platforms.
|
||||
*
|
||||
* "Reachable" here means an Apple Watch with the Faceclaw app is paired, not
|
||||
* that the app is running: iOS can't wake a closed watch app, and it is
|
||||
* suspended whenever the wrist drops, so WCSession's live reachability flips
|
||||
* constantly. The native side sends live while it can and otherwise leaves
|
||||
* the latest state in the application context for the app's next wake.
|
||||
*/
|
||||
import { WEAR_PATHS, parseWearPayload, type WearMessage, type WearWatchConnection } from './wear-bridge-types'
|
||||
|
||||
export { WEAR_PATHS, type WearMessage, type WearWatchConnection }
|
||||
|
||||
declare const FaceclawWatchBridge: any
|
||||
|
||||
/** WatchConnectivity doesn't expose the watch's own name. */
|
||||
const WATCH_NAME = 'Apple Watch'
|
||||
/** Replies go to the session's one counterpart; this only fills WearMessage.nodeId. */
|
||||
const WATCH_NODE_ID = 'apple-watch'
|
||||
|
||||
type MessageListener = (message: WearMessage) => void
|
||||
type ConnectionListener = (connection: WearWatchConnection) => void
|
||||
|
||||
class WearBridge {
|
||||
private nativeBridge: any = undefined
|
||||
private listening = false
|
||||
private readonly messageListeners = new Set<MessageListener>()
|
||||
private readonly connectionListeners = new Set<ConnectionListener>()
|
||||
|
||||
private native(): any {
|
||||
if (this.nativeBridge !== undefined) return this.nativeBridge
|
||||
try {
|
||||
const bridge = FaceclawWatchBridge.shared()
|
||||
this.nativeBridge = bridge.isAvailable() ? bridge : null
|
||||
} catch (error) {
|
||||
console.warn('watch bridge unavailable', error)
|
||||
this.nativeBridge = null
|
||||
}
|
||||
return this.nativeBridge
|
||||
}
|
||||
|
||||
/** Whether WatchConnectivity works on this phone (it does on every iPhone). */
|
||||
isAvailable(): boolean {
|
||||
return this.native() !== null
|
||||
}
|
||||
|
||||
private ensureListener(): void {
|
||||
if (this.listening) return
|
||||
const native = this.native()
|
||||
if (!native) return
|
||||
this.listening = true
|
||||
native.setMessageHandlerConnectionHandler((path: string, json: string) => {
|
||||
const message: WearMessage = { path: String(path), payload: parseWearPayload(String(json)), nodeId: WATCH_NODE_ID }
|
||||
for (const listener of Array.from(this.messageListeners)) {
|
||||
try { listener(message) }
|
||||
catch (error) { console.warn('watch message listener failed', error) }
|
||||
}
|
||||
}, () => {
|
||||
const connection = this.getWatchConnection()
|
||||
for (const listener of Array.from(this.connectionListeners)) {
|
||||
try { listener(connection) }
|
||||
catch (error) { console.warn('watch connection listener failed', error) }
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/** Subscribe to watch messages. Registers the native listener on first use. */
|
||||
onMessage(listener: MessageListener): () => void {
|
||||
this.messageListeners.add(listener)
|
||||
this.ensureListener()
|
||||
return () => { this.messageListeners.delete(listener) }
|
||||
}
|
||||
|
||||
/**
|
||||
* Subscribe to the watch's availability; the current value is delivered
|
||||
* immediately. Also fires when the watch app comes to the front with the
|
||||
* value unchanged, which is what prompts WearRemote to push it fresh state.
|
||||
*/
|
||||
onWatchConnection(listener: ConnectionListener): () => void {
|
||||
this.connectionListeners.add(listener)
|
||||
this.ensureListener()
|
||||
listener(this.getWatchConnection())
|
||||
return () => { this.connectionListeners.delete(listener) }
|
||||
}
|
||||
|
||||
getWatchConnection(): WearWatchConnection {
|
||||
const reachable = Boolean(this.native()?.isWatchAppAvailable())
|
||||
return { reachable, watchName: reachable ? WATCH_NAME : '' }
|
||||
}
|
||||
|
||||
/** WatchConnectivity pushes changes; there is nothing to re-query. */
|
||||
refreshWatchNodes(): void {}
|
||||
|
||||
/** Mirror the dashboard state; unchanged states are dropped natively unless `force`. */
|
||||
publishState(state: Record<string, unknown>, force = false): void {
|
||||
this.native()?.publishStateForce(JSON.stringify(state), force)
|
||||
}
|
||||
|
||||
/**
|
||||
* Send an event to the watch. A suspended app misses live messages, so all
|
||||
* but streaming snapshots also stay behind for its next wake: that is how a
|
||||
* reply that finished with the wrist down still reaches the Assistant screen.
|
||||
*/
|
||||
sendEvent(payload: Record<string, unknown>): void {
|
||||
const sticky = !(payload.type === 'assistant' && payload.phase === 'streaming')
|
||||
this.native()?.sendEventSticky(JSON.stringify(payload), sticky)
|
||||
}
|
||||
|
||||
/** Send a live message on any phone -> watch path; dropped if the app isn't in front. */
|
||||
sendToWatch(path: string, payload: Record<string, unknown>): void {
|
||||
this.native()?.sendToWatchJson(path, JSON.stringify(payload))
|
||||
}
|
||||
|
||||
/** Acknowledge a watch message; `seq` echoes the watch's sequence number. */
|
||||
sendAck(_nodeId: string, seq: number, ok: boolean, message = ''): void {
|
||||
this.native()?.sendAckOkJsReadyMessage(seq, ok, true, message)
|
||||
}
|
||||
}
|
||||
|
||||
export const wearBridge = new WearBridge()
|
||||
@@ -9,12 +9,47 @@
|
||||
* Data Layer is part of it), so the rest of the app never has to care.
|
||||
*/
|
||||
import { Utils } from "@nativescript/core";
|
||||
import { WEAR_PATHS, parseWearPayload, type WearMessage, type WearWatchConnection } from "./wear-bridge-types";
|
||||
|
||||
export { WEAR_PATHS, type WearMessage, type WearWatchConnection };
|
||||
|
||||
declare const com: any;
|
||||
|
||||
/** Message paths shared with the watch app (wear/app/.../Protocol.kt). */
|
||||
export const WEAR_PATHS = {
|
||||
/** Watch -> phone: a ring-style gesture. */
|
||||
input: "/faceclaw/input",
|
||||
/** Watch -> phone: a finger landed on the pad (the ring-press ahead of a gesture); never acked. */
|
||||
press: "/faceclaw/press",
|
||||
/** Watch -> phone: a shell command (launch app, wake, lock, ...). */
|
||||
command: "/faceclaw/command",
|
||||
/** Watch -> phone: a text query for the assistant. */
|
||||
assistant: "/faceclaw/assistant",
|
||||
/** Watch -> phone: text to type into the foreground app. */
|
||||
text: "/faceclaw/text",
|
||||
/** Watch -> phone: please re-publish the state item. */
|
||||
stateRequest: "/faceclaw/state/request",
|
||||
/** Watch -> phone: the watch's own battery ({battery, charging}); never acked. */
|
||||
battery: "/faceclaw/battery",
|
||||
/** Phone -> watch: please report the watch battery (answered even while the watch app is closed). */
|
||||
batteryRequest: "/faceclaw/battery/request",
|
||||
/** Phone -> watch: reply to any of the above. */
|
||||
ack: "/faceclaw/ack",
|
||||
/** Phone -> watch: assistant activity, alerts, voice-dialog transcripts. */
|
||||
event: "/faceclaw/event",
|
||||
/** Phone -> watch Data Layer item: the mirrored dashboard state. */
|
||||
state: "/faceclaw/state",
|
||||
} as const;
|
||||
|
||||
export type WearMessage = {
|
||||
path: string;
|
||||
/** Parsed JSON payload ({} when the watch sent none or it was malformed). */
|
||||
payload: Record<string, unknown>;
|
||||
nodeId: string;
|
||||
};
|
||||
|
||||
export type WearWatchConnection = {
|
||||
reachable: boolean;
|
||||
watchName: string;
|
||||
};
|
||||
|
||||
type MessageListener = (message: WearMessage) => void;
|
||||
type ConnectionListener = (connection: WearWatchConnection) => void;
|
||||
|
||||
@@ -56,7 +91,7 @@ class WearBridge {
|
||||
onMessage: (path: string, json: string, nodeId: string) => {
|
||||
const message: WearMessage = {
|
||||
path: String(path),
|
||||
payload: parseWearPayload(String(json)),
|
||||
payload: parsePayload(String(json)),
|
||||
nodeId: String(nodeId),
|
||||
};
|
||||
for (const listener of Array.from(this.messageListeners)) {
|
||||
@@ -142,4 +177,13 @@ class WearBridge {
|
||||
}
|
||||
}
|
||||
|
||||
function parsePayload(json: string): Record<string, unknown> {
|
||||
try {
|
||||
const parsed = JSON.parse(json);
|
||||
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
|
||||
} catch {
|
||||
return {};
|
||||
}
|
||||
}
|
||||
|
||||
export const wearBridge = new WearBridge();
|
||||
@@ -18,6 +18,7 @@ import {
|
||||
} from "~/assistant/models";
|
||||
import { isLocalModelReady } from "../native/local-llm";
|
||||
import { normalizeWhisperServerUrl } from "../native/whisper-server-stt";
|
||||
import { TRANSCRIPTION_LANGUAGES, resolveTranscriptionLanguage, type TranscriptionLanguage } from "../native/transcription-language";
|
||||
import { normalizeOpenAiCompatibleUrl } from "../native/openai-chat";
|
||||
import { isValidSpotifyClientId, SPOTIFY_CLIENT_ID_KEY } from "../native/spotify-auth";
|
||||
import { drawRightValueMenuItem, drawToggleMenuItem, MenuItem, openModalMenu } from "./menu";
|
||||
@@ -148,6 +149,39 @@ export class ConfigSettingBoolean<TId extends string = string> extends ConfigSet
|
||||
}
|
||||
}
|
||||
|
||||
const appFullscreenSettings = new Map<string, ConfigSettingBoolean>();
|
||||
|
||||
/** A user choice independent of an app's own temporary immersive mode. */
|
||||
export function appFullscreenSetting(appId: string): ConfigSettingBoolean {
|
||||
let setting = appFullscreenSettings.get(appId);
|
||||
if (!setting) {
|
||||
setting = new ConfigSettingBoolean({
|
||||
id: `app-fullscreen-${appId}`, label: "Full screen",
|
||||
storageKey: `display.fullscreen.${appId}`, defaultValue: false,
|
||||
reportInAnalytics: false,
|
||||
});
|
||||
appFullscreenSettings.set(appId, setting);
|
||||
}
|
||||
return setting;
|
||||
}
|
||||
|
||||
const appKeepAwakeSettings = new Map<string, ConfigSettingBoolean>();
|
||||
|
||||
/** Independent of full screen; applies only while this app is visible. */
|
||||
export function appKeepAwakeSetting(appId: string): ConfigSettingBoolean {
|
||||
let setting = appKeepAwakeSettings.get(appId);
|
||||
if (!setting) {
|
||||
setting = new ConfigSettingBoolean({
|
||||
id: `app-keep-awake-${appId}`, label: "Keep screen awake",
|
||||
description: "Prevent automatic sleep while this app is visible, in any display mode.",
|
||||
storageKey: `display.keepAwake.${appId}`, defaultValue: false,
|
||||
reportInAnalytics: false,
|
||||
});
|
||||
appKeepAwakeSettings.set(appId, setting);
|
||||
}
|
||||
return setting;
|
||||
}
|
||||
|
||||
type ConfigSettingEnumOptions<TValue extends string, TId extends string> = ConfigSettingOptions<TValue, TId> & {
|
||||
values: readonly TValue[];
|
||||
normalize?: (value: string | null | undefined) => TValue;
|
||||
@@ -298,7 +332,7 @@ export const glassesBatteryVisibilitySetting = batteryVisibilitySetting(
|
||||
export const ringBatteryVisibilitySetting = batteryVisibilitySetting(
|
||||
"ringBatteryVisibility", "R1", "display.battery.ringVisibility",
|
||||
);
|
||||
/** The watch; the indicator only exists while a watch is reachable. */
|
||||
/** The Wear OS watch; the indicator only exists while a watch is reachable. */
|
||||
export const watchBatteryVisibilitySetting = batteryVisibilitySetting(
|
||||
"watchBatteryVisibility", "Watch", "display.battery.watchVisibility",
|
||||
);
|
||||
@@ -711,7 +745,7 @@ export const mirrorTouchSetting = new ConfigSettingBoolean({
|
||||
"Let touches on the phone's mirror act on the glasses UI: tap selects what it lands on, double-tap goes back, a hold opens the menu, swipes navigate.",
|
||||
});
|
||||
|
||||
// Watch remote (app/g2/wear-remote.ts, wear/, apple-watch/). All three are read on
|
||||
// Wear OS watch remote (app/g2/wear-remote.ts, wear/). All three are read on
|
||||
// every watch message, so a change applies immediately.
|
||||
export const watchRemoteEnabledSetting = new ConfigSettingBoolean({
|
||||
id: "watch-remote-enabled",
|
||||
@@ -719,7 +753,7 @@ export const watchRemoteEnabledSetting = new ConfigSettingBoolean({
|
||||
storageKey: "watch.remoteEnabled",
|
||||
defaultValue: true,
|
||||
description:
|
||||
"Accept input from the Faceclaw watch app: spatial swipes, taps, holds, crown, voice queries and app commands. The ring's scheme is unaffected. Turn off to ignore the watch.",
|
||||
"Accept input from the Faceclaw Wear OS app: spatial swipes, taps, holds, crown, voice queries and app commands. The ring's scheme is unaffected. Turn off to ignore the watch.",
|
||||
});
|
||||
|
||||
export const watchCanUnlockSetting = new ConfigSettingBoolean({
|
||||
@@ -731,7 +765,6 @@ export const watchCanUnlockSetting = new ConfigSettingBoolean({
|
||||
"Let the watch unlock the glasses' lock screen (which otherwise waits for the phone to be unlocked). Your watch is on your wrist; turn this off if you would rather it stay a phone-only unlock.",
|
||||
});
|
||||
|
||||
// Wear OS only: the Apple Watch's crown doesn't reach the app, so iOS doesn't offer this.
|
||||
export const watchCrownClockwiseNextSetting = new ConfigSettingBoolean({
|
||||
id: "watch-crown-clockwise-next",
|
||||
label: "Clockwise crown = next",
|
||||
@@ -741,26 +774,6 @@ export const watchCrownClockwiseNextSetting = new ConfigSettingBoolean({
|
||||
"Choose which crown direction moves to the next item. Off: clockwise moves to the previous item. On: clockwise moves to the next item.",
|
||||
});
|
||||
|
||||
// Apple Watch only: Wear OS has no sounds, and keeps its vibration setting on the watch.
|
||||
// The watch reads these from the mirrored state (apple-watch/Faceclaw/WatchPrefs.swift).
|
||||
export const watchVibrateOnInputSetting = new ConfigSettingBoolean({
|
||||
id: "watch-vibrate-on-input",
|
||||
label: "Vibrate on input",
|
||||
storageKey: "watch.vibrateOnInput",
|
||||
defaultValue: true,
|
||||
description:
|
||||
"Adds a slight vibration with each watch input",
|
||||
});
|
||||
|
||||
export const watchSoundEffectsSetting = new ConfigSettingBoolean({
|
||||
id: "watch-sound-effects",
|
||||
label: "Sound effects",
|
||||
storageKey: "watch.soundEffects",
|
||||
defaultValue: false,
|
||||
description:
|
||||
"On: each input gets its own watchOS feedback, a sound with a vibration (watchOS can't play one alone, so this vibrates even with Vibrate on input off). Off: a light tap for every input. Only Silent Mode on the watch guarantees no sound.",
|
||||
});
|
||||
|
||||
export const watchMirrorAssistantSetting = new ConfigSettingBoolean({
|
||||
id: "watch-mirror-assistant",
|
||||
label: "Mirror assistant to watch",
|
||||
@@ -1168,9 +1181,26 @@ export const whisperServerModelSetting = new ConfigSettingString({
|
||||
description: "Model id sent to the Whisper server. Leave empty to use the first model the server lists.",
|
||||
});
|
||||
|
||||
export const voiceLanguageSetting = new ConfigSettingEnum<TranscriptionLanguage>({
|
||||
id: "voice-language",
|
||||
label: "Transcription language",
|
||||
storageKey: "voice.language",
|
||||
defaultValue: "default",
|
||||
values: ["default", "auto", ...(Object.keys(TRANSCRIPTION_LANGUAGES) as (keyof typeof TRANSCRIPTION_LANGUAGES)[])],
|
||||
formatValue: (value) => value === "default" ? "Provider default"
|
||||
: value === "auto" ? "Auto-detect" : TRANSCRIPTION_LANGUAGES[value],
|
||||
description: "Spoken language for OpenAI, on-device Whisper and other cloud transcription providers. " +
|
||||
"Provider default preserves English for on-device Whisper and auto-detection for cloud providers, with the server's own language below. " +
|
||||
"On-device Whisper needs the multilingual model for auto-detection or languages other than English. Moonshine remains English-only.",
|
||||
});
|
||||
|
||||
export function getVoiceTranscriptionLanguage(provider: VoiceProvider): string {
|
||||
return resolveTranscriptionLanguage(voiceLanguageSetting.get(), provider, whisperServerLanguageSetting.get());
|
||||
}
|
||||
|
||||
export const whisperServerLanguageSetting = new ConfigSettingString({
|
||||
id: "whisper-server-language",
|
||||
label: "Whisper language",
|
||||
label: "Whisper server language",
|
||||
storageKey: "voice.whisperServerLanguage",
|
||||
defaultValue: "",
|
||||
editorTitle: "Language code, e.g. en or sk (empty: auto)",
|
||||
@@ -1178,7 +1208,7 @@ export const whisperServerLanguageSetting = new ConfigSettingString({
|
||||
formatValue: (value) => value || "Auto-detect",
|
||||
validate: (value) => (!value.trim() || /^[a-z]{2,3}$/i.test(value.trim()) ? null : "Use a language code like en, sk or cs."),
|
||||
description:
|
||||
"Spoken language for the Whisper server. Leave empty to auto-detect; a wrong fixed language makes Whisper translate into it instead of transcribing.",
|
||||
"Spoken language for the Whisper server when Transcription language is Provider default. Leave empty to auto-detect.",
|
||||
});
|
||||
|
||||
export const whisperServerApiKeySetting = new ConfigSettingString({
|
||||
|
||||
@@ -89,6 +89,7 @@ import {
|
||||
toggleSettingMenuItem,
|
||||
useMicControlSetting,
|
||||
voiceProviderSetting,
|
||||
voiceLanguageSetting,
|
||||
screenTimeoutSetting,
|
||||
wakeToLastAppSetting,
|
||||
wakeWordActionSetting,
|
||||
@@ -96,8 +97,6 @@ import {
|
||||
watchCrownClockwiseNextSetting,
|
||||
watchMirrorAssistantSetting,
|
||||
watchRemoteEnabledSetting,
|
||||
watchSoundEffectsSetting,
|
||||
watchVibrateOnInputSetting,
|
||||
} from "../dashboard-settings";
|
||||
import { wearBridge } from "../../native/wear-bridge";
|
||||
import { openSettingsSubMenu, SettingsPanelLayer, type SettingsSection } from "./settings-panel";
|
||||
@@ -146,9 +145,11 @@ function settingsSections(): SettingsSection[] {
|
||||
items: [
|
||||
enumSettingMenuItem(wakeWordActionSetting),
|
||||
enumSettingMenuItem(voiceProviderSetting),
|
||||
enumSettingMenuItem(voiceLanguageSetting),
|
||||
...whisperServerMenuItems(),
|
||||
asrModelMenuItem("moonshine"),
|
||||
asrModelMenuItem("whisper-base-en"),
|
||||
asrModelMenuItem("whisper-base"),
|
||||
],
|
||||
},
|
||||
{
|
||||
@@ -214,16 +215,11 @@ function settingsSections(): SettingsSection[] {
|
||||
},
|
||||
{
|
||||
label: "Watch",
|
||||
// Watch remote (wear/, apple-watch/); the status line above the items says
|
||||
// whether a watch running the companion app is currently reachable.
|
||||
// Wear OS remote (wear/); the status line above the items says whether
|
||||
// a watch running the companion app is currently reachable.
|
||||
items: [
|
||||
toggleSettingMenuItem(watchRemoteEnabledSetting),
|
||||
...(global.isIOS ? [
|
||||
toggleSettingMenuItem(watchVibrateOnInputSetting),
|
||||
toggleSettingMenuItem(watchSoundEffectsSetting),
|
||||
] : [
|
||||
toggleSettingMenuItem(watchCrownClockwiseNextSetting),
|
||||
]),
|
||||
toggleSettingMenuItem(watchCrownClockwiseNextSetting),
|
||||
toggleSettingMenuItem(watchCanUnlockSetting),
|
||||
toggleSettingMenuItem(watchMirrorAssistantSetting),
|
||||
],
|
||||
@@ -282,12 +278,17 @@ function settingsSections(): SettingsSection[] {
|
||||
},
|
||||
];
|
||||
if (!global.isIOS) return sections;
|
||||
const deferred = new Set(["Watch"]);
|
||||
return sections.map(section => {
|
||||
if (section.label === "Developer") return { ...section, items: [enumSettingMenuItem(ringConnectionModeSetting),
|
||||
toggleSettingMenuItem(showBleBandwidthSetting)] };
|
||||
// No downloadable on-device models: iOS's on-device option is Apple's recognizer.
|
||||
if (section.label === "Voice") return { label: "Voice", items: [enumSettingMenuItem(wakeWordActionSetting),
|
||||
enumSettingMenuItem(voiceProviderSetting), toggleSettingMenuItem(saveTranscribeAudioSetting), ...whisperServerMenuItems()] };
|
||||
enumSettingMenuItem(voiceProviderSetting), enumSettingMenuItem(voiceLanguageSetting), toggleSettingMenuItem(saveTranscribeAudioSetting), ...whisperServerMenuItems()] };
|
||||
if (deferred.has(section.label)) return { label: section.label, items: [{
|
||||
label: "Not available on iOS yet", disabled: true, onSelect: () => {},
|
||||
description: `${section.label} integration has not been ported to iOS.`,
|
||||
}] };
|
||||
if (section.label === "Display") return { ...section, items: section.items.filter(item =>
|
||||
item.label !== screenTimeoutSetting.label) };
|
||||
return section;
|
||||
@@ -365,7 +366,7 @@ function batteryIndicatorsMenuItem(): MenuItem {
|
||||
return {
|
||||
label: "Battery indicators",
|
||||
description:
|
||||
"Top-bar battery indicators for the phone, watch, glasses, and ring: their style, and whether each shows always, only when low, or never.",
|
||||
"Top-bar battery indicators for the phone, Wear OS watch, glasses, and ring: their style, and whether each shows always, only when low, or never.",
|
||||
onSelect: (ctx) => {
|
||||
openSettingsSubMenu(ctx, "Battery indicators", [
|
||||
enumSettingMenuItem(batteryDisplayModeSetting),
|
||||
@@ -608,21 +609,12 @@ function renderWatchStatus(args: { image: GrayImage; x: number; y: number; width
|
||||
const font = getDefaultSmallFont();
|
||||
let status: string;
|
||||
if (!wearBridge.isAvailable()) {
|
||||
status = global.isIOS
|
||||
? "This device can't pair with an Apple Watch."
|
||||
: "Google Play services is unavailable on this phone, so no watch can connect.";
|
||||
status = "Google Play services is unavailable on this phone, so no watch can connect.";
|
||||
} else {
|
||||
const connection = wearBridge.getWatchConnection();
|
||||
if (global.isIOS) {
|
||||
// iOS only says whether the app is installed; it may not be running.
|
||||
status = connection.reachable
|
||||
? "The Faceclaw app is installed on your Apple Watch."
|
||||
: "No watch connected. Install the Faceclaw watch app (apple-watch/ in the source tree) on an Apple Watch paired with this iPhone.";
|
||||
} else {
|
||||
status = connection.reachable
|
||||
? `Connected to ${connection.watchName || "a watch"}.`
|
||||
: "No watch connected. Install the Faceclaw watch app (wear/ in the source tree) on a Wear OS watch paired with this phone.";
|
||||
}
|
||||
status = connection.reachable
|
||||
? `Connected to ${connection.watchName || "a watch"}.`
|
||||
: "No watch connected. Install the Faceclaw watch app (wear/ in the source tree) on a Wear OS watch paired with this phone.";
|
||||
}
|
||||
const lines = wrapText(font, status, width);
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
|
||||
+4
-4
@@ -2,9 +2,9 @@ import type { RingInput } from "../g2/ring-input";
|
||||
|
||||
/**
|
||||
* Where an input came from. The ring and the glasses' arms are the stock
|
||||
* sources; "watch" is the watch remote (Wear OS or Apple Watch), which
|
||||
* components may treat with a richer scheme (see isWatchInput) — the ring's
|
||||
* semantics are never changed by it.
|
||||
* sources; "watch" is the Wear OS remote, which components may treat with a
|
||||
* richer scheme (see isWatchInput) — the ring's semantics are never changed
|
||||
* by it.
|
||||
*/
|
||||
export type InputSource = "ring" | "left-arm" | "right-arm" | "watch";
|
||||
|
||||
@@ -80,7 +80,7 @@ export function makeInputEvent(payload: InputEventPayload): InputEvent {
|
||||
return { ...payload, timestampMs: Date.now() };
|
||||
}
|
||||
|
||||
/** True for input from the watch remote (any type that carries a source). */
|
||||
/** True for input from the Wear OS remote (any type that carries a source). */
|
||||
export function isWatchInput(event: InputEvent): boolean {
|
||||
return "source" in event && event.source === "watch";
|
||||
}
|
||||
|
||||
@@ -2,7 +2,7 @@ import { getDefaultSmallFont } from "../graphics/ui-fonts";
|
||||
import { GrayImage } from "../graphics/image";
|
||||
import { truncateText } from "../graphics/textwrap";
|
||||
import { ALL_NOTIFICATIONS, readActiveNotifications } from "../native/notification-icons";
|
||||
import { readNotificationSources, setNotificationSourceEnabled, shouldShowNotificationOnGlasses } from "../native/notification-sources";
|
||||
import { newNotificationAppsEnabledByDefault, setNewNotificationAppsEnabledByDefault, setAllNotificationSourcesEnabled, readNotificationSources, setNotificationSourceEnabled, shouldShowNotificationOnGlasses } from "../native/notification-sources";
|
||||
import { type InputEvent } from "./gestures";
|
||||
import { type Layer, type LayerContext, type PaintBelow } from "./layers";
|
||||
import { drawToggleMenuItem, MenuLayer, type MenuItem } from "./menu";
|
||||
@@ -11,14 +11,26 @@ import { drawToggleMenuItem, MenuLayer, type MenuItem } from "./menu";
|
||||
export class NotificationFilterLayer implements Layer {
|
||||
private menu: MenuLayer | null = null;
|
||||
private menuWidth = 0;
|
||||
/** The package behind each current row, parallel to the menu's items. */
|
||||
/** Stable row keys, including controls, parallel to the menu's items. */
|
||||
private packages: string[] = [];
|
||||
|
||||
private currentMenu(ctx: LayerContext): MenuLayer {
|
||||
readActiveNotifications(ALL_NOTIFICATIONS);
|
||||
const sources = readNotificationSources().sort((a, b) =>
|
||||
a.appName.localeCompare(b.appName) || a.packageName.localeCompare(b.packageName));
|
||||
const items: MenuItem[] = sources.map((source) => ({
|
||||
const items: MenuItem[] = [{
|
||||
label: "New apps enabled by default",
|
||||
onSelect: () => setNewNotificationAppsEnabledByDefault(!newNotificationAppsEnabledByDefault()),
|
||||
render: ({ image, x, y, width, selected }) => {
|
||||
const font = getDefaultSmallFont();
|
||||
drawToggleMenuItem(image, font, x, y, width,
|
||||
truncateText(font, "New apps enabled by default", width - 48), newNotificationAppsEnabledByDefault(), selected);
|
||||
},
|
||||
}, {
|
||||
label: "Enable all", onSelect: () => setAllNotificationSourcesEnabled(true),
|
||||
}, {
|
||||
label: "Disable all", onSelect: () => setAllNotificationSourcesEnabled(false),
|
||||
}, ...sources.map<MenuItem>((source) => ({
|
||||
label: source.appName,
|
||||
onSelect: () => setNotificationSourceEnabled(source, !shouldShowNotificationOnGlasses(source.packageName)),
|
||||
render: ({ image, x, y, width, selected }) => {
|
||||
@@ -26,11 +38,11 @@ export class NotificationFilterLayer implements Layer {
|
||||
drawToggleMenuItem(image, font, x, y, width, truncateText(font, source.appName, width - 48),
|
||||
shouldShowNotificationOnGlasses(source.packageName), selected);
|
||||
},
|
||||
}));
|
||||
if (!items.length) items.push({ label: "No notification sources discovered yet.", disabled: true, onSelect: () => {} });
|
||||
}))];
|
||||
if (!sources.length) items.push({ label: "No notification sources discovered yet.", disabled: true, onSelect: () => {} });
|
||||
const selectedPackage = this.menu?.selectedIndex != null ? this.packages[this.menu.selectedIndex] : undefined;
|
||||
const index = sources.findIndex((source) => source.packageName === selectedPackage);
|
||||
this.packages = sources.map((source) => source.packageName);
|
||||
this.packages = ["default", "enable-all", "disable-all", ...sources.map((source) => `source:${source.packageName}`)];
|
||||
const index = selectedPackage === undefined ? 0 : this.packages.indexOf(selectedPackage);
|
||||
|
||||
const width = ctx.stack.getBaseSize().width;
|
||||
if (!this.menu || width !== this.menuWidth) {
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../../graphics/image";
|
||||
import {
|
||||
appSwitcherPositionSetting,
|
||||
appFullscreenSetting,
|
||||
type AppSwitcherPosition,
|
||||
displayLayoutSetting,
|
||||
type DisplayLayout,
|
||||
@@ -118,7 +119,7 @@ export function setAppImmersive(appId: string, immersive: boolean): boolean {
|
||||
}
|
||||
|
||||
export function isImmersive(appId?: string): boolean {
|
||||
return appId !== undefined && immersiveApps.has(appId);
|
||||
return appId !== undefined && (immersiveApps.has(appId) || appFullscreenSetting(appId).get());
|
||||
}
|
||||
|
||||
/** Whether an app's windows span the panel's whole width: Full Screen, or immersive. */
|
||||
|
||||
+65
-11
@@ -31,6 +31,9 @@ import type { AssistantContext } from "../../assistant/types";
|
||||
import { SingleNotificationLayer } from "../notifications";
|
||||
import {
|
||||
anthropicApiKeySetting,
|
||||
appFullscreenSetting,
|
||||
appKeepAwakeSetting,
|
||||
toggleSettingMenuItem,
|
||||
assistantHermesKeySetting,
|
||||
assistantHermesUrlSetting,
|
||||
assistantBackendSetting,
|
||||
@@ -94,7 +97,8 @@ import type { AppSwitcherPosition } from "../dashboard-settings";
|
||||
* Input flow: every event enters via receiveInput. The shell consumes
|
||||
* everything while the sidebar or a shell overlay has focus and forwards the
|
||||
* rest to the focused window. Long-press opens the shell-owned system menu
|
||||
* (Focus app switcher, Voice input, Brightness, Close window, Debug) without reaching the
|
||||
* (Focus app switcher, Voice input, Brightness, Close current app, Close all apps,
|
||||
* Debug) without reaching the
|
||||
* app, so the shell keeps working when a window's handler hangs; a window
|
||||
* that claims long-press for a move of its own gets it forwarded instead, and
|
||||
* holding the press past the escape threshold still opens the system menu.
|
||||
@@ -109,7 +113,7 @@ export type ShellWindow = {
|
||||
title: string;
|
||||
/** Compositor surface this window renders to; configured at connect / launch. */
|
||||
surfaceId: string;
|
||||
/** Whether the system menu offers Close window (the launcher is pinned). */
|
||||
/** Whether the system menu can close this window (the launcher is pinned). */
|
||||
closeable: boolean;
|
||||
/**
|
||||
* True when tap-then-hold currently opens the window's own context menu
|
||||
@@ -222,6 +226,10 @@ export type ShellConfig = {
|
||||
* after the shell paint that found it.
|
||||
*/
|
||||
onSwitcherBarHeightChanged?: () => void;
|
||||
/** A per-app full-screen choice changed the viewport and compositor geometry. */
|
||||
onWindowLayoutChanged?: () => void;
|
||||
/** An app's keep-awake preference must not keep the lock screen awake. */
|
||||
isLocked?: () => boolean;
|
||||
/**
|
||||
* The Notifications app's window, opened in the background (neither
|
||||
* foregrounded nor focused) unless it is open already, for the switcher
|
||||
@@ -655,6 +663,12 @@ class Shell {
|
||||
if (window) this.closeWindow(window.windowId);
|
||||
}
|
||||
|
||||
/** Snapshot ids: close callbacks may remove themselves or other windows. */
|
||||
closeAllWindows(): void {
|
||||
const ids = this.windows.filter(window => window.closeable).map(window => window.windowId);
|
||||
for (const id of ids) this.closeWindow(id);
|
||||
}
|
||||
|
||||
getWindows(): readonly ShellWindow[] {
|
||||
return this.windows;
|
||||
}
|
||||
@@ -866,7 +880,9 @@ class Shell {
|
||||
// A foreground window that is playing video holds it off the same way.
|
||||
const foreground = this.foregroundWindow();
|
||||
if (this.activeVoiceLayer || this.activeKeyboardLayer || this.assistantSession?.isTurnActive() ||
|
||||
foreground?.isVoiceCapturing?.() || foreground?.keepsScreenOn?.()) {
|
||||
foreground?.isVoiceCapturing?.() || foreground?.keepsScreenOn?.() ||
|
||||
(foreground?.closeable && !this.config.isLocked?.() &&
|
||||
appKeepAwakeSetting(foreground.appId).get())) {
|
||||
this.lastInputAtMs = nowMs;
|
||||
return false;
|
||||
}
|
||||
@@ -1073,6 +1089,12 @@ class Shell {
|
||||
if (this.activeVoiceLayer || !this.stack.isAtBase()) {
|
||||
return { shell: true, window: false };
|
||||
}
|
||||
// The switcher owns its menu even when the selected app uses a hold
|
||||
// for a game move or voice capture.
|
||||
if (this.focus === "sidebar") {
|
||||
this.openEscapeMenu();
|
||||
return { shell: true, window: false };
|
||||
}
|
||||
const window = this.foregroundWindow();
|
||||
if (!window) {
|
||||
return { shell: true, window: false };
|
||||
@@ -1082,10 +1104,6 @@ class Shell {
|
||||
return { shell: true, window: false };
|
||||
}
|
||||
if (!window.holdToTalk) this.startEscapeMenuTimer();
|
||||
if (this.focus === "sidebar") {
|
||||
this.focus = "window";
|
||||
window.onFocus?.(this.lastInput);
|
||||
}
|
||||
// The window owns frameId from here (render or explicit finish).
|
||||
await window.handleInput(event, frameId);
|
||||
return { shell: true, window: true };
|
||||
@@ -1096,6 +1114,10 @@ class Shell {
|
||||
// first), which answers with its own menu or asks for the system menu
|
||||
// when it has none.
|
||||
if (event.type === "short-then-long-press") {
|
||||
if (this.focus === "sidebar" && !this.activeVoiceLayer && this.stack.isAtBase()) {
|
||||
this.openEscapeMenu();
|
||||
return { shell: true, window: false };
|
||||
}
|
||||
const window = this.foregroundWindow();
|
||||
if (window?.holdToTalk) {
|
||||
this.openEscapeMenu();
|
||||
@@ -1913,7 +1935,7 @@ class Shell {
|
||||
|
||||
/**
|
||||
* The system/escape menu: the entries every window shares (Focus app
|
||||
* switcher, Voice input, Brightness, Close window) plus Debug. Shell-owned and
|
||||
* switcher, Voice input, Brightness, Close current app, Close all apps) plus Debug. Shell-owned and
|
||||
* shell-drawn (never the app's), so an unresponsive app can always be
|
||||
* closed. It opens for long-press (over the app's own menu too), after an
|
||||
* extended hold in a window that claims long-press, and on a window's
|
||||
@@ -1926,16 +1948,16 @@ class Shell {
|
||||
const items: MenuItem[] = [];
|
||||
if (foreground.closeable) {
|
||||
items.push({
|
||||
label: "Close window",
|
||||
label: "Close current app",
|
||||
onSelect: (ctx) => {
|
||||
// Pop the menu first (its onRemoved returns focus to the sidebar),
|
||||
// then close the window the menu was opened over.
|
||||
ctx.stack.pop();
|
||||
this.closeForegroundWindow();
|
||||
this.closeWindow(foreground.windowId);
|
||||
},
|
||||
});
|
||||
}
|
||||
// Close window sits first but the menu opens on Focus app switcher, so a
|
||||
// Close current app sits first but the menu opens on Focus app switcher, so a
|
||||
// reflexive tap never closes the window.
|
||||
const initialSelection = items.length;
|
||||
items.push(
|
||||
@@ -1959,6 +1981,38 @@ class Shell {
|
||||
},
|
||||
}]),
|
||||
);
|
||||
items.push({
|
||||
label: "Close all apps",
|
||||
disabled: () => !this.windows.some(window => window.closeable),
|
||||
onSelect: (ctx) => {
|
||||
ctx.stack.pop();
|
||||
this.closeAllWindows();
|
||||
},
|
||||
});
|
||||
if (foreground.closeable) {
|
||||
const fullscreen = appFullscreenSetting(foreground.appId);
|
||||
items.push({
|
||||
label: fullscreen.get() ? "Exit full screen" : "Enter full screen",
|
||||
description: "Use the whole display for this app.",
|
||||
onSelect: (ctx) => {
|
||||
ctx.stack.pop();
|
||||
if (!this.windows.some(window => window.windowId === foreground.windowId)) return;
|
||||
fullscreen.set(!fullscreen.get());
|
||||
this.noteUserActivity();
|
||||
this.config.onWindowLayoutChanged?.();
|
||||
this.focusWindow(foreground.windowId);
|
||||
this.config.requestShellRender();
|
||||
},
|
||||
});
|
||||
items.push(toggleSettingMenuItem(appKeepAwakeSetting(foreground.appId), {
|
||||
onChange: (ctx) => {
|
||||
ctx.stack.pop();
|
||||
this.noteUserActivity();
|
||||
this.focusWindow(foreground.windowId);
|
||||
this.config.requestShellRender();
|
||||
},
|
||||
}));
|
||||
}
|
||||
if (brightnessSetting.get() !== "auto") {
|
||||
items.push({
|
||||
label: "Brightness",
|
||||
|
||||
@@ -9,7 +9,7 @@ import type { WorkerAppReply } from "./shell/worker-window";
|
||||
* The window context menu, opened by tap-then-hold: an app's own menu,
|
||||
* holding its app-specific actions. The shell's system menu (long-press)
|
||||
* carries the entries every window shares — Focus app switcher, Voice input,
|
||||
* Close window — so an app with nothing of its own to offer has no menu of
|
||||
* Close current app, Close all apps — so an app with nothing of its own to offer has no menu of
|
||||
* its own: tap-then-hold then opens the system menu in its place, so both
|
||||
* gestures land on the same menu. The system menu is also the safety net:
|
||||
* shell-owned, so an unresponsive app can always be closed (a window that
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
// Settings shared by every target of the watch project.
|
||||
//
|
||||
// The watch app is tied to the phone app by bundle ID: its own must begin with
|
||||
// the phone app's, and WKCompanionAppBundleIdentifier must equal it, or
|
||||
// WatchConnectivity has no counterpart. Local.xcconfig (not checked in) overrides
|
||||
// this and sets the signing team; build_apple_watch.sh writes it from build_paths.sh.
|
||||
FACECLAW_IOS_BUNDLE_ID = com.faceclaw.app
|
||||
|
||||
SDKROOT = watchos
|
||||
SUPPORTED_PLATFORMS = watchos watchsimulator
|
||||
TARGETED_DEVICE_FAMILY = 4
|
||||
// Observation (@Observable) needs watchOS 10: Series 6, SE 2, Ultra and later.
|
||||
WATCHOS_DEPLOYMENT_TARGET = 10.0
|
||||
SWIFT_VERSION = 5.0
|
||||
CODE_SIGN_STYLE = Automatic
|
||||
CURRENT_PROJECT_VERSION = 1
|
||||
MARKETING_VERSION = 1.0
|
||||
ENABLE_USER_SCRIPT_SANDBOXING = YES
|
||||
ALWAYS_SEARCH_USER_PATHS = NO
|
||||
|
||||
#include? "Local.xcconfig"
|
||||
@@ -1,315 +0,0 @@
|
||||
// !$*UTF8*$!
|
||||
{
|
||||
archiveVersion = 1;
|
||||
classes = {
|
||||
};
|
||||
objectVersion = 77;
|
||||
objects = {
|
||||
|
||||
/* Begin PBXContainerItemProxy section */
|
||||
FC0000000000000000000041 /* PBXContainerItemProxy */ = {
|
||||
isa = PBXContainerItemProxy;
|
||||
containerPortal = FC0000000000000000000001 /* Project object */;
|
||||
proxyType = 1;
|
||||
remoteGlobalIDString = FC0000000000000000000010;
|
||||
remoteInfo = Faceclaw;
|
||||
};
|
||||
/* End PBXContainerItemProxy section */
|
||||
|
||||
/* Begin PBXFileReference section */
|
||||
FC0000000000000000000020 /* Faceclaw.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Faceclaw.app; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
FC0000000000000000000021 /* FaceclawUITests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = FaceclawUITests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
|
||||
FC0000000000000000000022 /* Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Base.xcconfig; sourceTree = "<group>"; };
|
||||
/* End PBXFileReference section */
|
||||
|
||||
/* Begin PBXFileSystemSynchronizedRootGroup section */
|
||||
FC0000000000000000000030 /* Faceclaw */ = {isa = PBXFileSystemSynchronizedRootGroup; path = Faceclaw; sourceTree = "<group>"; };
|
||||
FC0000000000000000000031 /* FaceclawUITests */ = {isa = PBXFileSystemSynchronizedRootGroup; path = FaceclawUITests; sourceTree = "<group>"; };
|
||||
/* End PBXFileSystemSynchronizedRootGroup section */
|
||||
|
||||
/* Begin PBXFrameworksBuildPhase section */
|
||||
FC0000000000000000000050 /* Frameworks */ = {
|
||||
isa = PBXFrameworksBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
FC0000000000000000000051 /* Frameworks */ = {
|
||||
isa = PBXFrameworksBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXFrameworksBuildPhase section */
|
||||
|
||||
/* Begin PBXGroup section */
|
||||
FC0000000000000000000002 = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
FC0000000000000000000022 /* Base.xcconfig */,
|
||||
FC0000000000000000000030 /* Faceclaw */,
|
||||
FC0000000000000000000031 /* FaceclawUITests */,
|
||||
FC0000000000000000000003 /* Products */,
|
||||
);
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
FC0000000000000000000003 /* Products */ = {
|
||||
isa = PBXGroup;
|
||||
children = (
|
||||
FC0000000000000000000020 /* Faceclaw.app */,
|
||||
FC0000000000000000000021 /* FaceclawUITests.xctest */,
|
||||
);
|
||||
name = Products;
|
||||
sourceTree = "<group>";
|
||||
};
|
||||
/* End PBXGroup section */
|
||||
|
||||
/* Begin PBXNativeTarget section */
|
||||
FC0000000000000000000010 /* Faceclaw */ = {
|
||||
isa = PBXNativeTarget;
|
||||
buildConfigurationList = FC0000000000000000000071 /* Build configuration list for PBXNativeTarget "Faceclaw" */;
|
||||
buildPhases = (
|
||||
FC0000000000000000000060 /* Sources */,
|
||||
FC0000000000000000000050 /* Frameworks */,
|
||||
FC0000000000000000000062 /* Resources */,
|
||||
);
|
||||
buildRules = (
|
||||
);
|
||||
dependencies = (
|
||||
);
|
||||
fileSystemSynchronizedGroups = (
|
||||
FC0000000000000000000030 /* Faceclaw */,
|
||||
);
|
||||
name = Faceclaw;
|
||||
productName = Faceclaw;
|
||||
productReference = FC0000000000000000000020 /* Faceclaw.app */;
|
||||
productType = "com.apple.product-type.application";
|
||||
};
|
||||
FC0000000000000000000011 /* FaceclawUITests */ = {
|
||||
isa = PBXNativeTarget;
|
||||
buildConfigurationList = FC0000000000000000000072 /* Build configuration list for PBXNativeTarget "FaceclawUITests" */;
|
||||
buildPhases = (
|
||||
FC0000000000000000000061 /* Sources */,
|
||||
FC0000000000000000000051 /* Frameworks */,
|
||||
FC0000000000000000000063 /* Resources */,
|
||||
);
|
||||
buildRules = (
|
||||
);
|
||||
dependencies = (
|
||||
FC0000000000000000000042 /* PBXTargetDependency */,
|
||||
);
|
||||
fileSystemSynchronizedGroups = (
|
||||
FC0000000000000000000031 /* FaceclawUITests */,
|
||||
);
|
||||
name = FaceclawUITests;
|
||||
productName = FaceclawUITests;
|
||||
productReference = FC0000000000000000000021 /* FaceclawUITests.xctest */;
|
||||
productType = "com.apple.product-type.bundle.ui-testing";
|
||||
};
|
||||
/* End PBXNativeTarget section */
|
||||
|
||||
/* Begin PBXProject section */
|
||||
FC0000000000000000000001 /* Project object */ = {
|
||||
isa = PBXProject;
|
||||
attributes = {
|
||||
BuildIndependentTargetsInParallel = 1;
|
||||
LastSwiftUpdateCheck = 2640;
|
||||
LastUpgradeCheck = 2640;
|
||||
TargetAttributes = {
|
||||
FC0000000000000000000010 = {
|
||||
CreatedOnToolsVersion = 26.4;
|
||||
};
|
||||
FC0000000000000000000011 = {
|
||||
CreatedOnToolsVersion = 26.4;
|
||||
TestTargetID = FC0000000000000000000010;
|
||||
};
|
||||
};
|
||||
};
|
||||
buildConfigurationList = FC0000000000000000000070 /* Build configuration list for PBXProject "Faceclaw" */;
|
||||
developmentRegion = en;
|
||||
hasScannedForEncodings = 0;
|
||||
knownRegions = (
|
||||
en,
|
||||
Base,
|
||||
);
|
||||
mainGroup = FC0000000000000000000002;
|
||||
minimizedProjectReferenceProxies = 1;
|
||||
preferredProjectObjectVersion = 77;
|
||||
productRefGroup = FC0000000000000000000003 /* Products */;
|
||||
projectDirPath = "";
|
||||
projectRoot = "";
|
||||
targets = (
|
||||
FC0000000000000000000010 /* Faceclaw */,
|
||||
FC0000000000000000000011 /* FaceclawUITests */,
|
||||
);
|
||||
};
|
||||
/* End PBXProject section */
|
||||
|
||||
/* Begin PBXResourcesBuildPhase section */
|
||||
FC0000000000000000000062 /* Resources */ = {
|
||||
isa = PBXResourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
FC0000000000000000000063 /* Resources */ = {
|
||||
isa = PBXResourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXResourcesBuildPhase section */
|
||||
|
||||
/* Begin PBXSourcesBuildPhase section */
|
||||
FC0000000000000000000060 /* Sources */ = {
|
||||
isa = PBXSourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
FC0000000000000000000061 /* Sources */ = {
|
||||
isa = PBXSourcesBuildPhase;
|
||||
buildActionMask = 2147483647;
|
||||
files = (
|
||||
);
|
||||
runOnlyForDeploymentPostprocessing = 0;
|
||||
};
|
||||
/* End PBXSourcesBuildPhase section */
|
||||
|
||||
/* Begin PBXTargetDependency section */
|
||||
FC0000000000000000000042 /* PBXTargetDependency */ = {
|
||||
isa = PBXTargetDependency;
|
||||
target = FC0000000000000000000010 /* Faceclaw */;
|
||||
targetProxy = FC0000000000000000000041 /* PBXContainerItemProxy */;
|
||||
};
|
||||
/* End PBXTargetDependency section */
|
||||
|
||||
/* Begin XCBuildConfiguration section */
|
||||
FC0000000000000000000080 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = FC0000000000000000000022 /* Base.xcconfig */;
|
||||
buildSettings = {
|
||||
COPY_PHASE_STRIP = NO;
|
||||
DEBUG_INFORMATION_FORMAT = dwarf;
|
||||
ENABLE_TESTABILITY = YES;
|
||||
GCC_OPTIMIZATION_LEVEL = 0;
|
||||
ONLY_ACTIVE_ARCH = YES;
|
||||
SWIFT_ACTIVE_COMPILATION_CONDITIONS = "DEBUG $(inherited)";
|
||||
SWIFT_OPTIMIZATION_LEVEL = "-Onone";
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
FC0000000000000000000081 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
baseConfigurationReference = FC0000000000000000000022 /* Base.xcconfig */;
|
||||
buildSettings = {
|
||||
COPY_PHASE_STRIP = NO;
|
||||
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
|
||||
SWIFT_COMPILATION_MODE = wholemodule;
|
||||
VALIDATE_PRODUCT = YES;
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
FC0000000000000000000082 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
buildSettings = {
|
||||
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
|
||||
ENABLE_PREVIEWS = YES;
|
||||
GENERATE_INFOPLIST_FILE = YES;
|
||||
INFOPLIST_KEY_CFBundleDisplayName = Faceclaw;
|
||||
INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
|
||||
INFOPLIST_KEY_WKCompanionAppBundleIdentifier = "$(FACECLAW_IOS_BUNDLE_ID)";
|
||||
INFOPLIST_KEY_WKRunsIndependentlyOfCompanionApp = YES;
|
||||
LD_RUNPATH_SEARCH_PATHS = (
|
||||
"$(inherited)",
|
||||
"@executable_path/Frameworks",
|
||||
);
|
||||
PRODUCT_BUNDLE_IDENTIFIER = "$(FACECLAW_IOS_BUNDLE_ID).watchkitapp";
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SKIP_INSTALL = YES;
|
||||
SWIFT_EMIT_LOC_STRINGS = YES;
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
FC0000000000000000000083 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
buildSettings = {
|
||||
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
|
||||
ENABLE_PREVIEWS = YES;
|
||||
GENERATE_INFOPLIST_FILE = YES;
|
||||
INFOPLIST_KEY_CFBundleDisplayName = Faceclaw;
|
||||
INFOPLIST_KEY_UISupportedInterfaceOrientations = "UIInterfaceOrientationPortrait UIInterfaceOrientationPortraitUpsideDown";
|
||||
INFOPLIST_KEY_WKCompanionAppBundleIdentifier = "$(FACECLAW_IOS_BUNDLE_ID)";
|
||||
INFOPLIST_KEY_WKRunsIndependentlyOfCompanionApp = YES;
|
||||
LD_RUNPATH_SEARCH_PATHS = (
|
||||
"$(inherited)",
|
||||
"@executable_path/Frameworks",
|
||||
);
|
||||
PRODUCT_BUNDLE_IDENTIFIER = "$(FACECLAW_IOS_BUNDLE_ID).watchkitapp";
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SKIP_INSTALL = YES;
|
||||
SWIFT_EMIT_LOC_STRINGS = YES;
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
FC0000000000000000000084 /* Debug */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
buildSettings = {
|
||||
GENERATE_INFOPLIST_FILE = YES;
|
||||
PRODUCT_BUNDLE_IDENTIFIER = "$(FACECLAW_IOS_BUNDLE_ID).watchkitapp.uitests";
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SWIFT_EMIT_LOC_STRINGS = NO;
|
||||
TEST_TARGET_NAME = Faceclaw;
|
||||
};
|
||||
name = Debug;
|
||||
};
|
||||
FC0000000000000000000085 /* Release */ = {
|
||||
isa = XCBuildConfiguration;
|
||||
buildSettings = {
|
||||
GENERATE_INFOPLIST_FILE = YES;
|
||||
PRODUCT_BUNDLE_IDENTIFIER = "$(FACECLAW_IOS_BUNDLE_ID).watchkitapp.uitests";
|
||||
PRODUCT_NAME = "$(TARGET_NAME)";
|
||||
SWIFT_EMIT_LOC_STRINGS = NO;
|
||||
TEST_TARGET_NAME = Faceclaw;
|
||||
};
|
||||
name = Release;
|
||||
};
|
||||
/* End XCBuildConfiguration section */
|
||||
|
||||
/* Begin XCConfigurationList section */
|
||||
FC0000000000000000000070 /* Build configuration list for PBXProject "Faceclaw" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
FC0000000000000000000080 /* Debug */,
|
||||
FC0000000000000000000081 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
FC0000000000000000000071 /* Build configuration list for PBXNativeTarget "Faceclaw" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
FC0000000000000000000082 /* Debug */,
|
||||
FC0000000000000000000083 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
FC0000000000000000000072 /* Build configuration list for PBXNativeTarget "FaceclawUITests" */ = {
|
||||
isa = XCConfigurationList;
|
||||
buildConfigurations = (
|
||||
FC0000000000000000000084 /* Debug */,
|
||||
FC0000000000000000000085 /* Release */,
|
||||
);
|
||||
defaultConfigurationIsVisible = 0;
|
||||
defaultConfigurationName = Release;
|
||||
};
|
||||
/* End XCConfigurationList section */
|
||||
};
|
||||
rootObject = FC0000000000000000000001 /* Project object */;
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Scheme
|
||||
LastUpgradeVersion = "2640"
|
||||
version = "1.3">
|
||||
<BuildAction
|
||||
parallelizeBuildables = "YES"
|
||||
buildImplicitDependencies = "YES">
|
||||
<BuildActionEntries>
|
||||
<BuildActionEntry
|
||||
buildForTesting = "YES"
|
||||
buildForRunning = "YES"
|
||||
buildForProfiling = "YES"
|
||||
buildForArchiving = "YES"
|
||||
buildForAnalyzing = "YES">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "FC0000000000000000000010"
|
||||
BuildableName = "Faceclaw.app"
|
||||
BlueprintName = "Faceclaw"
|
||||
ReferencedContainer = "container:Faceclaw.xcodeproj">
|
||||
</BuildableReference>
|
||||
</BuildActionEntry>
|
||||
</BuildActionEntries>
|
||||
</BuildAction>
|
||||
<TestAction
|
||||
buildConfiguration = "Debug"
|
||||
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
|
||||
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
|
||||
shouldUseLaunchSchemeArgsEnv = "YES">
|
||||
<Testables>
|
||||
<TestableReference
|
||||
skipped = "NO">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "FC0000000000000000000011"
|
||||
BuildableName = "FaceclawUITests.xctest"
|
||||
BlueprintName = "FaceclawUITests"
|
||||
ReferencedContainer = "container:Faceclaw.xcodeproj">
|
||||
</BuildableReference>
|
||||
</TestableReference>
|
||||
</Testables>
|
||||
</TestAction>
|
||||
<LaunchAction
|
||||
buildConfiguration = "Debug"
|
||||
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
|
||||
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
|
||||
launchStyle = "0"
|
||||
useCustomWorkingDirectory = "NO"
|
||||
ignoresPersistentStateOnLaunch = "NO"
|
||||
debugDocumentVersioning = "YES"
|
||||
debugServiceExtension = "internal"
|
||||
allowLocationSimulation = "YES">
|
||||
<BuildableProductRunnable
|
||||
runnableDebuggingMode = "0">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "FC0000000000000000000010"
|
||||
BuildableName = "Faceclaw.app"
|
||||
ReferencedContainer = "container:Faceclaw.xcodeproj">
|
||||
</BuildableReference>
|
||||
</BuildableProductRunnable>
|
||||
</LaunchAction>
|
||||
<ProfileAction
|
||||
buildConfiguration = "Release"
|
||||
shouldUseLaunchSchemeArgsEnv = "YES"
|
||||
savedToolIdentifier = ""
|
||||
useCustomWorkingDirectory = "NO"
|
||||
debugDocumentVersioning = "YES">
|
||||
<BuildableProductRunnable
|
||||
runnableDebuggingMode = "0">
|
||||
<BuildableReference
|
||||
BuildableIdentifier = "primary"
|
||||
BlueprintIdentifier = "FC0000000000000000000010"
|
||||
BuildableName = "Faceclaw.app"
|
||||
ReferencedContainer = "container:Faceclaw.xcodeproj">
|
||||
</BuildableReference>
|
||||
</BuildableProductRunnable>
|
||||
</ProfileAction>
|
||||
<AnalyzeAction
|
||||
buildConfiguration = "Debug">
|
||||
</AnalyzeAction>
|
||||
<ArchiveAction
|
||||
buildConfiguration = "Release"
|
||||
revealArchiveInOrganizer = "YES">
|
||||
</ArchiveAction>
|
||||
</Scheme>
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 MiB |
@@ -1 +0,0 @@
|
||||
{"images":[{"filename":"AppIcon.png","idiom":"universal","platform":"watchos","size":"1024x1024"}],"info":{"author":"xcode","version":1}}
|
||||
@@ -1 +0,0 @@
|
||||
{"info":{"author":"xcode","version":1}}
|
||||
@@ -1,59 +0,0 @@
|
||||
import SwiftUI
|
||||
|
||||
@main
|
||||
struct FaceclawWatchApp: App {
|
||||
private let link: PhoneLink
|
||||
private let prefs: WatchPrefs
|
||||
|
||||
init() {
|
||||
link = PhoneLink()
|
||||
prefs = WatchPrefs(link: link)
|
||||
// Here rather than in a view: a background launch never builds one.
|
||||
link.start()
|
||||
}
|
||||
|
||||
var body: some Scene {
|
||||
WindowGroup {
|
||||
RootView()
|
||||
.environment(link)
|
||||
.environment(prefs)
|
||||
}
|
||||
.backgroundTask(.appRefresh(WatchBattery.refreshIdentifier)) { [link] in
|
||||
await link.reportBatteryFromBackground()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum Destination: Hashable {
|
||||
case assistant, apps, status, settings
|
||||
}
|
||||
|
||||
private struct RootView: View {
|
||||
@Environment(PhoneLink.self) private var link
|
||||
@Environment(WatchPrefs.self) private var prefs
|
||||
@Environment(\.scenePhase) private var scenePhase
|
||||
@State private var path: [Destination] = []
|
||||
|
||||
var body: some View {
|
||||
NavigationStack(path: $path) {
|
||||
RemoteScreen(link: link, prefs: prefs, open: { path.append($0) })
|
||||
.navigationDestination(for: Destination.self) { destination in
|
||||
switch destination {
|
||||
case .assistant: AssistantScreen()
|
||||
case .apps: AppsScreen()
|
||||
case .status: StatusScreen(openSettings: { path.append(.settings) })
|
||||
case .settings: SettingsScreen()
|
||||
}
|
||||
}
|
||||
}
|
||||
.overlay(alignment: .bottom) { NoticeOverlay(notice: link.notice) }
|
||||
.onChange(of: scenePhase, initial: true) { _, phase in
|
||||
if phase == .active { link.becameActive() } else { link.resignedActive() }
|
||||
}
|
||||
// A refused or unanswered gesture gets a distinct buzz, so the wrist
|
||||
// knows without looking; the notice pill says why.
|
||||
.onChange(of: link.notice?.id) { _, _ in
|
||||
if link.notice?.isError == true { Haptics(prefs: prefs).error() }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,185 +0,0 @@
|
||||
import CoreGraphics
|
||||
import Foundation
|
||||
import Observation
|
||||
import os
|
||||
|
||||
/**
|
||||
What the pad's touches and crown turns mean: the watch-side half of the remote,
|
||||
the twin of the callbacks in wear/.../RemoteScreen.kt.
|
||||
*/
|
||||
@MainActor
|
||||
@Observable
|
||||
final class PadController {
|
||||
/** The action buttons, hidden until a swipe up from the bottom edge. */
|
||||
var controlsVisible = false
|
||||
|
||||
@ObservationIgnored private let log = Logger(subsystem: "com.faceclaw.watch", category: "Pad")
|
||||
@ObservationIgnored private let link: PhoneLink
|
||||
@ObservationIgnored private let haptics: Haptics
|
||||
@ObservationIgnored private let recognizer = PadGestureRecognizer()
|
||||
@ObservationIgnored private var deadlineTask: Task<Void, Never>?
|
||||
@ObservationIgnored private var longPressSent = false
|
||||
@ObservationIgnored private var touchStartedAt: Date?
|
||||
@ObservationIgnored private var crownRemainder = 0.0
|
||||
/** Pad height in points, for the edge-reveal zone. */
|
||||
@ObservationIgnored var padHeight: CGFloat = 200
|
||||
|
||||
init(link: PhoneLink, prefs: WatchPrefs) {
|
||||
self.link = link
|
||||
self.haptics = Haptics(prefs: prefs)
|
||||
recognizer.onEvent = { [weak self] event in self?.handle(event) }
|
||||
}
|
||||
|
||||
// MARK: - Touch input
|
||||
|
||||
func touchChanged(start: CGPoint, location: CGPoint, time: Date) {
|
||||
if !recognizer.isTouching {
|
||||
touchStartedAt = time
|
||||
recognizer.touchDown(at: start, time: now())
|
||||
}
|
||||
recognizer.touchMoved(to: location)
|
||||
syncDeadline()
|
||||
}
|
||||
|
||||
func touchEnded(location: CGPoint) {
|
||||
recognizer.touchUp(at: location, time: now())
|
||||
syncDeadline()
|
||||
}
|
||||
|
||||
/** The touch ended without a touch-up: the system took it, or the wrist dropped. */
|
||||
func touchCancelled() {
|
||||
recognizer.cancel()
|
||||
syncDeadline()
|
||||
}
|
||||
|
||||
/**
|
||||
SwiftUI says a touch is over. If it's the current one and it hasn't ended, no
|
||||
touch-up is coming, and a hold still has to be released on the phone.
|
||||
*/
|
||||
func touchWentAway(startedAt: Date) {
|
||||
if recognizer.isTouching && startedAt == touchStartedAt { touchCancelled() }
|
||||
}
|
||||
|
||||
private func now() -> TimeInterval { ProcessInfo.processInfo.systemUptime }
|
||||
|
||||
private func syncDeadline() {
|
||||
deadlineTask?.cancel()
|
||||
deadlineTask = nil
|
||||
guard let deadline = recognizer.deadline else { return }
|
||||
let delay = max(0, deadline - now())
|
||||
deadlineTask = Task { [weak self] in
|
||||
try? await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
|
||||
guard !Task.isCancelled, let self else { return }
|
||||
self.recognizer.advance(to: self.now())
|
||||
self.syncDeadline()
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - What gestures mean
|
||||
|
||||
private var glassesScreenIsOff: Bool {
|
||||
guard let state = link.state else { return false }
|
||||
return state.takesInput && !state.screenOn
|
||||
}
|
||||
|
||||
/**
|
||||
A dark display still takes a double-click (wake), and a tap or a hold (the
|
||||
phone's Glanceboard). Scrolls, swipes and the menu gesture mean nothing there,
|
||||
so they're dropped here without a buzz.
|
||||
*/
|
||||
private func gestureAllowed(_ gesture: RingGesture) -> Bool {
|
||||
guard glassesScreenIsOff else { return true }
|
||||
switch gesture {
|
||||
case .doubleClick, .click, .longPressStart, .longPressRelease: return true
|
||||
default: return false
|
||||
}
|
||||
}
|
||||
|
||||
private func handle(_ event: PadEvent) {
|
||||
log.debug("pad \(String(describing: event), privacy: .public)")
|
||||
switch event {
|
||||
case .press:
|
||||
link.sendPress()
|
||||
case .tap:
|
||||
click()
|
||||
case .doubleTap:
|
||||
haptics.doubleClick()
|
||||
link.sendGesture(.doubleClick)
|
||||
case .shortThenLongPress:
|
||||
guard !glassesScreenIsOff else { return }
|
||||
haptics.heavy()
|
||||
link.sendGesture(.shortThenLongPress)
|
||||
case .longPressStart:
|
||||
longPressSent = gestureAllowed(.longPressStart)
|
||||
if longPressSent {
|
||||
haptics.heavy()
|
||||
link.sendGesture(.longPressStart)
|
||||
}
|
||||
case .longPressEnd:
|
||||
if longPressSent {
|
||||
longPressSent = false
|
||||
haptics.click()
|
||||
link.sendGesture(.longPressRelease)
|
||||
}
|
||||
case let .swipe(start, dx, dy):
|
||||
swipe(start: start, dx: dx, dy: dy)
|
||||
}
|
||||
}
|
||||
|
||||
/** The system's double-tap hand gesture lands here too. */
|
||||
func click() {
|
||||
guard gestureAllowed(.click) else { return }
|
||||
haptics.click()
|
||||
link.sendGesture(.click)
|
||||
}
|
||||
|
||||
private func swipe(start: CGPoint, dx: CGFloat, dy: CGFloat) {
|
||||
let vertical = abs(dy) >= abs(dx)
|
||||
if vertical && !controlsVisible && dy < 0 && start.y >= padHeight - Self.edgeRevealZone {
|
||||
controlsVisible = true
|
||||
haptics.click()
|
||||
} else if vertical && controlsVisible && dy > 0 && start.y >= padHeight - Self.buttonTrayHeight {
|
||||
controlsVisible = false
|
||||
haptics.click()
|
||||
} else if vertical {
|
||||
// One step per swipe, regardless of length: the glasses repaint per
|
||||
// step, and multi-step swipes overshoot lists when the display lags
|
||||
// the finger. Repeated flicks or the crown cover long distances.
|
||||
send(dy < 0 ? .swipeUp : .swipeDown, steps: 1)
|
||||
} else {
|
||||
send(dx < 0 ? .swipeLeft : .swipeRight, steps: 1)
|
||||
}
|
||||
}
|
||||
|
||||
private func send(_ gesture: RingGesture, steps: Int) {
|
||||
guard gestureAllowed(gesture) else { return }
|
||||
haptics.click()
|
||||
link.sendGesture(gesture, steps: steps)
|
||||
}
|
||||
|
||||
func dismissControls() {
|
||||
guard controlsVisible else { return }
|
||||
controlsVisible = false
|
||||
haptics.click()
|
||||
}
|
||||
|
||||
// MARK: - Crown
|
||||
|
||||
/** A crown turn, in detents; positive is clockwise seen from the crown's end. */
|
||||
func crownTurned(by delta: Double) {
|
||||
crownRemainder += delta
|
||||
let steps = Int(crownRemainder.rounded(.towardZero))
|
||||
guard steps != 0 else { return }
|
||||
crownRemainder -= Double(steps)
|
||||
// Clockwise moves to the previous item.
|
||||
let gesture: RingGesture = steps > 0 ? .scrollUp : .scrollDown
|
||||
guard gestureAllowed(gesture) else { return }
|
||||
// Capped low: a fast twirl otherwise outruns the display. The crown's
|
||||
// own detent haptics are the feedback, so there's no buzz here.
|
||||
link.sendGesture(gesture, steps: min(abs(steps), Self.maxCrownSteps))
|
||||
}
|
||||
|
||||
static let edgeRevealZone: CGFloat = 28
|
||||
static let buttonTrayHeight: CGFloat = 56
|
||||
private static let maxCrownSteps = 2
|
||||
}
|
||||
@@ -1,143 +0,0 @@
|
||||
import CoreGraphics
|
||||
import Foundation
|
||||
|
||||
/** What the remote's touch surface can report. */
|
||||
enum PadEvent: Equatable {
|
||||
/** A finger landed (the second tap of a pair included), before it's known what the touch will become. */
|
||||
case press
|
||||
case tap
|
||||
case doubleTap
|
||||
/** A tap whose immediate second press was held: the G2 tap-then-hold gesture. */
|
||||
case shortThenLongPress
|
||||
case longPressStart
|
||||
case longPressEnd
|
||||
/** The finger travelled past touch slop; dx/dy are the total displacement. */
|
||||
case swipe(start: CGPoint, dx: CGFloat, dy: CGFloat)
|
||||
}
|
||||
|
||||
/**
|
||||
One detector for everything the pad does, so a gesture is reported exactly
|
||||
once: tap, double-tap (a second tap inside the double-tap timeout), a hold
|
||||
(reported at the long-press timeout and again on release), tap-then-hold (a
|
||||
second tap held past the long-press timeout) and a swipe. The same state
|
||||
machine as wear/.../TouchpadGestures.kt, without its two-finger gestures:
|
||||
SwiftUI on watchOS only ever sees one finger.
|
||||
|
||||
It has no clock of its own. The owner passes the time with each event and calls
|
||||
`advance(to:)` once `deadline` passes, which is what makes it testable.
|
||||
Every longPressStart is paired with a longPressEnd, whatever ends the touch:
|
||||
the phone treats a start without a release as a hold still in progress.
|
||||
*/
|
||||
final class PadGestureRecognizer {
|
||||
struct Timing {
|
||||
var longPress: TimeInterval = 0.4
|
||||
var doubleTap: TimeInterval = 0.3
|
||||
var slop: CGFloat = 8
|
||||
}
|
||||
|
||||
private enum Phase {
|
||||
case idle
|
||||
case firstTouch(start: CGPoint, moved: Bool)
|
||||
case holding
|
||||
case awaitingSecondTouch
|
||||
case secondTouch(held: Bool)
|
||||
}
|
||||
|
||||
private var phase = Phase.idle
|
||||
private let timing: Timing
|
||||
|
||||
/** When `advance(to:)` next has something to do; nil when only a touch event can move things on. */
|
||||
private(set) var deadline: TimeInterval?
|
||||
var onEvent: (PadEvent) -> Void = { _ in }
|
||||
|
||||
init(timing: Timing = Timing()) {
|
||||
self.timing = timing
|
||||
}
|
||||
|
||||
/** A finger is on the pad, as far as this recognizer knows. */
|
||||
var isTouching: Bool {
|
||||
switch phase {
|
||||
case .firstTouch, .holding, .secondTouch: return true
|
||||
case .idle, .awaitingSecondTouch: return false
|
||||
}
|
||||
}
|
||||
|
||||
func touchDown(at location: CGPoint, time: TimeInterval) {
|
||||
if isTouching { cancel() }
|
||||
onEvent(.press)
|
||||
if case .awaitingSecondTouch = phase {
|
||||
phase = .secondTouch(held: false)
|
||||
} else {
|
||||
phase = .firstTouch(start: location, moved: false)
|
||||
}
|
||||
deadline = time + timing.longPress
|
||||
}
|
||||
|
||||
func touchMoved(to location: CGPoint) {
|
||||
guard case let .firstTouch(start, moved) = phase, !moved else { return }
|
||||
if hypot(location.x - start.x, location.y - start.y) > timing.slop {
|
||||
phase = .firstTouch(start: start, moved: true)
|
||||
deadline = nil
|
||||
}
|
||||
}
|
||||
|
||||
func touchUp(at location: CGPoint, time: TimeInterval) {
|
||||
switch phase {
|
||||
case let .firstTouch(start, moved):
|
||||
if moved {
|
||||
reset()
|
||||
onEvent(.swipe(start: start, dx: location.x - start.x, dy: location.y - start.y))
|
||||
} else {
|
||||
// A plain tap; give a second tap a chance to make it a double.
|
||||
phase = .awaitingSecondTouch
|
||||
deadline = time + timing.doubleTap
|
||||
}
|
||||
case .holding:
|
||||
reset()
|
||||
onEvent(.longPressEnd)
|
||||
case let .secondTouch(held):
|
||||
reset()
|
||||
if !held { onEvent(.doubleTap) }
|
||||
case .idle, .awaitingSecondTouch:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
func advance(to time: TimeInterval) {
|
||||
guard let deadline, time >= deadline else { return }
|
||||
self.deadline = nil
|
||||
switch phase {
|
||||
case .firstTouch:
|
||||
phase = .holding
|
||||
onEvent(.longPressStart)
|
||||
case .secondTouch:
|
||||
phase = .secondTouch(held: true)
|
||||
onEvent(.shortThenLongPress)
|
||||
case .awaitingSecondTouch:
|
||||
reset()
|
||||
onEvent(.tap)
|
||||
case .idle, .holding:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
The touch is over but no touch-up will come: the system took the gesture or
|
||||
the wrist dropped. A touch in progress is dropped rather than mistaken for a
|
||||
tap; a tap already completed and a hold already reported are both honoured.
|
||||
*/
|
||||
func cancel() {
|
||||
let cancelled = phase
|
||||
reset()
|
||||
switch cancelled {
|
||||
case .holding: onEvent(.longPressEnd)
|
||||
case .awaitingSecondTouch: onEvent(.tap)
|
||||
case .idle, .firstTouch, .secondTouch: break
|
||||
}
|
||||
}
|
||||
|
||||
private func reset() {
|
||||
phase = .idle
|
||||
deadline = nil
|
||||
}
|
||||
}
|
||||
@@ -1,77 +0,0 @@
|
||||
import Foundation
|
||||
|
||||
/** What we know about the phone and the Faceclaw app on it. */
|
||||
struct LinkStatus: Equatable {
|
||||
/** The WatchConnectivity session is up; until then nothing below is known. */
|
||||
var activated = false
|
||||
/** The iPhone can be messaged right now. */
|
||||
var phoneReachable = false
|
||||
/** That iPhone has Faceclaw installed. */
|
||||
var phoneAppInstalled = false
|
||||
/**
|
||||
Whether the phone app's dashboard (the JS side) answered our last message;
|
||||
nil until we have heard anything. False means Faceclaw is installed but its
|
||||
dashboard isn't running, so the user has to open it.
|
||||
*/
|
||||
var appRunning: Bool?
|
||||
}
|
||||
|
||||
enum StatusTone { case good, busy, off, problem }
|
||||
|
||||
/**
|
||||
The pad's indicator line, with a tone that picks its colour, and an optional
|
||||
smaller line under it (the charging case's level while charging).
|
||||
*/
|
||||
struct StatusLine: Equatable {
|
||||
var text: String
|
||||
var tone: StatusTone
|
||||
var detail: String?
|
||||
}
|
||||
|
||||
/**
|
||||
The pad's indicator: what the next gesture lands on when everything is
|
||||
connected (the foreground app, or the screen/lock state in the way of it),
|
||||
otherwise the connection problem to fix first.
|
||||
*/
|
||||
func padLine(state: PhoneState?, link: LinkStatus) -> StatusLine {
|
||||
guard link.activated else { return StatusLine(text: "Waiting for phone", tone: .busy) }
|
||||
guard link.phoneAppInstalled else { return StatusLine(text: "Install Faceclaw on phone", tone: .problem) }
|
||||
guard link.phoneReachable else { return StatusLine(text: "No phone", tone: .problem) }
|
||||
if link.appRunning == false { return StatusLine(text: "Open Faceclaw on phone", tone: .problem) }
|
||||
guard let state else { return StatusLine(text: "Waiting for phone", tone: .busy) }
|
||||
if !state.remoteEnabled { return StatusLine(text: "Watch control off", tone: .problem) }
|
||||
if state.connected {
|
||||
if state.charging || state.phase == "charging" {
|
||||
return StatusLine(text: chargingLine(state.battery), tone: .busy, detail: caseLine(state))
|
||||
}
|
||||
if state.silentMode { return StatusLine(text: "Silent mode", tone: .off) }
|
||||
if state.locked { return StatusLine(text: "Locked", tone: .off) }
|
||||
if !state.screenOn { return StatusLine(text: "●● Wake", tone: .off) }
|
||||
if state.listening { return StatusLine(text: "Listening…", tone: .busy) }
|
||||
return StatusLine(text: state.foreground?.title ?? "Launcher", tone: .good)
|
||||
}
|
||||
switch state.phase {
|
||||
case "connecting": return StatusLine(text: "Connecting…", tone: .busy)
|
||||
case "retrying": return StatusLine(text: "Reconnecting…", tone: .busy)
|
||||
case "disconnecting": return StatusLine(text: "Disconnecting…", tone: .busy)
|
||||
default: break
|
||||
}
|
||||
if state.preview {
|
||||
if state.locked { return StatusLine(text: "Locked", tone: .off) }
|
||||
if !state.screenOn { return StatusLine(text: "●● Wake", tone: .off) }
|
||||
return StatusLine(text: state.foreground?.title ?? "Launcher", tone: .good, detail: "Phone preview")
|
||||
}
|
||||
return StatusLine(text: "Disconnected", tone: .off)
|
||||
}
|
||||
|
||||
private func chargingLine(_ battery: Int?) -> String {
|
||||
battery.map { "Charging · G2 \($0)%" } ?? "Charging"
|
||||
}
|
||||
|
||||
/**
|
||||
"Case 64%", with ⚡ while the case is on USB; nil when the level is unknown. The
|
||||
case only reports while the glasses are docked, so this is only drawn while they charge.
|
||||
*/
|
||||
private func caseLine(_ state: PhoneState) -> String? {
|
||||
state.caseBattery.map { "Case \($0)%" + (state.caseCharging == true ? " ⚡" : "") }
|
||||
}
|
||||
@@ -1,376 +0,0 @@
|
||||
import Foundation
|
||||
import Observation
|
||||
import WatchConnectivity
|
||||
import WatchKit
|
||||
import os
|
||||
|
||||
/** A transient message for the UI (ack failures, confirmations). */
|
||||
struct Notice: Equatable {
|
||||
var text: String
|
||||
var isError: Bool
|
||||
var id: UUID
|
||||
}
|
||||
|
||||
/**
|
||||
The watch's end of the WatchConnectivity conversation with the phone: sends
|
||||
gestures, commands and text as messages, receives acks and events, and mirrors
|
||||
the phone's state. The twin of wear/.../PhoneLink.kt, with these differences:
|
||||
|
||||
- Live messages only work while this app is in front. The iPhone app can't wake
|
||||
us, so the phone also leaves its state and latest event in the application
|
||||
context, which is delivered whenever we next run.
|
||||
- `isReachable` lags a moment behind a wrist raise, which is exactly when a
|
||||
gesture arrives, so messages are held briefly instead of failing at once.
|
||||
*/
|
||||
@MainActor
|
||||
@Observable
|
||||
final class PhoneLink: NSObject {
|
||||
private(set) var state: PhoneState?
|
||||
private(set) var link = LinkStatus()
|
||||
private(set) var assistant = AssistantMirror()
|
||||
private(set) var notice: Notice?
|
||||
|
||||
@ObservationIgnored private let log = Logger(subsystem: "com.faceclaw.watch", category: "PhoneLink")
|
||||
@ObservationIgnored private var nextSeq: Int64 = 1
|
||||
@ObservationIgnored private var pendingAcks: [Int64: Task<Void, Never>] = [:]
|
||||
@ObservationIgnored private var held: [Outgoing] = []
|
||||
@ObservationIgnored private var heldExpiry: Task<Void, Never>?
|
||||
@ObservationIgnored private var noticeTask: Task<Void, Never>?
|
||||
@ObservationIgnored private var batteryTimer: Task<Void, Never>?
|
||||
@ObservationIgnored private var lastBatteryReported: WatchBatteryReading?
|
||||
@ObservationIgnored private var lastEventAt: Int64 = 0
|
||||
|
||||
private struct Outgoing {
|
||||
var path: String
|
||||
var json: String
|
||||
var seq: Int64
|
||||
var quiet: Bool
|
||||
}
|
||||
|
||||
private var session: WCSession { WCSession.default }
|
||||
|
||||
/** Activate the session. Called during launch, including a background launch. */
|
||||
func start() {
|
||||
guard WCSession.isSupported() else { return }
|
||||
session.delegate = self
|
||||
session.activate()
|
||||
}
|
||||
|
||||
// MARK: - App lifecycle
|
||||
|
||||
/** The app came to the front: catch up on everything that happened while suspended. */
|
||||
func becameActive() {
|
||||
refresh()
|
||||
batteryTimer?.cancel()
|
||||
// watchOS has no battery-change notification, and the app is only awake to be polled here.
|
||||
batteryTimer = Task { [weak self] in
|
||||
while !Task.isCancelled {
|
||||
try? await Task.sleep(nanoseconds: Self.batteryPollNanos)
|
||||
guard !Task.isCancelled else { return }
|
||||
self?.reportBattery(force: false)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func resignedActive() {
|
||||
batteryTimer?.cancel()
|
||||
batteryTimer = nil
|
||||
WatchBattery.scheduleBackgroundRefresh()
|
||||
}
|
||||
|
||||
/** Re-read the session, the cached state and ask the phone for a fresh one. */
|
||||
func refresh() {
|
||||
updateLink()
|
||||
guard session.activationState == .activated else { return }
|
||||
applyContext(session.receivedApplicationContext)
|
||||
if link.phoneAppInstalled {
|
||||
requestState()
|
||||
reportBattery(force: true)
|
||||
}
|
||||
}
|
||||
|
||||
/** The system gave us background time: leave the battery level for the phone to find. */
|
||||
func reportBatteryFromBackground() async {
|
||||
for _ in 0..<50 where session.activationState != .activated {
|
||||
try? await Task.sleep(nanoseconds: 100_000_000)
|
||||
}
|
||||
reportBattery(force: true)
|
||||
WatchBattery.scheduleBackgroundRefresh()
|
||||
}
|
||||
|
||||
// MARK: - Outbound
|
||||
|
||||
func sendGesture(_ gesture: RingGesture, steps: Int = 1) {
|
||||
send(WirePath.input, ["gesture": gesture.rawValue, "steps": steps])
|
||||
}
|
||||
|
||||
/**
|
||||
A finger landed: the phone delivers it as the ring's touch-down (ring-press)
|
||||
ahead of whatever gesture the touch becomes. Fire-and-forget and silent, since
|
||||
the gesture that follows reports any failure; never held, since a late
|
||||
touch-down would be worse than none.
|
||||
*/
|
||||
func sendPress() {
|
||||
guard let state, state.takesInput, state.screenOn, session.isReachable else { return }
|
||||
transmit(path: WirePath.press, json: "{}")
|
||||
}
|
||||
|
||||
func sendCommand(_ command: String, extras: [String: String] = [:]) {
|
||||
var body: [String: Any] = ["command": command]
|
||||
for (key, value) in extras { body[key] = value }
|
||||
send(WirePath.command, body)
|
||||
}
|
||||
|
||||
func sendAssistantQuery(_ text: String) {
|
||||
assistant = AssistantMirror(phase: "thinking", text: "")
|
||||
send(WirePath.assistant, ["text": text])
|
||||
}
|
||||
|
||||
func sendText(_ text: String) {
|
||||
send(WirePath.text, ["text": text])
|
||||
}
|
||||
|
||||
func requestState() {
|
||||
send(WirePath.stateRequest, [:], quiet: true)
|
||||
}
|
||||
|
||||
func clearAssistant() {
|
||||
assistant = AssistantMirror()
|
||||
}
|
||||
|
||||
private func send(_ path: String, _ body: [String: Any], quiet: Bool = false) {
|
||||
let seq = nextSeq
|
||||
nextSeq += 1
|
||||
var body = body
|
||||
body["seq"] = seq
|
||||
guard let json = encodeJSON(body) else { return }
|
||||
let message = Outgoing(path: path, json: json, seq: seq, quiet: quiet)
|
||||
if session.activationState == .activated && session.isReachable {
|
||||
transmit(message)
|
||||
} else if quiet {
|
||||
// Only state requests are quiet, and reachability returning sends a fresh one.
|
||||
} else {
|
||||
hold(message)
|
||||
}
|
||||
}
|
||||
|
||||
private func hold(_ message: Outgoing) {
|
||||
log.debug("hold \(message.path, privacy: .public) seq=\(message.seq) (not reachable)")
|
||||
held.append(message)
|
||||
if held.count > Self.heldLimit { held.removeFirst() }
|
||||
guard heldExpiry == nil else { return }
|
||||
heldExpiry = Task { [weak self] in
|
||||
try? await Task.sleep(nanoseconds: Self.holdNanos)
|
||||
guard !Task.isCancelled else { return }
|
||||
self?.expireHeld()
|
||||
}
|
||||
}
|
||||
|
||||
private func flushHeld() {
|
||||
heldExpiry?.cancel()
|
||||
heldExpiry = nil
|
||||
let messages = held
|
||||
held = []
|
||||
messages.forEach(transmit)
|
||||
}
|
||||
|
||||
private func expireHeld() {
|
||||
heldExpiry = nil
|
||||
guard !held.isEmpty else { return }
|
||||
held = []
|
||||
showNotice(link.phoneAppInstalled ? "The phone is out of range." : "Faceclaw isn't installed on the phone.", isError: true)
|
||||
}
|
||||
|
||||
private func transmit(_ message: Outgoing) {
|
||||
log.debug("send \(message.path, privacy: .public) seq=\(message.seq)")
|
||||
transmit(path: message.path, json: message.json) { [weak self] error in
|
||||
self?.sendFailed(message, error)
|
||||
}
|
||||
// The phone acks every message; silence means its app process never received it.
|
||||
pendingAcks[message.seq] = Task { [weak self] in
|
||||
try? await Task.sleep(nanoseconds: Self.ackTimeoutNanos)
|
||||
guard !Task.isCancelled, let self, self.pendingAcks.removeValue(forKey: message.seq) != nil else { return }
|
||||
if self.link.appRunning == nil { self.link.appRunning = false }
|
||||
if !message.quiet { self.showNotice("No reply from the phone.", isError: true) }
|
||||
}
|
||||
}
|
||||
|
||||
private func transmit(path: String, json: String, onError: (@MainActor (Error) -> Void)? = nil) {
|
||||
session.sendMessage([WireKey.path: path, WireKey.json: json], replyHandler: nil) { [log] error in
|
||||
log.error("send \(path, privacy: .public) failed: \(error.localizedDescription, privacy: .public)")
|
||||
Task { @MainActor in onError?(error) }
|
||||
}
|
||||
}
|
||||
|
||||
private func sendFailed(_ message: Outgoing, _ error: Error) {
|
||||
pendingAcks.removeValue(forKey: message.seq)?.cancel()
|
||||
updateLink()
|
||||
guard !message.quiet else { return }
|
||||
let code = (error as? WCError)?.code
|
||||
switch code {
|
||||
case .notReachable: showNotice("The phone is out of range.", isError: true)
|
||||
case .companionAppNotInstalled: showNotice("Faceclaw isn't installed on the phone.", isError: true)
|
||||
default: showNotice("Couldn't reach the phone.", isError: true)
|
||||
}
|
||||
}
|
||||
|
||||
/** Send our battery to the phone (for the glasses' Watch indicator), live and for later. */
|
||||
private func reportBattery(force: Bool) {
|
||||
guard session.activationState == .activated else { return }
|
||||
let reading = WatchBattery.read()
|
||||
if !force && reading == lastBatteryReported { return }
|
||||
lastBatteryReported = reading
|
||||
guard let json = encodeJSON(reading.payload(at: Date())) else { return }
|
||||
if session.isReachable { transmit(path: WirePath.battery, json: json) }
|
||||
do {
|
||||
try session.updateApplicationContext([WireKey.battery: json])
|
||||
} catch {
|
||||
log.debug("battery context not sent: \(error.localizedDescription, privacy: .public)")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Inbound
|
||||
|
||||
private func handleMessage(path: String, json: String, updatedAt: Int64, at: Int64) {
|
||||
switch path {
|
||||
case WirePath.ack:
|
||||
if let ack = Ack.parse(json) { handleAck(ack) }
|
||||
case WirePath.event:
|
||||
handleEvent(json: json, at: at, fromContext: false)
|
||||
case WirePath.state:
|
||||
// A live state comes from the running dashboard, unlike one left in the context.
|
||||
applyState(json: json, updatedAt: updatedAt)
|
||||
link.appRunning = true
|
||||
case WirePath.batteryRequest:
|
||||
reportBattery(force: true)
|
||||
default:
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
private func handleAck(_ ack: Ack) {
|
||||
pendingAcks.removeValue(forKey: ack.seq)?.cancel()
|
||||
link.appRunning = ack.jsReady
|
||||
if !ack.ok {
|
||||
showNotice(ack.message.isEmpty ? "The phone refused that." : ack.message, isError: true)
|
||||
} else if !ack.message.isEmpty {
|
||||
showNotice(ack.message, isError: false)
|
||||
}
|
||||
}
|
||||
|
||||
private func handleEvent(json: String, at: Int64, fromContext: Bool) {
|
||||
guard let event = PhoneEvent.parse(json) else { return }
|
||||
// The same event can arrive both live and in the context.
|
||||
if at != 0 {
|
||||
guard at > lastEventAt else { return }
|
||||
lastEventAt = at
|
||||
}
|
||||
let age = at == 0 ? 0 : Date().timeIntervalSince1970 - Double(at) / 1000
|
||||
switch event {
|
||||
case let .assistant(phase, text):
|
||||
if fromContext && age > Self.assistantEventMaxAge { return }
|
||||
assistant = assistant.applying(phase: phase, text: text)
|
||||
case let .alert(text):
|
||||
if fromContext && age > Self.alertEventMaxAge { return }
|
||||
showNotice(text, isError: false)
|
||||
}
|
||||
}
|
||||
|
||||
private func applyContext(_ context: [String: Any]) {
|
||||
if let json = context[WireKey.json] as? String {
|
||||
applyState(json: json, updatedAt: (context[WireKey.updatedAt] as? NSNumber)?.int64Value ?? 0)
|
||||
}
|
||||
if let json = context[WireKey.event] as? String {
|
||||
handleEvent(json: json, at: (context[WireKey.eventAt] as? NSNumber)?.int64Value ?? 0, fromContext: true)
|
||||
}
|
||||
}
|
||||
|
||||
private func applyState(json: String, updatedAt: Int64) {
|
||||
// A live message and the context can carry the same or an older state, in either order.
|
||||
if let state, updatedAt < state.updatedAt { return }
|
||||
if let parsed = PhoneState.parse(json, updatedAt: updatedAt) { state = parsed }
|
||||
}
|
||||
|
||||
private func updateLink() {
|
||||
// The session logs an error for each property read before activation.
|
||||
guard WCSession.isSupported(), session.activationState == .activated else { return }
|
||||
link.activated = true
|
||||
link.phoneReachable = session.isReachable
|
||||
link.phoneAppInstalled = session.isCompanionAppInstalled
|
||||
if !link.phoneAppInstalled { link.appRunning = nil }
|
||||
}
|
||||
|
||||
private func reachabilityChanged() {
|
||||
updateLink()
|
||||
log.debug("reachable=\(self.link.phoneReachable)")
|
||||
if session.isReachable {
|
||||
flushHeld()
|
||||
requestState()
|
||||
reportBattery(force: true)
|
||||
}
|
||||
}
|
||||
|
||||
private func activated() {
|
||||
updateLink()
|
||||
applyContext(session.receivedApplicationContext)
|
||||
reachabilityChanged()
|
||||
}
|
||||
|
||||
private func showNotice(_ text: String, isError: Bool) {
|
||||
noticeTask?.cancel()
|
||||
notice = Notice(text: text, isError: isError, id: UUID())
|
||||
noticeTask = Task { [weak self] in
|
||||
try? await Task.sleep(nanoseconds: isError ? Self.noticeErrorNanos : Self.noticeInfoNanos)
|
||||
guard !Task.isCancelled else { return }
|
||||
self?.notice = nil
|
||||
}
|
||||
}
|
||||
|
||||
private static let ackTimeoutNanos: UInt64 = 4_000_000_000
|
||||
/** How long a message waits for reachability, e.g. right after a wrist raise. */
|
||||
private static let holdNanos: UInt64 = 1_500_000_000
|
||||
private static let heldLimit = 8
|
||||
private static let batteryPollNanos: UInt64 = 60_000_000_000
|
||||
private static let noticeInfoNanos: UInt64 = 1_800_000_000
|
||||
private static let noticeErrorNanos: UInt64 = 3_200_000_000
|
||||
/** A reply that finished while we slept is still worth showing for this long. */
|
||||
private static let assistantEventMaxAge: TimeInterval = 600
|
||||
private static let alertEventMaxAge: TimeInterval = 60
|
||||
}
|
||||
|
||||
extension PhoneLink: WCSessionDelegate {
|
||||
nonisolated func session(_ session: WCSession, activationDidCompleteWith state: WCSessionActivationState, error: Error?) {
|
||||
let log = Logger(subsystem: "com.faceclaw.watch", category: "PhoneLink")
|
||||
log.info("session activation finished: state \(state.rawValue), error \(error?.localizedDescription ?? "none", privacy: .public)")
|
||||
Task { @MainActor in self.activated() }
|
||||
}
|
||||
|
||||
nonisolated func sessionReachabilityDidChange(_ session: WCSession) {
|
||||
Task { @MainActor in self.reachabilityChanged() }
|
||||
}
|
||||
|
||||
nonisolated func sessionCompanionAppInstalledDidChange(_ session: WCSession) {
|
||||
Task { @MainActor in self.updateLink() }
|
||||
}
|
||||
|
||||
nonisolated func session(_ session: WCSession, didReceiveMessage message: [String: Any]) {
|
||||
guard let path = message[WireKey.path] as? String else { return }
|
||||
let json = message[WireKey.json] as? String ?? "{}"
|
||||
let updatedAt = (message[WireKey.updatedAt] as? NSNumber)?.int64Value ?? 0
|
||||
let at = (message[WireKey.at] as? NSNumber)?.int64Value ?? 0
|
||||
Task { @MainActor in self.handleMessage(path: path, json: json, updatedAt: updatedAt, at: at) }
|
||||
}
|
||||
|
||||
nonisolated func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
|
||||
Task { @MainActor in self.refreshFromContext() }
|
||||
}
|
||||
|
||||
@MainActor private func refreshFromContext() {
|
||||
applyContext(session.receivedApplicationContext)
|
||||
}
|
||||
}
|
||||
|
||||
private func encodeJSON(_ object: [String: Any]) -> String? {
|
||||
guard let data = try? JSONSerialization.data(withJSONObject: object) else { return nil }
|
||||
return String(data: data, encoding: .utf8)
|
||||
}
|
||||
@@ -1,234 +0,0 @@
|
||||
import Foundation
|
||||
|
||||
/**
|
||||
Wire format shared with the phone app. Mirror of app/native/wear-bridge-types.ts
|
||||
(paths), app/g2/wear-remote.ts (payloads) and App_Resources/iOS/src/FaceclawWatchBridge.m
|
||||
(WatchConnectivity keys); see wear/PROTOCOL.md.
|
||||
*/
|
||||
enum WirePath {
|
||||
static let input = "/faceclaw/input"
|
||||
/** Watch -> phone: a finger landed on the pad, ahead of the gesture it becomes; no seq, never acked. */
|
||||
static let press = "/faceclaw/press"
|
||||
static let command = "/faceclaw/command"
|
||||
static let assistant = "/faceclaw/assistant"
|
||||
static let text = "/faceclaw/text"
|
||||
static let stateRequest = "/faceclaw/state/request"
|
||||
/** Watch -> phone: our own battery ({battery, charging, at}); no seq, never acked. */
|
||||
static let battery = "/faceclaw/battery"
|
||||
/** Phone -> watch: please send `battery` now. Only reaches an app that's in front. */
|
||||
static let batteryRequest = "/faceclaw/battery/request"
|
||||
static let ack = "/faceclaw/ack"
|
||||
static let event = "/faceclaw/event"
|
||||
static let state = "/faceclaw/state"
|
||||
}
|
||||
|
||||
/** Keys of the WatchConnectivity dictionaries that carry those messages. */
|
||||
enum WireKey {
|
||||
static let path = "path"
|
||||
static let json = "json"
|
||||
static let updatedAt = "updatedAt"
|
||||
/** The time a live event was sent, matching `eventAt` when it's also in the context. */
|
||||
static let at = "at"
|
||||
/** Application context: the latest event a suspended app would otherwise have missed. */
|
||||
static let event = "event"
|
||||
static let eventAt = "eventAt"
|
||||
/** Application context, watch -> phone: the battery report, as JSON. */
|
||||
static let battery = "battery"
|
||||
}
|
||||
|
||||
/** Ring-style gestures, as the phone's synthetic ring input understands them. */
|
||||
enum RingGesture: String {
|
||||
case click
|
||||
case doubleClick = "double-click"
|
||||
case scrollUp = "scroll-up"
|
||||
case scrollDown = "scroll-down"
|
||||
/** Finger down: the hold lasts until longPressRelease. */
|
||||
case longPressStart = "long-press-start"
|
||||
case longPressRelease = "long-press-release"
|
||||
/** Tap then hold: opens the app's context menu on the glasses. */
|
||||
case shortThenLongPress = "short-then-long-press"
|
||||
/** The spoken "Hey Even": opens the glasses' own voice dialog. */
|
||||
case wakeword
|
||||
/**
|
||||
Spatial (four-way) input the ring cannot produce. The glasses UI gives it a
|
||||
spatial meaning where one exists (grid rows and columns, panel columns,
|
||||
tracks) and otherwise treats up/down as scroll, right as select and left as back.
|
||||
*/
|
||||
case swipeUp = "swipe-up"
|
||||
case swipeDown = "swipe-down"
|
||||
case swipeLeft = "swipe-left"
|
||||
case swipeRight = "swipe-right"
|
||||
}
|
||||
|
||||
/** Shell commands; things the ring cannot express. */
|
||||
enum PhoneCommand {
|
||||
static let launchApp = "launch-app"
|
||||
static let focusWindow = "focus-window"
|
||||
static let closeWindow = "close-window"
|
||||
static let wake = "wake"
|
||||
static let sleep = "sleep"
|
||||
static let lock = "lock"
|
||||
static let unlock = "unlock"
|
||||
static let connect = "connect"
|
||||
static let disconnect = "disconnect"
|
||||
static let closeAssistant = "close-assistant"
|
||||
static let sidebar = "sidebar"
|
||||
}
|
||||
|
||||
struct AppEntry: Equatable, Identifiable {
|
||||
var appId: String
|
||||
var title: String
|
||||
var id: String { appId }
|
||||
}
|
||||
|
||||
struct WindowEntry: Equatable, Identifiable {
|
||||
var windowId: String
|
||||
var title: String
|
||||
var appId: String
|
||||
var focused: Bool
|
||||
var closeable: Bool
|
||||
var acceptsText: Bool
|
||||
var id: String { windowId }
|
||||
}
|
||||
|
||||
/** The phone's mirrored dashboard state (/faceclaw/state). */
|
||||
struct PhoneState: Equatable {
|
||||
var version = ""
|
||||
var phase = "disconnected"
|
||||
var status = ""
|
||||
var connected = false
|
||||
/** The shell is running on the phone's preview with no glasses, so gestures still land. */
|
||||
var preview = false
|
||||
var screenOn = false
|
||||
var locked = false
|
||||
var worn: Bool?
|
||||
var listening = false
|
||||
/** Current or last-known G2 charge percentage. */
|
||||
var battery: Int?
|
||||
var charging = false
|
||||
/** Last-known charging-case percentage; live only while the glasses are docked. */
|
||||
var caseBattery: Int?
|
||||
/** The case is on USB; nil while the glasses are out of the case. */
|
||||
var caseCharging: Bool?
|
||||
var silentMode = false
|
||||
var foreground: AppEntry?
|
||||
var windows: [WindowEntry] = []
|
||||
var apps: [AppEntry] = []
|
||||
var remoteEnabled = true
|
||||
/** Settings > Watch on the glasses; WatchPrefs and Haptics say what they do. */
|
||||
var vibrateOnInput = true
|
||||
var soundEffects = false
|
||||
var canUnlock = true
|
||||
var mirrorAssistant = true
|
||||
var assistantAvailable = false
|
||||
var updatedAt: Int64 = 0
|
||||
|
||||
/** Gestures have a display to act on, whether that's the glasses or the phone's preview. */
|
||||
var takesInput: Bool { connected || preview }
|
||||
|
||||
static func parse(_ json: String, updatedAt: Int64) -> PhoneState? {
|
||||
guard let o = parseObject(json) else { return nil }
|
||||
var state = PhoneState()
|
||||
state.version = o["version"] as? String ?? ""
|
||||
state.phase = o["phase"] as? String ?? "disconnected"
|
||||
state.status = o["status"] as? String ?? ""
|
||||
state.connected = o["connected"] as? Bool ?? false
|
||||
state.preview = o["preview"] as? Bool ?? false
|
||||
state.screenOn = o["screenOn"] as? Bool ?? false
|
||||
state.locked = o["locked"] as? Bool ?? false
|
||||
state.worn = o["worn"] as? Bool
|
||||
state.listening = o["listening"] as? Bool ?? false
|
||||
state.battery = percent(o["battery"])
|
||||
state.charging = o["charging"] as? Bool ?? false
|
||||
state.caseBattery = percent(o["caseBattery"])
|
||||
state.caseCharging = o["caseCharging"] as? Bool
|
||||
state.silentMode = o["silentMode"] as? Bool ?? false
|
||||
if let foreground = o["foreground"] as? [String: Any] { state.foreground = appEntry(foreground) }
|
||||
state.windows = (o["windows"] as? [[String: Any]] ?? []).map { w in
|
||||
WindowEntry(
|
||||
windowId: w["windowId"] as? String ?? "",
|
||||
title: w["title"] as? String ?? "",
|
||||
appId: w["appId"] as? String ?? "",
|
||||
focused: w["focused"] as? Bool ?? false,
|
||||
closeable: w["closeable"] as? Bool ?? true,
|
||||
acceptsText: w["acceptsText"] as? Bool ?? false
|
||||
)
|
||||
}
|
||||
state.apps = (o["apps"] as? [[String: Any]] ?? []).map(appEntry)
|
||||
state.remoteEnabled = o["remoteEnabled"] as? Bool ?? true
|
||||
state.vibrateOnInput = o["vibrateOnInput"] as? Bool ?? true
|
||||
state.soundEffects = o["soundEffects"] as? Bool ?? false
|
||||
state.canUnlock = o["canUnlock"] as? Bool ?? true
|
||||
state.mirrorAssistant = o["mirrorAssistant"] as? Bool ?? true
|
||||
state.assistantAvailable = o["assistantAvailable"] as? Bool ?? false
|
||||
state.updatedAt = updatedAt
|
||||
return state
|
||||
}
|
||||
|
||||
private static func appEntry(_ o: [String: Any]) -> AppEntry {
|
||||
AppEntry(appId: o["appId"] as? String ?? "", title: o["title"] as? String ?? "")
|
||||
}
|
||||
|
||||
private static func percent(_ value: Any?) -> Int? {
|
||||
guard let number = value as? NSNumber, (0...100).contains(number.intValue) else { return nil }
|
||||
return number.intValue
|
||||
}
|
||||
}
|
||||
|
||||
/** The phone's reply to one of our messages. */
|
||||
struct Ack: Equatable {
|
||||
var seq: Int64
|
||||
var ok: Bool
|
||||
/** False: the phone's app process answered, but its dashboard isn't up. */
|
||||
var jsReady: Bool
|
||||
var message: String
|
||||
|
||||
static func parse(_ json: String) -> Ack? {
|
||||
guard let o = parseObject(json) else { return nil }
|
||||
return Ack(
|
||||
seq: (o["seq"] as? NSNumber)?.int64Value ?? 0,
|
||||
ok: o["ok"] as? Bool ?? false,
|
||||
jsReady: o["jsReady"] as? Bool ?? true,
|
||||
message: o["message"] as? String ?? ""
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** Phone -> watch events (/faceclaw/event). */
|
||||
enum PhoneEvent: Equatable {
|
||||
/** phase: thinking | streaming | done | error | closed; text is the reply so far. */
|
||||
case assistant(phase: String, text: String)
|
||||
case alert(text: String)
|
||||
|
||||
static func parse(_ json: String) -> PhoneEvent? {
|
||||
guard let o = parseObject(json) else { return nil }
|
||||
switch o["type"] as? String {
|
||||
case "assistant": return .assistant(phase: o["phase"] as? String ?? "", text: o["text"] as? String ?? "")
|
||||
case "alert": return .alert(text: o["text"] as? String ?? "")
|
||||
default: return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The assistant overlay as mirrored from the glasses. */
|
||||
struct AssistantMirror: Equatable {
|
||||
/** idle | thinking | streaming | done | error */
|
||||
var phase = "idle"
|
||||
var text = ""
|
||||
|
||||
func applying(phase next: String, text nextText: String) -> AssistantMirror {
|
||||
switch next {
|
||||
case "thinking": return AssistantMirror(phase: "thinking", text: "")
|
||||
case "streaming": return AssistantMirror(phase: "streaming", text: nextText)
|
||||
case "done": return AssistantMirror(phase: "done", text: nextText.isEmpty ? text : nextText)
|
||||
case "error": return AssistantMirror(phase: "error", text: nextText)
|
||||
case "closed": return AssistantMirror(phase: "idle", text: text)
|
||||
default: return self
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func parseObject(_ json: String) -> [String: Any]? {
|
||||
guard let data = json.data(using: .utf8) else { return nil }
|
||||
return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
|
||||
}
|
||||
@@ -1,210 +0,0 @@
|
||||
import SwiftUI
|
||||
|
||||
/**
|
||||
The touchpad. The whole screen is the pad: tap = select, double-tap = back, hold
|
||||
= long press (released when the finger lifts), tap then hold = the app's menu,
|
||||
swipes in four directions = spatial navigation, crown = plain scrolling. An upward
|
||||
swipe that begins at the bottom edge reveals the otherwise-hidden action buttons.
|
||||
*/
|
||||
struct RemoteScreen: View {
|
||||
let link: PhoneLink
|
||||
let prefs: WatchPrefs
|
||||
let open: (Destination) -> Void
|
||||
|
||||
@Environment(\.isLuminanceReduced) private var isDimmed
|
||||
@Environment(\.scenePhase) private var scenePhase
|
||||
@State private var pad: PadController
|
||||
@State private var crownValue = 0.0
|
||||
/** When the touch in progress began; nil once it's over, however it ended. */
|
||||
@GestureState private var touchStart: Date?
|
||||
@FocusState private var crownFocused: Bool
|
||||
|
||||
init(link: PhoneLink, prefs: WatchPrefs, open: @escaping (Destination) -> Void) {
|
||||
self.link = link
|
||||
self.prefs = prefs
|
||||
self.open = open
|
||||
_pad = State(initialValue: PadController(link: link, prefs: prefs))
|
||||
}
|
||||
|
||||
var body: some View {
|
||||
GeometryReader { geometry in
|
||||
ZStack {
|
||||
padSurface
|
||||
primaryActionShortcut
|
||||
clockAndStatus.allowsHitTesting(false)
|
||||
if pad.controlsVisible && !isDimmed { tray }
|
||||
}
|
||||
.onChange(of: geometry.size.height, initial: true) { _, height in pad.padHeight = height }
|
||||
}
|
||||
.ignoresSafeArea()
|
||||
.toolbar(.hidden, for: .navigationBar)
|
||||
.animation(.easeOut(duration: 0.18), value: pad.controlsVisible)
|
||||
// Crown events only reach a focused view, and the focus is lost to every screen pushed on top.
|
||||
.focusable(true)
|
||||
.focused($crownFocused)
|
||||
.focusEffectDisabled()
|
||||
.digitalCrownRotation(
|
||||
$crownValue,
|
||||
from: -Self.crownRange,
|
||||
through: Self.crownRange,
|
||||
by: 1,
|
||||
sensitivity: prefs.crownSensitivity.digitalCrown,
|
||||
isContinuous: true,
|
||||
isHapticFeedbackEnabled: prefs.haptics
|
||||
)
|
||||
.digitalCrownAccessory(.hidden)
|
||||
.onChange(of: crownValue) { old, new in
|
||||
// A jump across the whole range is the value wrapping, not a turn.
|
||||
let delta = new - old
|
||||
if abs(delta) < Self.crownRange { pad.crownTurned(by: delta) }
|
||||
}
|
||||
// A touch-up also clears this, which arrives late enough to fall inside the next
|
||||
// touch of a quick double-tap; the pad checks which touch it's being told about.
|
||||
.onChange(of: touchStart) { old, new in
|
||||
if new == nil, let old { pad.touchWentAway(startedAt: old) }
|
||||
}
|
||||
.onChange(of: scenePhase) { _, phase in
|
||||
if phase == .active { crownFocused = true } else { pad.touchCancelled() }
|
||||
}
|
||||
.onAppear { crownFocused = true }
|
||||
}
|
||||
|
||||
private var padSurface: some View {
|
||||
Color.black
|
||||
.contentShape(Rectangle())
|
||||
.gesture(
|
||||
DragGesture(minimumDistance: 0, coordinateSpace: .local)
|
||||
.updating($touchStart) { value, state, _ in
|
||||
if state == nil { state = value.time }
|
||||
}
|
||||
.onChanged { pad.touchChanged(start: $0.startLocation, location: $0.location, time: $0.time) }
|
||||
.onEnded { pad.touchEnded(location: $0.location) }
|
||||
)
|
||||
.accessibilityIdentifier("pad")
|
||||
}
|
||||
|
||||
/**
|
||||
The double-tap hand gesture (Series 9, Ultra 2, SE 3 and later) selects. It needs a
|
||||
control to attach to, and the pad surface is a gesture rather than a control,
|
||||
so this one sits underneath everything as a transparent stand-in.
|
||||
*/
|
||||
@ViewBuilder
|
||||
private var primaryActionShortcut: some View {
|
||||
if #available(watchOS 11.0, *) {
|
||||
Button("Select") { pad.click() }
|
||||
.buttonStyle(.plain)
|
||||
.handGestureShortcut(.primaryAction)
|
||||
.frame(width: 1, height: 1)
|
||||
.opacity(0.01)
|
||||
.allowsHitTesting(false)
|
||||
.accessibilityHidden(true)
|
||||
}
|
||||
}
|
||||
|
||||
private var clockAndStatus: some View {
|
||||
let status = padLine(state: link.state, link: link.link)
|
||||
return ZStack {
|
||||
// A large, straight clock fixed on the vertical centre of the pad.
|
||||
TimelineView(.everyMinute) { context in
|
||||
Text(context.date.formatted(.dateTime.hour(.defaultDigits(amPM: .omitted)).minute()))
|
||||
.font(.system(size: 44, weight: .regular, design: .rounded))
|
||||
.monospacedDigit()
|
||||
.foregroundStyle(.white)
|
||||
.lineLimit(1)
|
||||
.minimumScaleFactor(0.7)
|
||||
}
|
||||
if !pad.controlsVisible {
|
||||
// Offset rather than stacked, so the clock stays put whatever this says.
|
||||
VStack(spacing: 0) {
|
||||
Text(status.text)
|
||||
.font(.headline)
|
||||
.foregroundStyle(statusColor(status.tone))
|
||||
.accessibilityIdentifier("padStatus")
|
||||
if let detail = status.detail {
|
||||
Text(detail)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
}
|
||||
}
|
||||
.lineLimit(1)
|
||||
.minimumScaleFactor(0.7)
|
||||
.padding(.horizontal, 12)
|
||||
.offset(y: 46)
|
||||
.transition(.opacity)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func statusColor(_ tone: StatusTone) -> Color {
|
||||
if isDimmed { return .gray }
|
||||
return tone == .good ? .white : tone.color
|
||||
}
|
||||
|
||||
private var tray: some View {
|
||||
VStack {
|
||||
Spacer()
|
||||
HStack(spacing: 6) {
|
||||
TrayButton(symbol: "sparkles", label: "Assistant") { openFromTray(.assistant) }
|
||||
TextFieldLink(prompt: Text("Type into app")) {
|
||||
TrayIcon(symbol: "keyboard")
|
||||
} onSubmit: { text in
|
||||
send(typed: text)
|
||||
}
|
||||
.buttonStyle(.plain)
|
||||
.accessibilityLabel("Type into app")
|
||||
.accessibilityIdentifier("Type into app")
|
||||
TrayButton(symbol: "square.grid.2x2", label: "Apps") { openFromTray(.apps) }
|
||||
TrayButton(symbol: "ellipsis", label: "Status and settings") { openFromTray(.status) }
|
||||
}
|
||||
.padding(.bottom, 10)
|
||||
// A swipe down that starts on a button dismisses the tray; a tap stays the button's.
|
||||
.simultaneousGesture(
|
||||
DragGesture(minimumDistance: 12).onEnded { value in
|
||||
if value.translation.height > abs(value.translation.width) { pad.dismissControls() }
|
||||
}
|
||||
)
|
||||
}
|
||||
.transition(.move(edge: .bottom).combined(with: .opacity))
|
||||
}
|
||||
|
||||
/** The tray has done its job: coming back should show the pad's status, not the buttons. */
|
||||
private func openFromTray(_ destination: Destination) {
|
||||
pad.controlsVisible = false
|
||||
open(destination)
|
||||
}
|
||||
|
||||
private func send(typed text: String) {
|
||||
let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
|
||||
guard !trimmed.isEmpty else { return }
|
||||
Haptics(prefs: prefs).click()
|
||||
link.sendText(trimmed)
|
||||
}
|
||||
|
||||
/** Far more detents than a session will ever turn; only the changes matter. */
|
||||
private static let crownRange = 1_000_000.0
|
||||
}
|
||||
|
||||
private struct TrayButton: View {
|
||||
let symbol: String
|
||||
let label: String
|
||||
let action: () -> Void
|
||||
|
||||
var body: some View {
|
||||
Button(action: action) { TrayIcon(symbol: symbol) }
|
||||
.buttonStyle(.plain)
|
||||
.accessibilityLabel(label)
|
||||
.accessibilityIdentifier(label)
|
||||
}
|
||||
}
|
||||
|
||||
private struct TrayIcon: View {
|
||||
let symbol: String
|
||||
|
||||
var body: some View {
|
||||
Image(systemName: symbol)
|
||||
.font(.system(size: 16, weight: .medium))
|
||||
.foregroundStyle(.white)
|
||||
.frame(width: 36, height: 36)
|
||||
.background(Circle().fill(Color(white: 0.2)))
|
||||
}
|
||||
}
|
||||
@@ -1,372 +0,0 @@
|
||||
import SwiftUI
|
||||
|
||||
extension StatusTone {
|
||||
var color: Color {
|
||||
switch self {
|
||||
case .good: return Color(red: 0.48, green: 0.85, blue: 0.56)
|
||||
case .busy: return Color(red: 0.95, green: 0.76, blue: 0.31)
|
||||
case .off: return Color(white: 0.54)
|
||||
case .problem: return Color(red: 1.0, green: 0.54, blue: 0.5)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** A transient pill at the bottom of the screen: ack failures and confirmations. */
|
||||
struct NoticeOverlay: View {
|
||||
let notice: Notice?
|
||||
|
||||
var body: some View {
|
||||
Group {
|
||||
if let notice {
|
||||
Text(notice.text)
|
||||
.font(.caption2)
|
||||
.multilineTextAlignment(.center)
|
||||
.lineLimit(2)
|
||||
.foregroundStyle(notice.isError ? Color(red: 1, green: 0.71, blue: 0.66) : .white)
|
||||
.padding(.horizontal, 10)
|
||||
.padding(.vertical, 5)
|
||||
.background(
|
||||
RoundedRectangle(cornerRadius: 12)
|
||||
.fill(notice.isError ? Color(red: 0.29, green: 0.12, blue: 0.1) : Color(white: 0.16))
|
||||
)
|
||||
.padding(.horizontal, 8)
|
||||
.padding(.bottom, 4)
|
||||
.transition(.opacity)
|
||||
.accessibilityIdentifier("notice")
|
||||
}
|
||||
}
|
||||
.animation(.easeOut(duration: 0.15), value: notice?.id)
|
||||
.allowsHitTesting(false)
|
||||
}
|
||||
}
|
||||
|
||||
/** A list row: a title with an optional smaller line beneath it. */
|
||||
private struct RowLabel: View {
|
||||
let title: String
|
||||
var detail: String?
|
||||
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: 1) {
|
||||
Text(title).lineLimit(1)
|
||||
if let detail {
|
||||
Text(detail).font(.caption2).foregroundStyle(.secondary).lineLimit(1)
|
||||
}
|
||||
}
|
||||
.frame(maxWidth: .infinity, alignment: .leading)
|
||||
}
|
||||
}
|
||||
|
||||
private struct SectionHeader: View {
|
||||
let title: String
|
||||
init(_ title: String) { self.title = title }
|
||||
|
||||
var body: some View {
|
||||
Text(title)
|
||||
.font(.footnote)
|
||||
.foregroundStyle(.secondary)
|
||||
.frame(maxWidth: .infinity, alignment: .leading)
|
||||
.padding(.top, 6)
|
||||
.padding(.leading, 4)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Apps
|
||||
|
||||
/**
|
||||
The glasses' sidebar and launcher, on the wrist: open windows first (tap to bring
|
||||
one to the front, × to close it), then every launchable app.
|
||||
*/
|
||||
struct AppsScreen: View {
|
||||
@Environment(PhoneLink.self) private var link
|
||||
@Environment(WatchPrefs.self) private var prefs
|
||||
@Environment(\.dismiss) private var dismiss
|
||||
|
||||
var body: some View {
|
||||
let windows = link.state?.windows ?? []
|
||||
let apps = link.state?.apps ?? []
|
||||
let onScreen = windows.filter(\.focused)
|
||||
let others = windows.filter { !$0.focused }
|
||||
ScrollView {
|
||||
LazyVStack(spacing: 4) {
|
||||
if !onScreen.isEmpty {
|
||||
SectionHeader("On screen")
|
||||
ForEach(onScreen) { windowRow($0) }
|
||||
}
|
||||
if !others.isEmpty {
|
||||
SectionHeader("Also open")
|
||||
ForEach(others) { windowRow($0) }
|
||||
}
|
||||
SectionHeader(apps.isEmpty ? "No app list yet" : "Launch")
|
||||
ForEach(apps) { app in
|
||||
Button {
|
||||
Haptics(prefs: prefs).click()
|
||||
link.sendCommand(PhoneCommand.launchApp, extras: ["appId": app.appId])
|
||||
dismiss()
|
||||
} label: {
|
||||
RowLabel(title: app.title)
|
||||
}
|
||||
.accessibilityIdentifier("app:\(app.appId)")
|
||||
}
|
||||
if apps.isEmpty {
|
||||
Text("Open Faceclaw on the phone and connect the glasses.")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
.multilineTextAlignment(.center)
|
||||
}
|
||||
}
|
||||
}
|
||||
.navigationTitle("Apps")
|
||||
}
|
||||
|
||||
/** One open window: tap to bring it to the front, × to close it. */
|
||||
private func windowRow(_ window: WindowEntry) -> some View {
|
||||
HStack(spacing: 4) {
|
||||
Button {
|
||||
Haptics(prefs: prefs).click()
|
||||
link.sendCommand(PhoneCommand.focusWindow, extras: ["windowId": window.windowId])
|
||||
dismiss()
|
||||
} label: {
|
||||
// The launcher's window is titled "Apps" on the glasses; here
|
||||
// that would read as this very screen.
|
||||
RowLabel(
|
||||
title: window.appId == "launcher" ? "Launcher" : window.title,
|
||||
detail: window.acceptsText ? "takes typed text" : nil
|
||||
)
|
||||
}
|
||||
.tint(window.focused ? StatusTone.good.color : nil)
|
||||
if window.closeable {
|
||||
Button {
|
||||
Haptics(prefs: prefs).click()
|
||||
link.sendCommand(PhoneCommand.closeWindow, extras: ["windowId": window.windowId])
|
||||
} label: {
|
||||
Image(systemName: "xmark").font(.system(size: 12, weight: .semibold))
|
||||
}
|
||||
.frame(width: 40)
|
||||
.accessibilityLabel("Close \(window.title)")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Assistant
|
||||
|
||||
/**
|
||||
Ask the assistant from the wrist (the system text sheet, which offers dictation)
|
||||
and read its reply here as it streams, mirrored from the glasses overlay. "Hey
|
||||
Even" instead uses the glasses' own microphone and voice dialog.
|
||||
*/
|
||||
struct AssistantScreen: View {
|
||||
@Environment(PhoneLink.self) private var link
|
||||
@Environment(WatchPrefs.self) private var prefs
|
||||
|
||||
var body: some View {
|
||||
let available = link.state?.assistantAvailable != false
|
||||
let mirror = link.assistant
|
||||
let haptics = Haptics(prefs: prefs)
|
||||
ScrollView {
|
||||
VStack(spacing: 6) {
|
||||
TextFieldLink(prompt: Text("Ask the assistant")) {
|
||||
Label("Ask", systemImage: "mic.fill").frame(maxWidth: .infinity)
|
||||
} onSubmit: { text in
|
||||
let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
|
||||
guard !trimmed.isEmpty else { return }
|
||||
haptics.click()
|
||||
link.sendAssistantQuery(trimmed)
|
||||
}
|
||||
.disabled(!available)
|
||||
.accessibilityIdentifier("assistantAsk")
|
||||
|
||||
Text(phaseLabel(mirror.phase, available: available))
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.multilineTextAlignment(.center)
|
||||
.accessibilityIdentifier("assistantPhase")
|
||||
|
||||
if !mirror.text.isEmpty {
|
||||
Text(mirror.text)
|
||||
.font(.body)
|
||||
.frame(maxWidth: .infinity, alignment: .leading)
|
||||
.padding(.horizontal, 4)
|
||||
}
|
||||
|
||||
Button {
|
||||
haptics.click()
|
||||
link.sendGesture(.wakeword)
|
||||
} label: {
|
||||
RowLabel(title: "“Hey Even”", detail: "uses the glasses mic")
|
||||
}
|
||||
|
||||
if mirror.phase != "idle" {
|
||||
Button(mirror.phase == "thinking" || mirror.phase == "streaming" ? "Cancel" : "Dismiss") {
|
||||
haptics.click()
|
||||
link.sendCommand(PhoneCommand.closeAssistant)
|
||||
link.clearAssistant()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
.navigationTitle("Assistant")
|
||||
// A finished reply deserves a nudge: the wrist may be down while it streams.
|
||||
.onChange(of: mirror.phase) { _, phase in
|
||||
if phase == "done" || phase == "error" { haptics.done() }
|
||||
}
|
||||
}
|
||||
|
||||
private func phaseLabel(_ phase: String, available: Bool) -> String {
|
||||
switch phase {
|
||||
case "thinking": return "Thinking…"
|
||||
case "streaming": return "Replying…"
|
||||
case "error": return "Error"
|
||||
case "done": return "Reply"
|
||||
default: return available ? "Ask something" : "Set up the assistant in Faceclaw's Settings"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Status
|
||||
|
||||
/** Glasses and phone status, with the connection / display / lock switches. */
|
||||
struct StatusScreen: View {
|
||||
@Environment(PhoneLink.self) private var link
|
||||
@Environment(WatchPrefs.self) private var prefs
|
||||
let openSettings: () -> Void
|
||||
|
||||
var body: some View {
|
||||
let state = link.state
|
||||
let connected = state?.connected == true
|
||||
let takesInput = state?.takesInput == true
|
||||
let haptics = Haptics(prefs: prefs)
|
||||
ScrollView {
|
||||
VStack(spacing: 4) {
|
||||
SectionHeader("Glasses")
|
||||
Button {
|
||||
haptics.click()
|
||||
link.sendCommand(connected ? PhoneCommand.disconnect : PhoneCommand.connect)
|
||||
} label: {
|
||||
RowLabel(title: connectionLabel(state), detail: connected ? "tap to disconnect" : "tap to connect")
|
||||
}
|
||||
.tint(connected ? StatusTone.good.color : nil)
|
||||
.disabled(link.link.appRunning == false)
|
||||
|
||||
let screenOn = state?.screenOn == true
|
||||
Button {
|
||||
haptics.click()
|
||||
link.sendCommand(screenOn ? PhoneCommand.sleep : PhoneCommand.wake)
|
||||
} label: {
|
||||
RowLabel(title: screenOn ? "Display on" : "Display off", detail: screenOn ? "tap to turn off" : "tap to wake")
|
||||
}
|
||||
.disabled(!takesInput || state?.locked == true)
|
||||
|
||||
let locked = state?.locked == true
|
||||
Button {
|
||||
haptics.click()
|
||||
link.sendCommand(locked ? PhoneCommand.unlock : PhoneCommand.lock)
|
||||
} label: {
|
||||
RowLabel(title: locked ? "Locked" : "Unlocked", detail: lockDetail(locked: locked, state: state))
|
||||
}
|
||||
.disabled(!takesInput || (locked && state?.canUnlock == false))
|
||||
|
||||
if let foreground = state?.foreground {
|
||||
Button {
|
||||
haptics.click()
|
||||
link.sendCommand(PhoneCommand.sidebar)
|
||||
} label: {
|
||||
RowLabel(title: "On screen: \(foreground.title)", detail: "tap to open the sidebar")
|
||||
}
|
||||
.disabled(!takesInput)
|
||||
}
|
||||
|
||||
SectionHeader("Phone")
|
||||
Button {
|
||||
haptics.click()
|
||||
link.refresh()
|
||||
} label: {
|
||||
Label {
|
||||
RowLabel(title: phoneLabel, detail: phoneDetail(state))
|
||||
} icon: {
|
||||
Image(systemName: "arrow.clockwise")
|
||||
}
|
||||
}
|
||||
|
||||
if state?.remoteEnabled == false {
|
||||
Text("Watch control is turned off in Faceclaw's Settings > Watch.")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
.multilineTextAlignment(.center)
|
||||
}
|
||||
|
||||
Button(action: openSettings) {
|
||||
Label("Watch settings", systemImage: "gearshape").frame(maxWidth: .infinity, alignment: .leading)
|
||||
}
|
||||
}
|
||||
}
|
||||
.navigationTitle("Status")
|
||||
}
|
||||
|
||||
private func connectionLabel(_ state: PhoneState?) -> String {
|
||||
guard let state else { return "No status yet" }
|
||||
if state.charging || state.phase == "charging" { return "Charging" }
|
||||
if state.connected { return "Connected" }
|
||||
switch state.phase {
|
||||
case "connecting": return "Connecting…"
|
||||
case "retrying": return "Reconnecting…"
|
||||
case "disconnecting": return "Disconnecting…"
|
||||
default: return state.preview ? "Phone preview" : "Disconnected"
|
||||
}
|
||||
}
|
||||
|
||||
private func lockDetail(locked: Bool, state: PhoneState?) -> String {
|
||||
if locked && state?.canUnlock == false { return "unlock from the phone" }
|
||||
return locked ? "tap to unlock" : "tap to lock"
|
||||
}
|
||||
|
||||
private var phoneLabel: String {
|
||||
let status = link.link
|
||||
if !status.phoneAppInstalled { return "Faceclaw not installed" }
|
||||
if !status.phoneReachable { return "No phone connected" }
|
||||
if status.appRunning == false { return "Faceclaw not running" }
|
||||
return "iPhone"
|
||||
}
|
||||
|
||||
private func phoneDetail(_ state: PhoneState?) -> String {
|
||||
let status = link.link
|
||||
if !status.phoneAppInstalled { return "install it on the phone" }
|
||||
if !status.phoneReachable { return "check Bluetooth" }
|
||||
if status.appRunning == false { return "open it on the phone" }
|
||||
if let version = state?.version, !version.isEmpty { return "Faceclaw v\(version)" }
|
||||
return "tap to refresh"
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Settings
|
||||
|
||||
/** Watch-local preferences: feel of the crown. */
|
||||
struct SettingsScreen: View {
|
||||
@Environment(WatchPrefs.self) private var prefs
|
||||
|
||||
var body: some View {
|
||||
ScrollView {
|
||||
VStack(spacing: 4) {
|
||||
Button {
|
||||
prefs.crownSensitivity = prefs.crownSensitivity.next
|
||||
} label: {
|
||||
RowLabel(title: "Crown sensitivity", detail: prefs.crownSensitivity.rawValue)
|
||||
}
|
||||
Text("Vibration and sound effects are in Settings > Watch on the glasses.")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
.multilineTextAlignment(.center)
|
||||
.padding(.top, 6)
|
||||
Text("To keep the remote open between glances, set Settings > General > Return to Clock > Faceclaw on the watch.")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
.multilineTextAlignment(.center)
|
||||
.padding(.top, 6)
|
||||
Text("Faceclaw watch v\(Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "?")")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(.secondary)
|
||||
}
|
||||
}
|
||||
.navigationTitle("Settings")
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
import Foundation
|
||||
import WatchKit
|
||||
|
||||
/** The watch's own charge level and charging state, for the glasses' battery indicators. */
|
||||
struct WatchBatteryReading: Equatable {
|
||||
var battery: Int?
|
||||
var charging: Bool
|
||||
|
||||
/** `at` lets the phone discount a report it finds long after it was left in the application context. */
|
||||
func payload(at date: Date) -> [String: Any] {
|
||||
[
|
||||
"battery": battery ?? NSNull(),
|
||||
"charging": charging,
|
||||
"at": Int64(date.timeIntervalSince1970 * 1000),
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
enum WatchBattery {
|
||||
/** The `.backgroundTask(.appRefresh(...))` identifier. */
|
||||
static let refreshIdentifier = "battery"
|
||||
|
||||
private static let refreshInterval: TimeInterval = 30 * 60
|
||||
|
||||
@MainActor
|
||||
static func read() -> WatchBatteryReading {
|
||||
let device = WKInterfaceDevice.current()
|
||||
device.isBatteryMonitoringEnabled = true
|
||||
// Unknown (the simulator, or just after enabling monitoring) is not a reading of 0%.
|
||||
let level = device.batteryLevel
|
||||
let known = device.batteryState != .unknown && level >= 0
|
||||
let percent = known ? min(100, Int((level * 100).rounded())) : nil
|
||||
return WatchBatteryReading(
|
||||
battery: percent,
|
||||
charging: device.batteryState == .charging || device.batteryState == .full
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
A closed app can't answer the phone's battery polls, so it asks to be woken
|
||||
now and then to leave a report behind. The system decides when, and may
|
||||
decline; the phone discards the level once it goes stale.
|
||||
*/
|
||||
@MainActor
|
||||
static func scheduleBackgroundRefresh() {
|
||||
WKApplication.shared().scheduleBackgroundRefresh(
|
||||
withPreferredDate: Date(timeIntervalSinceNow: refreshInterval),
|
||||
userInfo: refreshIdentifier as NSString
|
||||
) { _ in }
|
||||
}
|
||||
}
|
||||
@@ -1,100 +0,0 @@
|
||||
import Foundation
|
||||
import Observation
|
||||
import SwiftUI
|
||||
import WatchKit
|
||||
|
||||
enum CrownSensitivity: String, CaseIterable {
|
||||
case low = "Low"
|
||||
case normal = "Normal"
|
||||
case high = "High"
|
||||
|
||||
var next: CrownSensitivity {
|
||||
let all = Self.allCases
|
||||
return all[(all.firstIndex(of: self)! + 1) % all.count]
|
||||
}
|
||||
|
||||
var digitalCrown: DigitalCrownRotationalSensitivity {
|
||||
switch self {
|
||||
case .low: return .low
|
||||
case .normal: return .medium
|
||||
case .high: return .high
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Crown sensitivity is the watch's own. Vibration and sound follow Settings > Watch on
|
||||
the glasses, through the mirrored state, which the application context keeps for
|
||||
when the phone is out of reach.
|
||||
*/
|
||||
@MainActor
|
||||
@Observable
|
||||
final class WatchPrefs {
|
||||
/** Confirm each gesture sent, and tick on crown detents. */
|
||||
var haptics: Bool { link.state?.vibrateOnInput ?? true }
|
||||
|
||||
/** Give each gesture its own cue, sound included; see Haptics. */
|
||||
var soundEffects: Bool { link.state?.soundEffects ?? false }
|
||||
|
||||
var crownSensitivity: CrownSensitivity {
|
||||
didSet { store.set(crownSensitivity.rawValue, forKey: Keys.crown) }
|
||||
}
|
||||
|
||||
@ObservationIgnored private let link: PhoneLink
|
||||
@ObservationIgnored private let store = UserDefaults.standard
|
||||
|
||||
private enum Keys {
|
||||
static let crown = "crownSensitivity"
|
||||
}
|
||||
|
||||
init(link: PhoneLink) {
|
||||
self.link = link
|
||||
crownSensitivity = store.string(forKey: Keys.crown).flatMap(CrownSensitivity.init(rawValue:)) ?? .normal
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
The wrist's confirmation of what was sent. watchOS has no call that plays only a
|
||||
vibration or only a sound: every WKHapticType is both, and only the watch's own Silent
|
||||
Mode mutes the sound. So sound effects on means the full set of cues, which vibrate
|
||||
whatever the vibrate setting says, and off means `.click` for everything. Whether
|
||||
`.click` is truly silent is unconfirmed; see notes/apple-watch-followups.md.
|
||||
*/
|
||||
@MainActor
|
||||
struct Haptics {
|
||||
let prefs: WatchPrefs
|
||||
|
||||
/** A sent click, swipe or command. */
|
||||
func click() { play(.click) }
|
||||
/** A sent double-click: back. */
|
||||
func doubleClick() { play(.directionDown) }
|
||||
/** The start of a hold. */
|
||||
func heavy() { play(.start) }
|
||||
/** A reply finished arriving. */
|
||||
func done() { play(.success) }
|
||||
|
||||
/** The phone refused or did not answer; always plays, and never feels like a sent gesture. */
|
||||
func error() {
|
||||
let device = WKInterfaceDevice.current()
|
||||
if prefs.soundEffects {
|
||||
device.play(.failure)
|
||||
return
|
||||
}
|
||||
device.play(.click)
|
||||
Task {
|
||||
try? await Task.sleep(nanoseconds: Self.errorTapGapNanos)
|
||||
device.play(.click)
|
||||
}
|
||||
}
|
||||
|
||||
private func play(_ cue: WKHapticType) {
|
||||
if prefs.soundEffects {
|
||||
WKInterfaceDevice.current().play(cue)
|
||||
} else if prefs.haptics {
|
||||
WKInterfaceDevice.current().play(.click)
|
||||
}
|
||||
}
|
||||
|
||||
/** Apple's documentation asks for at least 100 ms between haptics. */
|
||||
private static let errorTapGapNanos: UInt64 = 150_000_000
|
||||
}
|
||||
@@ -1,168 +0,0 @@
|
||||
import XCTest
|
||||
|
||||
/**
|
||||
Drives the real app on a watch simulator. The screens' own behaviour needs only
|
||||
the watch; the tests that talk to the phone need Faceclaw running on the paired
|
||||
iPhone simulator, and skip themselves otherwise. See apple-watch/README.md.
|
||||
*/
|
||||
@MainActor
|
||||
final class PadUITests: XCTestCase {
|
||||
private var app: XCUIApplication!
|
||||
|
||||
override func setUp() async throws {
|
||||
continueAfterFailure = false
|
||||
app = XCUIApplication()
|
||||
app.launch()
|
||||
XCTAssertTrue(pad.waitForExistence(timeout: 10))
|
||||
}
|
||||
|
||||
private var pad: XCUIElement { app.descendants(matching: .any)["pad"] }
|
||||
private var status: XCUIElement { app.staticTexts["padStatus"] }
|
||||
|
||||
/**
|
||||
The middle of the pad. An element's own tap() lands on its accessibility activation
|
||||
point, near the top-left corner, and holding up there is the system's gesture for
|
||||
pulling down Notification Center.
|
||||
*/
|
||||
private var padCenter: XCUICoordinate {
|
||||
pad.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
|
||||
}
|
||||
|
||||
private func swipe(_ dx: CGFloat, _ dy: CGFloat) {
|
||||
padCenter.press(forDuration: 0.02, thenDragTo: pad.coordinate(withNormalizedOffset: CGVector(dx: 0.5 + dx, dy: 0.5 + dy)))
|
||||
}
|
||||
|
||||
private func revealTray() {
|
||||
// From the very bottom edge, which is what makes it the reveal gesture and not a scroll.
|
||||
let start = pad.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.97))
|
||||
let end = pad.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.5))
|
||||
start.press(forDuration: 0.02, thenDragTo: end)
|
||||
}
|
||||
|
||||
private func requirePhone() throws {
|
||||
let deadline = Date().addingTimeInterval(15)
|
||||
while Date() < deadline {
|
||||
let text = status.exists ? status.label : ""
|
||||
if !text.isEmpty && !text.contains("phone") && !text.contains("Install") { return }
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(0.25))
|
||||
}
|
||||
throw XCTSkip("Faceclaw isn't answering on a paired iPhone: \(status.label)")
|
||||
}
|
||||
|
||||
func testTrayRevealsAndOpensEveryScreen() {
|
||||
revealTray()
|
||||
let apps = app.buttons["Apps"]
|
||||
XCTAssertTrue(apps.waitForExistence(timeout: 3), "the tray should reveal from the bottom edge")
|
||||
XCTAssertTrue(app.buttons["Assistant"].exists)
|
||||
XCTAssertTrue(app.buttons["Status and settings"].exists)
|
||||
XCTAssertTrue(app.descendants(matching: .any)["Type into app"].exists)
|
||||
|
||||
apps.tap()
|
||||
XCTAssertTrue(app.staticTexts["Apps"].waitForExistence(timeout: 3))
|
||||
}
|
||||
|
||||
func testStatusScreenReachesSettings() {
|
||||
revealTray()
|
||||
let more = app.buttons["Status and settings"]
|
||||
XCTAssertTrue(more.waitForExistence(timeout: 3))
|
||||
more.tap()
|
||||
let settings = app.buttons["Watch settings"]
|
||||
XCTAssertTrue(settings.waitForExistence(timeout: 3))
|
||||
settings.tap()
|
||||
XCTAssertTrue(app.switches["Vibrate on input"].waitForExistence(timeout: 3))
|
||||
}
|
||||
|
||||
/** The whole path: pad gesture -> phone -> shell -> mirrored state -> pad status line. */
|
||||
func testGesturesReachThePhoneAndComeBackAsState() throws {
|
||||
try requirePhone()
|
||||
let launcher = status.label
|
||||
XCTAssertFalse(launcher.isEmpty)
|
||||
|
||||
// Open an app through the remote and watch the foreground title follow it.
|
||||
revealTray()
|
||||
let appsButton = app.buttons["Apps"]
|
||||
XCTAssertTrue(appsButton.waitForExistence(timeout: 3))
|
||||
appsButton.tap()
|
||||
let calculator = app.buttons["app:calculator"]
|
||||
XCTAssertTrue(calculator.waitForExistence(timeout: 5), "the phone's app list should be mirrored")
|
||||
calculator.tap()
|
||||
|
||||
XCTAssertTrue(status.waitForExistence(timeout: 5))
|
||||
let opened = NSPredicate(format: "label == %@", "Calculator")
|
||||
expectation(for: opened, evaluatedWith: status)
|
||||
waitForExpectations(timeout: 10)
|
||||
|
||||
// Every other gesture goes the same way, and the phone answers each. A silent phone
|
||||
// would raise "No reply from the phone" within seconds; the gestures themselves are
|
||||
// checked on the phone's side by apple-watch/README.md's log command.
|
||||
padCenter.tap()
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(0.6))
|
||||
padCenter.doubleTap()
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(0.6))
|
||||
padCenter.press(forDuration: 0.8)
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(0.6))
|
||||
// Tap then hold: the first touch's end must not cancel the second, however close they are.
|
||||
padCenter.tap()
|
||||
padCenter.press(forDuration: 0.8)
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(0.6))
|
||||
swipe(-0.35, 0)
|
||||
swipe(0.35, 0)
|
||||
swipe(0, -0.35)
|
||||
swipe(0, 0.35)
|
||||
XCUIDevice.shared.rotateDigitalCrown(delta: 1)
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(5))
|
||||
let notice = app.descendants(matching: .any)["notice"]
|
||||
XCTAssertFalse(notice.exists && notice.label.contains("reply"), "the phone should answer every gesture")
|
||||
}
|
||||
|
||||
/** The system text sheet: the same path dictation takes, typed instead. */
|
||||
private func enterText(_ text: String) {
|
||||
let field = app.textViews.firstMatch
|
||||
XCTAssertTrue(field.waitForExistence(timeout: 5))
|
||||
field.typeText(text)
|
||||
app.buttons["Done"].tap()
|
||||
}
|
||||
|
||||
func testTypingReachesTheForegroundApp() throws {
|
||||
try requirePhone()
|
||||
revealTray()
|
||||
let apps = app.buttons["Apps"]
|
||||
XCTAssertTrue(apps.waitForExistence(timeout: 3))
|
||||
apps.tap()
|
||||
let calculator = app.buttons["app:calculator"]
|
||||
XCTAssertTrue(calculator.waitForExistence(timeout: 5))
|
||||
calculator.tap()
|
||||
XCTAssertTrue(status.waitForExistence(timeout: 5))
|
||||
expectation(for: NSPredicate(format: "label == %@", "Calculator"), evaluatedWith: status)
|
||||
waitForExpectations(timeout: 10)
|
||||
|
||||
revealTray()
|
||||
let type = app.descendants(matching: .any)["Type into app"]
|
||||
XCTAssertTrue(type.waitForExistence(timeout: 3))
|
||||
type.tap()
|
||||
enterText("1234")
|
||||
|
||||
// A refusal or a dropped message would show an error pill within the ack timeout.
|
||||
RunLoop.current.run(until: Date().addingTimeInterval(6))
|
||||
let notice = app.descendants(matching: .any)["notice"]
|
||||
XCTAssertFalse(notice.exists, "typing should be accepted: \(notice.exists ? notice.label : "")")
|
||||
}
|
||||
|
||||
/** A query goes out, and whatever the assistant does comes back as events. */
|
||||
func testAssistantRepliesAreMirrored() throws {
|
||||
try requirePhone()
|
||||
revealTray()
|
||||
let assistant = app.buttons["Assistant"]
|
||||
XCTAssertTrue(assistant.waitForExistence(timeout: 3))
|
||||
assistant.tap()
|
||||
let phase = app.staticTexts["assistantPhase"]
|
||||
XCTAssertTrue(phase.waitForExistence(timeout: 3))
|
||||
if phase.label.contains("Set up") { throw XCTSkip("No assistant on the phone") }
|
||||
app.descendants(matching: .any)["assistantAsk"].tap()
|
||||
enterText("hello")
|
||||
// The phone's first event replaces the watch's optimistic "Thinking…" with its own, then
|
||||
// a real reply or, with no model on a simulator, an error: both prove the channel.
|
||||
expectation(for: NSPredicate(format: "label == %@ OR label == %@", "Reply", "Error"), evaluatedWith: phase)
|
||||
waitForExpectations(timeout: 60)
|
||||
}
|
||||
}
|
||||
@@ -1,171 +0,0 @@
|
||||
# Faceclaw for Apple Watch
|
||||
|
||||
A watch remote for Faceclaw on iOS: everything the Even R1 ring can do, plus the
|
||||
things it can't. It's the same remote as the [Wear OS app](../wear/README.md), and
|
||||
speaks the [same protocol](../wear/PROTOCOL.md), so the glasses treat them alike.
|
||||
Needs watchOS 10 or later (Series 6, SE 2, Ultra and newer) and is a remote, not a
|
||||
standalone app: without Faceclaw on the iPhone it only tells you to install it.
|
||||
|
||||
## What it does
|
||||
|
||||
**The pad** (the home screen; the whole display is the touch surface):
|
||||
|
||||
| On the watch | On the glasses |
|
||||
| --- | --- |
|
||||
| tap | select |
|
||||
| double-tap | **back**, everywhere: closes menus, leaves a settings column, leaves a folder or the launcher grid, returns to the sidebar (and from the sidebar turns the display off, as the ring does) |
|
||||
| press and hold | the system menu: Focus app switcher, Voice input, Close window (held until you lift your finger; games that use a long press as a move get it instead) |
|
||||
| tap, then press and hold | the app's context menu |
|
||||
| swipe ↑ ↓ ← → | **spatial navigation**: the launcher moves one app by a row or a column, the settings panel moves between its columns and down its lists, the sidebar moves up and down, Music skips tracks. Right goes *into* things and left comes back *out*. Anywhere without a spatial meaning, up/down scroll, right selects and left goes back. One step per swipe. |
|
||||
| turn the crown | previous / next; clockwise is previous. Don't count on it: on a real watch the crown has triggered watchOS's own actions instead of reaching the app. Sensitivity is in the watch's own settings. |
|
||||
| the Double Tap hand gesture (Series 9, Ultra 2, SE 3 and later, watchOS 11) | select |
|
||||
|
||||
Swipe up from the bottom edge to reveal the buttons, and down from them to hide them:
|
||||
|
||||
- **Assistant** — ask from the wrist using the system text sheet, which offers
|
||||
dictation, and read the reply as it streams. The watch buzzes when it finishes. A
|
||||
reply that finishes with your wrist down is waiting when you raise it. "Hey Even"
|
||||
instead opens the glasses' own voice dialog.
|
||||
- **Type into app** — dictate or type into the foreground app, such as the terminal.
|
||||
- **Apps** — the open windows (tap to switch, × to close) and the full launcher,
|
||||
including installed EvenHub apps.
|
||||
- **Status** — connection, display on/off, lock/unlock, whether Faceclaw is
|
||||
answering on the iPhone, and the watch's settings.
|
||||
|
||||
Phone-side switches live in Faceclaw's Settings > Watch, including vibration and
|
||||
sound effects. While the glasses display
|
||||
is off, a double-tap wakes it and a tap or hold shows the Glanceboard; other gestures
|
||||
do nothing. The watch buzzes differently when the phone refuses or doesn't answer a
|
||||
gesture, and the pill at the bottom says why.
|
||||
|
||||
With no glasses connected, the pad drives the iPhone's on-screen preview instead, so
|
||||
all of this can be tried without them.
|
||||
|
||||
### What's different from Wear OS
|
||||
|
||||
These come from what watchOS allows apps to do:
|
||||
|
||||
- **No two-finger gestures.** SwiftUI on watchOS only reports one finger.
|
||||
- **No side buttons.** The crown press and side button belong to the system.
|
||||
- **Vibration and sound come as a pair.** watchOS has no call that plays only one, and
|
||||
only the watch's own Silent Mode mutes the sound. With sound effects off, every input
|
||||
gets a light tap rather than its own cue; with them on, inputs vibrate even if
|
||||
Vibrate on input is off.
|
||||
- **The display can't be kept on.** To keep the remote open between glances, set
|
||||
Settings > General > Return to Clock > Faceclaw on the watch to a longer time.
|
||||
- **The tap that wakes the display does nothing.** The system consumes it, and an
|
||||
app can't tell it from a wrist raise, so it can't stand in for a first tap.
|
||||
- **Holding near the top edge opens Notification Center.** The system takes that
|
||||
touch after about 300 ms, and watchOS has no way to defer it. Hold lower down.
|
||||
- **The system's small clock stays in the corner**, beside the pad's large one. An
|
||||
app can't hide it.
|
||||
- **The glasses' Watch battery indicator can lag.** A closed app can't be asked for
|
||||
its level, so it reports when open and when the system grants background time. The
|
||||
phone hides a level more than 4 hours old.
|
||||
|
||||
There's no tip-tap detector like Wear OS's experimental one; Double Tap is the
|
||||
system's reliable version of the same idea.
|
||||
|
||||
## Building and installing
|
||||
|
||||
The watch app is its own Xcode project, so it can be opened and previewed alone:
|
||||
|
||||
```bash
|
||||
./build_apple_watch.sh # simulator build, no signing
|
||||
./build_apple_watch.sh --device # signed build for a real watch
|
||||
./build_apple_watch.sh --install # as --device, then installs on the paired watch
|
||||
npm run install:apple-watch # the same as --install
|
||||
```
|
||||
|
||||
**It only works with a phone app that embeds it.** The system links the two apps
|
||||
through the copy in the phone app's `Watch/` folder; install them separately and each
|
||||
reports the other as not installed. Embedding is off by default, because signing it
|
||||
needs a watch registered to your team and would break device builds for everyone
|
||||
without one. To turn it on, in `build_paths.sh`:
|
||||
|
||||
```bash
|
||||
export IOS_TEAM_ID=... # as for any iOS device build
|
||||
export FACECLAW_EMBED_WATCH=1
|
||||
```
|
||||
|
||||
Then, the first time:
|
||||
|
||||
1. Connect the iPhone, and enable Developer Mode on the watch (Settings > Privacy &
|
||||
Security; it appears after Xcode has seen the watch in Window > Devices and
|
||||
Simulators). After it restarts, accept any "Trust this computer" prompt.
|
||||
2. `./build_apple_watch.sh --install`, which registers the watch with your team and
|
||||
installs the app on it.
|
||||
3. `npm run run:ios -- --device <iphone-id> --no-hmr` builds and installs the iPhone
|
||||
app with the watch app inside.
|
||||
|
||||
Xcode has to be new enough for the watch's OS: Xcode 26.4 can't prepare a watch on
|
||||
watchOS 27 for development ("Could not support development", "doesn't have a known
|
||||
architecture"), and that also blocks registering it and installing directly. On an
|
||||
older Xcode you can still add the watch's UDID by hand at developer.apple.com and let
|
||||
the iPhone's Watch app install the embedded copy.
|
||||
|
||||
To see what the watch shows without looking at it (Xcode 27):
|
||||
|
||||
```bash
|
||||
xcrun devicectl device capture screenshot --device <watch-udid> --destination watch.png
|
||||
```
|
||||
|
||||
A hook (`scripts/apple-watch-embed.cjs`) adds the watch project to the generated iOS
|
||||
project after each prepare, and takes it back out if the setting is removed. The
|
||||
bundle ID follows `IOS_BUNDLE_ID` (the watch app's is `<that>.watchkitapp`) and the
|
||||
version follows `app/version.ts`.
|
||||
|
||||
## Testing
|
||||
|
||||
```bash
|
||||
node tests/apple-watch-native.cjs # gestures, wire format, status line, on the Mac
|
||||
node --test tests/ios-watch-remote.test.cjs # the phone side
|
||||
```
|
||||
|
||||
The UI tests drive the real app with synthesized touches on a watch simulator. Those
|
||||
that talk to the phone need Faceclaw running on the paired iPhone simulator, and skip
|
||||
themselves otherwise:
|
||||
|
||||
```bash
|
||||
# Once: a watchOS simulator runtime and a pair (ids from `xcrun simctl list devices`).
|
||||
xcodebuild -downloadPlatform watchOS
|
||||
xcrun simctl pair <watch> <iphone>
|
||||
xcrun simctl boot <iphone>; xcrun simctl boot <watch>
|
||||
|
||||
# The phone app, embedding the watch app.
|
||||
FACECLAW_EMBED_WATCH=1 scripts/ios.sh build ios
|
||||
xcrun simctl install <iphone> platforms/ios/build/Debug-iphonesimulator/faceclaw.app
|
||||
xcrun simctl spawn <iphone> defaults write com.faceclaw.app onboarding.complete -bool YES
|
||||
xcrun simctl spawn <iphone> defaults write com.faceclaw.app onboarding.previewOnly -bool YES
|
||||
xcrun simctl launch <iphone> com.faceclaw.app
|
||||
|
||||
# The tests, which install the watch app themselves.
|
||||
xcodebuild test -project apple-watch/Faceclaw.xcodeproj -scheme Faceclaw \
|
||||
-destination "platform=watchOS Simulator,id=<watch>" \
|
||||
-derivedDataPath apple-watch/build CODE_SIGNING_ALLOWED=NO
|
||||
|
||||
# What the phone made of each gesture.
|
||||
xcrun simctl spawn <iphone> log show --last 5m --style compact \
|
||||
--predicate 'process == "faceclaw" AND eventMessage CONTAINS "apple-watch"'
|
||||
```
|
||||
|
||||
The simulator delivers messages in bursts about a second apart, which real hardware
|
||||
isn't expected to do; don't judge gesture latency from it. `XCUIElement.tap()` lands
|
||||
near an element's top-left corner, so tests that hold must use a coordinate.
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
- *`Timed out while attempting to establish tunnel`, or the watch stays `connecting`
|
||||
in `devicectl`* — check the watch's Wi-Fi network. It has to reach this Mac directly,
|
||||
and a watch that joined a different network on the same router fails like this, even
|
||||
though it still looks paired. It also powers down Wi-Fi when idle, so raise your
|
||||
wrist; the first connection can take a minute or two.
|
||||
- *"No phone"* — the watch can't reach the iPhone right now.
|
||||
- *"Install Faceclaw on phone"* — the system doesn't see a linked phone app: it isn't
|
||||
installed, or it was built without `FACECLAW_EMBED_WATCH=1`, or the bundle IDs differ.
|
||||
- *"Open Faceclaw on phone"* — the phone app woke for our message but its dashboard
|
||||
isn't up (for instance, onboarding isn't finished). Open it once.
|
||||
- *"The glasses are not connected"* — tap Status > Connect.
|
||||
- Nothing happens and no message: check Settings > Watch on the phone.
|
||||
|
||||
Protocol details: [wear/PROTOCOL.md](../wear/PROTOCOL.md).
|
||||
@@ -1,60 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Builds the Apple Watch app (apple-watch/).
|
||||
#
|
||||
# ./build_apple_watch.sh Simulator build; no signing needed.
|
||||
# ./build_apple_watch.sh --device Signed build for a real watch.
|
||||
# ./build_apple_watch.sh --install As --device, then installs on the paired watch.
|
||||
#
|
||||
# Signing uses IOS_TEAM_ID from build_paths.sh. The bundle ID follows IOS_BUNDLE_ID,
|
||||
# because the watch app is tied to the phone app by it. To pick among several
|
||||
# watches, set APPLE_WATCH_DEVICE_ID to its UDID there (see `xcrun devicectl list devices`).
|
||||
#
|
||||
# This is for working on the watch app alone. It can only talk to a phone app that
|
||||
# was built with FACECLAW_EMBED_WATCH=1 (see apple-watch/README.md).
|
||||
cd "$(dirname "$0")"; source scripts/before_build.sh
|
||||
set -euo pipefail
|
||||
|
||||
mode="${1:-simulator}"
|
||||
project=apple-watch/Faceclaw.xcodeproj
|
||||
derived=apple-watch/build
|
||||
|
||||
node scripts/apple-watch-embed.cjs config
|
||||
|
||||
case "$mode" in
|
||||
simulator|--simulator)
|
||||
xcodebuild -quiet -project "$project" -scheme Faceclaw -configuration Debug \
|
||||
-destination 'generic/platform=watchOS Simulator' -derivedDataPath "$derived" \
|
||||
CODE_SIGNING_ALLOWED=NO build
|
||||
echo "Built $derived/Build/Products/Debug-watchsimulator/Faceclaw.app"
|
||||
;;
|
||||
--device|--install)
|
||||
if [[ -z "${IOS_TEAM_ID:-}" ]]; then
|
||||
echo "Set IOS_TEAM_ID in build_paths.sh to sign for a real watch." >&2
|
||||
exit 1
|
||||
fi
|
||||
destination='generic/platform=watchOS'
|
||||
if [[ "$mode" == --install ]]; then
|
||||
watch="${APPLE_WATCH_DEVICE_ID:-$(scripts/apple-watch-device.sh)}"
|
||||
if [[ -z "$watch" ]]; then
|
||||
echo "No Apple Watch found. Enable Developer Mode on it, with its iPhone connected to this Mac." >&2
|
||||
exit 1
|
||||
fi
|
||||
# Naming the watch is what gets it registered with the team and into the
|
||||
# profile; a generic destination signs for whatever is registered already.
|
||||
destination="platform=watchOS,id=$watch"
|
||||
fi
|
||||
# A watch's Wi-Fi link can take minutes to wake, far past xcodebuild's default wait.
|
||||
xcodebuild -quiet -project "$project" -scheme Faceclaw -configuration Debug \
|
||||
-destination "$destination" -destination-timeout 300 -derivedDataPath "$derived" \
|
||||
-allowProvisioningUpdates -allowProvisioningDeviceRegistration build
|
||||
product="$derived/Build/Products/Debug-watchos/Faceclaw.app"
|
||||
echo "Built $product"
|
||||
if [[ "$mode" == --install ]]; then
|
||||
xcrun devicectl device install app --device "$watch" "$product"
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
echo "Usage: $0 [--device|--install]" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
@@ -11,9 +11,4 @@
|
||||
# iOS bundle ID; set one your signing team owns to sideload alongside the
|
||||
# official build (default com.faceclaw.app). Also used by the iOS config scripts.
|
||||
#export IOS_BUNDLE_ID=
|
||||
# Embed the Apple Watch app in the iOS app. Its link to the phone needs this, and
|
||||
# signing it needs a watch registered to your team, so it's off by default.
|
||||
#export FACECLAW_EMBED_WATCH=1
|
||||
# Which Apple Watch build_apple_watch.sh --install targets (default: the first found)
|
||||
#export APPLE_WATCH_DEVICE_ID=
|
||||
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
{
|
||||
"nodes": {
|
||||
"devenv": {
|
||||
"locked": {
|
||||
"dir": "src/modules",
|
||||
"lastModified": 1793731702,
|
||||
"narHash": "sha256-WlVNaWXVTYaGBNey2Z+20sY1lT7BvzJEECb+VlDDdk0=",
|
||||
"owner": "cachix",
|
||||
"repo": "devenv",
|
||||
"rev": "9655d320b8f9df74dbecf681f52a7334574606c3",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"dir": "src/modules",
|
||||
"owner": "cachix",
|
||||
"repo": "devenv",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs": {
|
||||
"inputs": {
|
||||
"nixpkgs-src": "nixpkgs-src"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1793043970,
|
||||
"narHash": "sha256-m14odYTdkBUEkJOiEYs2zjGjn8fcjvdCJsm45+k084U=",
|
||||
"owner": "cachix",
|
||||
"repo": "devenv-nixpkgs",
|
||||
"rev": "d97234e58d4e90e3bf77c082fc3b546e51200938",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "cachix",
|
||||
"ref": "rolling",
|
||||
"repo": "devenv-nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs-src": {
|
||||
"flake": false,
|
||||
"locked": {
|
||||
"lastModified": 1792812153,
|
||||
"narHash": "sha256-T2+XBfNbf9pecLUWS4+RtuVNZ3W8K5taG5QdV71mWlk=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "674a2028661e550a97400c1cc992b9cca9a668a1",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixpkgs-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"devenv": "devenv",
|
||||
"nixpkgs": "nixpkgs"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
{ pkgs, config, lib, ... }:
|
||||
{
|
||||
languages.javascript = {
|
||||
enable = true;
|
||||
package = pkgs.nodejs_22;
|
||||
};
|
||||
languages.java = {
|
||||
enable = true;
|
||||
jdk.package = pkgs.jdk21;
|
||||
lsp.enable = false;
|
||||
};
|
||||
android = {
|
||||
enable = true;
|
||||
platforms.version = [ "35" ];
|
||||
buildTools.version = [ "34.0.0" "35.0.0" "35.0.1" ];
|
||||
ndk.enable = true;
|
||||
ndk.version = [ "27.2.12479018" ];
|
||||
cmake.version = [ ];
|
||||
emulator.enable = false;
|
||||
systemImages.enable = false;
|
||||
sources.enable = false;
|
||||
};
|
||||
packages = with pkgs; [ git gh curl jq ripgrep python3 pkg-config gnumake gcc unzip zip ];
|
||||
# Gradle's downloaded aapt2 cannot run directly on NixOS.
|
||||
# Keep API 35 aapt2 for phone builds even with Wear's older tools installed.
|
||||
env.GRADLE_OPTS = lib.mkForce "-Dorg.gradle.project.android.aapt2FromMavenOverride=${config.env.ANDROID_HOME}/build-tools/35.0.0/aapt2";
|
||||
# NativeScript's doctor rejects a valid build-only SDK without an emulator.
|
||||
# enterTest below checks the actual tools used by our local builds.
|
||||
env.NS_SKIP_ENV_CHECK = "1";
|
||||
env.ANDROID_CMAKE_HOME = "${pkgs.symlinkJoin {
|
||||
name = "faceclaw-cmake";
|
||||
paths = [ pkgs.cmake pkgs.ninja ];
|
||||
}}";
|
||||
scripts.faceclaw-setup.exec = "npm ci";
|
||||
scripts.faceclaw-test.exec = "npm test";
|
||||
enterShell = ''
|
||||
export PATH="$DEVENV_ROOT/node_modules/.bin:$PATH"
|
||||
'';
|
||||
enterTest = ''
|
||||
bash "$DEVENV_ROOT/scripts/check-devenv.sh"
|
||||
'';
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
inputs:
|
||||
nixpkgs:
|
||||
url: github:cachix/devenv-nixpkgs/rolling
|
||||
nixpkgs:
|
||||
allow_unfree: true
|
||||
android_sdk:
|
||||
accept_license: true
|
||||
@@ -0,0 +1,29 @@
|
||||
# Nix development environment
|
||||
|
||||
Install Nix with flakes and devenv, then run `devenv shell` in this directory
|
||||
(or `nix run nixpkgs#devenv -- shell`). With direnv, `direnv allow` loads `.envrc`.
|
||||
The committed `devenv.lock` pins the environment inputs.
|
||||
|
||||
The environment provides Node 22/npm, Java 21, Android SDK/platform 35,
|
||||
build-tools 34.0.0 (Wear OS) and 35.0.0/35.0.1 (phone and NativeScript plugins), NDK 27, CMake,
|
||||
Git/GitHub CLI, Python and build utilities. `ANDROID_CMAKE_HOME` selects the
|
||||
Nix-patched CMake/Ninja pair for the native Android libraries (the SDK's bundled
|
||||
Ninja can crash on NixOS). Other environments keep using the SDK's CMake.
|
||||
Android SDK licenses are accepted through `devenv.yaml`. Gradle uses the
|
||||
Nix-patched SDK aapt2. Gradle itself comes from the repository's wrapper.
|
||||
The emulator and system images are omitted. `NS_SKIP_ENV_CHECK=1` bypasses
|
||||
NativeScript doctor's mandatory emulator check; `devenv test` checks the actual
|
||||
SDK/JDK build prerequisites instead.
|
||||
|
||||
Run `faceclaw-setup` (`npm ci`) once, then `faceclaw-test` (`npm test`),
|
||||
`npm run lint` and `npm run test:kotlin`. `devenv test` checks the environment.
|
||||
`bash build.sh` builds the Android app; it does not install it. On NixOS, any
|
||||
additional downloaded native executables may require the host's nix-ld support.
|
||||
iOS builds still require macOS/Xcode and are outside this Linux environment.
|
||||
|
||||
Keep machine-specific signing/device settings in the ignored `build_paths.sh`.
|
||||
Use `gh auth login` separately if GitHub CLI is not already authenticated.
|
||||
|
||||
Software tests do not validate Bluetooth behavior on physical glasses. Record
|
||||
device/firmware versions and manual results separately for hardware checks.
|
||||
Do not flash firmware during development without explicit permission.
|
||||
@@ -0,0 +1,45 @@
|
||||
# Combined release build
|
||||
|
||||
Branch: `integration/device-preferences`. It contains notification defaults and
|
||||
bulk actions, Android calendar selection, head-up wake/angle, Android 16 KiB
|
||||
page compatibility, the app switcher close menu, and multilingual Whisper
|
||||
transcription (OpenAI and on-device), per-app full screen and an independent
|
||||
per-app keep-awake switch, and explicit bulk notification dismissal.
|
||||
|
||||
The switcher change is isolated on `feat/app-switcher-close-menu`, based on
|
||||
`main`, for a future independent PR. Whisper language selection is isolated on
|
||||
`feat/whisper-languages`, also based on `main`. Full screen is isolated on
|
||||
`feat/app-fullscreen` (based on the app switcher menu branch). Bulk dismissal
|
||||
is part of `feat/notification-filter-default`. No PR was created.
|
||||
|
||||
Validation on 2026-11-06:
|
||||
|
||||
- JS/TS suite: 1,084 passed, 2 skipped, 0 failed, including full-screen layout,
|
||||
independent keep-awake persistence, idle sleep behavior, bulk dismissal and
|
||||
preservation of the stock EvenHub 576x288 logical canvas in full screen.
|
||||
- Kotlin: 272 tests passed, including multilingual Whisper file selection.
|
||||
- TypeScript `tsc --noEmit`: passed.
|
||||
- oxlint on changed TypeScript: passed.
|
||||
- APK page checker: 5 unit tests passed; all 7 packaged native libraries pass
|
||||
16 KiB LOAD/RELRO checks. APK ZIP alignment also passes.
|
||||
- Release build: passed, `debuggable=false`, signature verified and identical
|
||||
to the locally signed release previously installed on the Pixel.
|
||||
- Packaged JavaScript contains the close actions, all earlier settings and the
|
||||
multilingual Whisper preference/model download, full-screen commands and bulk
|
||||
notification dismissal and independent Keep screen awake. Signature matches
|
||||
Wear OS too.
|
||||
|
||||
Artifact: `dist/faceclaw-all-features-release.apk` (95,270,300 bytes).
|
||||
SHA-256, also saved next to the APK:
|
||||
|
||||
```text
|
||||
7a2875f512b9715e7af998f600429a3172e8428c84abf11e6badc0c2790707a6
|
||||
```
|
||||
|
||||
The APK is built for local installation with the existing local signing key.
|
||||
It has not been installed during this feature task. Manual tests on glasses
|
||||
remain pending; see [the switcher validation procedure](validation-app-switcher-menu.md)
|
||||
and [Whisper language validation](validation-whisper-languages.md),
|
||||
[full-screen validation](validation-app-fullscreen.md),
|
||||
[bulk dismissal validation](validation-dismiss-all-notifications.md), as well as
|
||||
the earlier per-feature validation documents. No firmware was flashed.
|
||||
@@ -0,0 +1,33 @@
|
||||
# Android 16 KiB page compatibility
|
||||
|
||||
The initial debug APK triggered Android's page-size compatibility warning.
|
||||
Its `libfaceclaw_llama.so` LOAD segments were aligned to 4096 bytes. The other
|
||||
six packaged arm64 libraries were aligned to 16384 bytes, and APK ZIP alignment
|
||||
already passed `zipalign -c -P 16 4`.
|
||||
|
||||
The llama JNI shared library now links with both `max-page-size=16384` and
|
||||
`common-page-size=16384`, matching the LC3 JNI library. This changes the native
|
||||
binary layout rather than hiding the compatibility warning or disabling debug.
|
||||
Gradle already tracks CMakeLists.txt as an input, and Ninja reconfigures and
|
||||
relinks existing builds after this change.
|
||||
|
||||
Reproduce the regression and artifact checks inside `devenv shell`:
|
||||
|
||||
```sh
|
||||
python3 -m unittest discover -s tests -p test_apk_pages.py
|
||||
bash build.sh
|
||||
python3 scripts/check-apk-pages.py platforms/android/app/build/outputs/apk/debug/app-debug.apk
|
||||
"$ANDROID_HOME/build-tools/35.0.1/zipalign" -c -P 16 4 platforms/android/app/build/outputs/apk/debug/app-debug.apk
|
||||
```
|
||||
|
||||
The checker rejects the initial APK and reports its misaligned llama library.
|
||||
Five unit tests cover 4 KiB rejection, 16 KiB acceptance, RELRO boundaries and
|
||||
invalid ELF program headers. APK checks inspect all arm64/x86_64 shared libraries.
|
||||
|
||||
Reference: [Android's 16 KiB guidance](https://developer.android.com/guide/practices/page-sizes).
|
||||
Static alignment and successful installation do not prove every native code
|
||||
path works on-device; voice/LLM features still require functional testing.
|
||||
|
||||
The rebuilt APK passes all seven native-library checks, ZIP alignment and APK
|
||||
signature verification. The connected Pixel 10 Pro Fold reports `getconf
|
||||
PAGE_SIZE` = 4096; actual execution with 16 KiB pages remains untested.
|
||||
@@ -0,0 +1,36 @@
|
||||
# Per-app full screen and keep awake
|
||||
|
||||
Long-press opens the system menu. Closeable apps offer Enter full screen / Exit
|
||||
full screen. The choice persists per app through the existing settings store,
|
||||
independently of global display layout and app-controlled immersive mode.
|
||||
Full screen fills the 640x480 panel, hides chrome while the app has focus, and
|
||||
resizes existing in-process and worker windows without restarting the app.
|
||||
The switcher remains accessible through the system menu.
|
||||
|
||||
Stock EvenHub apps retain their logical 576x288 canvas in every host display
|
||||
mode, including full screen. Content is centered at native pixel scale and
|
||||
clipped to that canvas; extra space does not change wrapping or layout.
|
||||
Only an app's explicit Faceclaw extended-layout request enables a taller canvas.
|
||||
Regression tests compare the complete stock raster against its centered
|
||||
full-screen placement, including text crossing the logical canvas boundary.
|
||||
|
||||
Keep screen awake is a separate On/Off switch immediately after the full-screen
|
||||
action in the system menu. It defaults off and persists per app independently
|
||||
of full screen. Existing full-screen preferences remain unchanged and do not
|
||||
implicitly enable keep awake.
|
||||
|
||||
Automatic idle sleep is suspended only while an app with Keep screen awake
|
||||
enabled is in the foreground, in any display mode. A background app does not
|
||||
hold the display awake. Full screen alone does not suppress idle sleep.
|
||||
The lock screen and explicit sleep still work. The inactivity countdown starts
|
||||
fresh after disabling keep awake or leaving a kept-awake app. Existing automatic
|
||||
holds for voice capture, assistant turns and video playback remain in effect.
|
||||
|
||||
Software regressions cover geometry with every switcher position, preserving
|
||||
other display settings and persistence after reload, captured menu targets,
|
||||
exit, independent keep-awake persistence, foreground/background idle behavior,
|
||||
lock timeout and manual sleep.
|
||||
|
||||
On glasses, verify entry/exit from both in-process apps and worker apps,
|
||||
reflow, state retention, idle timeout, app switching, lock/off-head behavior,
|
||||
and reconnection. These hardware checks remain pending. No firmware change.
|
||||
@@ -0,0 +1,35 @@
|
||||
# App switcher close menu
|
||||
|
||||
Feature branch: `feat/app-switcher-close-menu`, based on `main` so it can be
|
||||
reviewed independently. The combined build lives on `integration/device-preferences`.
|
||||
|
||||
With the app switcher focused, long-press or tap-then-hold opens the existing
|
||||
shell-owned System menu. “Close current app” closes the selected window when it
|
||||
is closeable. It is absent for the pinned launcher (the large application grid).
|
||||
“Close all apps” closes every closeable window, including background windows and
|
||||
multiple windows belonging to one app. Pinned windows remain available.
|
||||
|
||||
Both actions reuse the shell's normal close/cleanup path. The menu closes before
|
||||
the windows do, and focus returns to the switcher. It opens on “Focus app switcher”
|
||||
to avoid an accidental close. With no closeable windows, “Close all apps” is disabled.
|
||||
No new preferences or persistence format are introduced.
|
||||
|
||||
Software: `tests/app-switcher-menu.test.cjs` covers both gestures, apps claiming
|
||||
holds/hold-to-talk, launcher exclusion, captured close targets, cancellation,
|
||||
default selection, multiple windows, reentrant removal, callback errors and
|
||||
screen-off behavior. Existing in-app gesture routing remains unchanged.
|
||||
|
||||
Manual validation on glasses remains pending:
|
||||
|
||||
1. Open several apps, focus the app switcher, and open the menu with both gestures.
|
||||
2. Close the selected app; verify its surface disappears and other apps remain.
|
||||
3. Select the large application grid; verify “Close current app” is absent.
|
||||
4. Use “Close all apps”; verify the launcher remains usable and apps can reopen.
|
||||
5. Repeat for left/right/bottom/popup switcher positions and with a running game,
|
||||
a hold-to-talk app and an app exposing multiple windows.
|
||||
6. Check cancel/back and the initial selection do not close anything. Check both
|
||||
menu gestures still work normally when focus is inside an app.
|
||||
|
||||
Closing windows retains each app's existing lifecycle semantics; it does not
|
||||
uninstall apps or reset their preferences. Existing app-specific shutdown behavior
|
||||
(such as a remote terminal connection) is the same as closing its window normally.
|
||||
@@ -0,0 +1,29 @@
|
||||
# Android calendar selection validation
|
||||
|
||||
Software: `npm test` and `bash lint.sh` for changed TypeScript files.
|
||||
`tests/calendar-selection.test.cjs` covers preference reloads, all versus none,
|
||||
duplicate names/accounts, selection changes with cached readers, deleted IDs,
|
||||
recurrence occurrences and forwarding the selection to the provider before its
|
||||
limit. Provider SQL structure is checked statically; the mocked bridge does not
|
||||
replace an Android CalendarContract integration test.
|
||||
|
||||
On an Android device (pending):
|
||||
|
||||
1. With no saved preference, compare events with the current release.
|
||||
2. Open Calendar's window menu > Calendars displayed (also available through
|
||||
Glanceboard's Calendar widget settings). Select between two equal-named
|
||||
calendars belonging to different accounts. Check ID/account labels.
|
||||
3. Create more than 50 early events in an excluded calendar and later recurring
|
||||
events in a selected calendar. Check those later occurrences still appear.
|
||||
4. Select “No calendars”: Calendar, Glanceboard and any other readers must be
|
||||
empty immediately. Restart and confirm the selection persists.
|
||||
5. Select individual calendars, rename one, then delete one. Remaining selections
|
||||
must stay unchanged. A missing selected ID is shown as unavailable and may be
|
||||
removed; it never causes a fallback to all calendars.
|
||||
6. Select “All calendars”, add a calendar, and check it is included. In individual
|
||||
mode, newly added calendars stay excluded. Check all-day and timed recurring
|
||||
events in both Calendar and Glanceboard, including timezone/DST boundaries.
|
||||
|
||||
IDs are Android CalendarContract IDs, stable across display-name changes within
|
||||
an installation. Removing/re-adding an account can create new calendar IDs.
|
||||
The iOS calendar reader and its behavior are unchanged; iOS selection is deferred.
|
||||
@@ -0,0 +1,51 @@
|
||||
# Integrated device preferences
|
||||
|
||||
Branch: `integration/device-preferences`. Separate implementation branches are
|
||||
`feat/notification-filter-default`, `feat/calendar-selection` and
|
||||
`feat/head-up-wake`. No pull requests were created.
|
||||
|
||||
Software validation on Linux/NixOS, 2026-11-06:
|
||||
|
||||
- JavaScript/TypeScript suite: 1,059 passed, 3 skipped, 0 failed.
|
||||
- Shared Kotlin Android host suite: 269 passed, 0 failures/errors.
|
||||
- TypeScript: `tsc --noEmit` passes.
|
||||
- oxlint: passes with existing warnings outside the changes.
|
||||
- Nix tools: Node 22, Java 21, Android SDK 35, both build-tools versions,
|
||||
adb, host CMake/Ninja and NDK verified. Tested using devenv 2.4.0.
|
||||
|
||||
Reproduce with `devenv shell`, then:
|
||||
|
||||
```sh
|
||||
npm ci
|
||||
npm test
|
||||
npm run test:kotlin
|
||||
npx tsc --noEmit
|
||||
bash lint.sh
|
||||
bash scripts/check-devenv.sh
|
||||
bash build.sh
|
||||
```
|
||||
|
||||
The build produces a debug APK for arm64 Android phones. It does not install
|
||||
the APK or flash firmware. Build output and machine-local signing/SDK files
|
||||
are ignored by Git.
|
||||
|
||||
Final artifact: `dist/faceclaw-device-preferences-debug.apk` (115,876,494 bytes),
|
||||
package `com.faceclaw.app`, version 0.8.6 (806). Build completed successfully;
|
||||
APK v2 signature verified with `apksigner`. The packaged JavaScript contains all
|
||||
three controls, and the DEX contains the new calendar and head-up native APIs.
|
||||
SHA-256 (also saved alongside the APK):
|
||||
|
||||
```text
|
||||
091ced145d499ec00aa03cbea60f5cec7a2167e459896c4b5b45211e1c9a7e8a
|
||||
```
|
||||
|
||||
The updated APK also passes ELF LOAD/RELRO and ZIP alignment checks for 16 KiB
|
||||
pages; see [16 KiB validation](validation-android-16k.md).
|
||||
|
||||
Glasses validation remains pending. The APK was installed on a Pixel 10 Pro Fold,
|
||||
which currently reports 4096-byte pages. No glasses were used. See the
|
||||
manual procedures for [notifications](validation-notifications.md),
|
||||
[Android calendars](validation-calendars.md) and [head-up wake](validation-head-up.md).
|
||||
In particular, successful BLE encoding and simulated ACK/reconnect tests do
|
||||
not establish physical wake/angle behavior on a target Faceclaw firmware.
|
||||
The iOS calendar-selection port is deferred.
|
||||
@@ -0,0 +1,20 @@
|
||||
# Dismiss all notifications
|
||||
|
||||
The Notifications app menu offers Dismiss all notifications, disabled when the
|
||||
list is empty. This explicit action dismisses notifications on the phone too;
|
||||
popup filtering and source/default preferences remain independent.
|
||||
|
||||
Android uses NotificationListenerService.cancelAllNotifications, so dismissal
|
||||
is not limited to the 50 items displayed by the list and Android controls which
|
||||
notifications are removable. The normal removal callbacks update the list and
|
||||
popups. Missing listener access returns false without changing preferences.
|
||||
iOS uses the existing ANCS dismissal operation on a snapshot of all known keys;
|
||||
notifications without a negative action may remain.
|
||||
|
||||
Software tests cover menu action/disabled state, more than 50 notifications,
|
||||
native bridge dispatch, disconnected access and ANCS bulk dismissal.
|
||||
On a device, verify the permission-granted/revoked cases, protected or ongoing
|
||||
notifications, notification groups, and consistency with the phone's tray.
|
||||
Hardware validation remains pending.
|
||||
|
||||
Reference: https://developer.android.com/reference/android/service/notification/NotificationListenerService#cancelAllNotifications()
|
||||
@@ -0,0 +1,23 @@
|
||||
# Notification filter validation
|
||||
|
||||
Software: `npm test` and `bash lint.sh app/native/notification-sources.ts app/ui/notification-filter.ts`.
|
||||
The notification suite covers legacy preferences, reloads of the settings store,
|
||||
discovery, default changes without overwriting exceptions, both bulk actions,
|
||||
empty lists, stable menu selection and popup suppression before wake.
|
||||
|
||||
Hardware validation (pending; no glasses tested):
|
||||
|
||||
1. On an existing installation, check that enabled and muted applications retain
|
||||
their behavior before touching the new default.
|
||||
2. Turn “New apps enabled by default” off; restart the app. Send a notification
|
||||
from a previously unknown package: it must appear in the filter and on the
|
||||
phone, without waking the glasses or showing a glasses popup.
|
||||
3. Enable that package individually; send another notification and check its popup.
|
||||
4. Change the default in both directions; verify individual exceptions survive.
|
||||
5. Use “Disable all”, then discover another package: it follows the default.
|
||||
Repeat with “Enable all” while the default is off.
|
||||
6. Restart and repeat notifications from enabled and disabled sources. Check that
|
||||
bulk actions and filtering never dismiss notifications on the phone.
|
||||
|
||||
Only popup delivery on glasses is filtered. The notification tray and phone
|
||||
notification lifecycle retain their existing behavior.
|
||||
@@ -0,0 +1,46 @@
|
||||
# Whisper transcription languages
|
||||
|
||||
Settings > Voice > Transcription language selects French, English, 27 other
|
||||
languages, or auto-detection. It applies to ordinary dictation and continuous
|
||||
transcription using OpenAI, on-device Whisper, and the other cloud providers.
|
||||
Translate retains its own spoken-language preference. Moonshine remains
|
||||
English-only; Apple's on-device speech recognizer retains its own locale.
|
||||
|
||||
The initial **Provider default** preserves existing installations: English for
|
||||
on-device Whisper, auto-detection for OpenAI/other cloud providers, and the saved
|
||||
Whisper server language for self-hosted Whisper. Selecting another shared
|
||||
language overrides the server language without deleting it. Returning to Provider
|
||||
default restores it. Settings persist through the existing settings store.
|
||||
|
||||
For French or auto-detection with **On-device (Whisper)**, download
|
||||
**On-device model: Whisper (multilingual, base)** in Settings > Voice (~161 MB).
|
||||
English uses the existing English-only base model; neither model is deleted or
|
||||
downloaded automatically. A missing model uses the existing “Voice model not
|
||||
downloaded” status. Language changes restart active continuous transcription;
|
||||
other captures use the new language when started.
|
||||
|
||||
## Software validation
|
||||
|
||||
- JavaScript regression tests exercise stored settings/reload, compatible
|
||||
defaults, French and auto-detection, Translate overrides in Android/iOS capture
|
||||
options, the OpenAI WebSocket configuration, and local bridge restart/sharing.
|
||||
- Kotlin tests exercise English/French/other/automatic model selection and file
|
||||
names. Android release compilation checks the actual sherpa-onnx bridge.
|
||||
- New model downloads use a pinned Hugging Face revision, per-file SHA-256 and
|
||||
the existing resumable downloader. Encoder/decoder hashes and sizes come from
|
||||
repository LFS metadata; the vocabulary hash was computed from its contents.
|
||||
|
||||
## Device validation still required
|
||||
|
||||
With both phone microphone preview and glasses microphone, check French dictation
|
||||
(including accents), auto-detection, English rollback, continuous capture while
|
||||
changing language, cancellation/resumption of model download, and persistence
|
||||
after restarting the app. Compare OpenAI and offline Whisper on the same phrases.
|
||||
No paid API call, microphone recording, or firmware update is needed for the
|
||||
software checks above; recognition accuracy and latency require device testing.
|
||||
|
||||
## References
|
||||
|
||||
- [OpenAI Realtime transcription: language configuration](https://developers.openai.com/api/docs/guides/realtime-transcription)
|
||||
- [sherpa-onnx Whisper configuration and automatic language detection](https://github.com/k2-fsa/sherpa-onnx/blob/master/sherpa-onnx/csrc/offline-whisper-model-config.cc)
|
||||
- [Multilingual base model, pinned revision](https://huggingface.co/csukuangfj/sherpa-onnx-whisper-base/tree/bb53ee204431c90d314c1cc08d28d23e5b7927cc)
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
package com.faceclaw.app
|
||||
|
||||
/** The English-only files remain usable after upgrading; other languages need multilingual base. */
|
||||
data class WhisperModelFiles(val language: String) {
|
||||
val englishOnly: Boolean get() = language == "en"
|
||||
val dirName: String get() = if (englishOnly) "sherpa-onnx-whisper-base-en-int8" else "sherpa-onnx-whisper-base-int8"
|
||||
private val prefix: String get() = if (englishOnly) "base.en" else "base"
|
||||
val encoder: String get() = "$prefix-encoder.int8.onnx"
|
||||
val decoder: String get() = "$prefix-decoder.int8.onnx"
|
||||
val tokens: String get() = "$prefix-tokens.txt"
|
||||
val files: List<String> get() = listOf(encoder, decoder, tokens)
|
||||
|
||||
companion object {
|
||||
/** Null preserves the old English default; an empty code enables automatic detection. */
|
||||
fun forLanguage(language: String?): WhisperModelFiles =
|
||||
WhisperModelFiles(language?.trim()?.lowercase() ?: "en")
|
||||
}
|
||||
}
|
||||
@@ -13,7 +13,6 @@
|
||||
"run:ios": "scripts/ios.sh run ios",
|
||||
"prepare:ios": "scripts/ios.sh prepare ios",
|
||||
"doctor:ios": "scripts/ios.sh doctor ios",
|
||||
"install:apple-watch": "./build_apple_watch.sh --install",
|
||||
"build": "./build.sh",
|
||||
"lint": "./lint.sh",
|
||||
"run": "./build_and_run.sh",
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Prints the UDID of the first real Apple Watch devicectl can see, if any. A UDID
|
||||
# works both as a devicectl --device and as an xcodebuild destination id.
|
||||
set -euo pipefail
|
||||
output="$(mktemp)"
|
||||
trap 'rm -f "$output"' EXIT
|
||||
xcrun devicectl list devices --quiet --json-output "$output" >/dev/null
|
||||
node -e '
|
||||
const devices = JSON.parse(require("fs").readFileSync(process.argv[1], "utf8")).result.devices;
|
||||
// Xcode 27 lists simulators too and moved these fields into `properties`. `reality`
|
||||
// is absent on a real device until it has connected, so only "simulated" rules one out.
|
||||
const hardware = device => device.properties?.hardware ?? device.hardwareProperties ?? {};
|
||||
const watch = devices.map(hardware).find(h => h.platform === "watchOS" && h.reality !== "simulated");
|
||||
if (watch) console.log(watch.udid);
|
||||
' "$output"
|
||||
@@ -1,69 +0,0 @@
|
||||
// Ties the Apple Watch app (apple-watch/) to the iOS build. WatchConnectivity
|
||||
// only links the two apps when the phone app's bundle carries the watch app in
|
||||
// Watch/, so a phone build that wants a working watch must embed it.
|
||||
//
|
||||
// Embedding is opt-in (FACECLAW_EMBED_WATCH=1 in build_paths.sh): signing the
|
||||
// result needs a provisioning profile for the watch app, which can't be made
|
||||
// for a team with no watch registered, so it would break everyone else's builds.
|
||||
//
|
||||
// node scripts/apple-watch-embed.cjs config Write apple-watch/Local.xcconfig.
|
||||
// node scripts/apple-watch-embed.cjs sync Make platforms/ios match the setting.
|
||||
const { execFileSync } = require('node:child_process');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
|
||||
const root = path.resolve(__dirname, '..');
|
||||
const pbxproj = path.join(root, 'platforms/ios/faceclaw.xcodeproj/project.pbxproj');
|
||||
// The CLI drops `-sdk iphoneos` from xcodebuild, which would otherwise force
|
||||
// the watch target onto the iOS SDK, only if this directory exists. Its own watch
|
||||
// support (the legacy two-target layout) stays inert without a `watchextension`.
|
||||
const cliWatchMarker = path.join(root, 'App_Resources/iOS/watchapp');
|
||||
|
||||
function embedEnabled() {
|
||||
return process.env.FACECLAW_EMBED_WATCH === '1';
|
||||
}
|
||||
|
||||
/** Xcode's own builds of the watch project read this too, so they sign the same way. */
|
||||
function writeLocalConfig() {
|
||||
const version = /FACECLAW_VERSION = "(.*)"/.exec(fs.readFileSync(path.join(root, 'app/version.ts'), 'utf8'))[1];
|
||||
const lines = [
|
||||
`FACECLAW_IOS_BUNDLE_ID = ${process.env.IOS_BUNDLE_ID || 'com.faceclaw.app'}`,
|
||||
// An embedded watch app has to carry the phone app's version.
|
||||
`MARKETING_VERSION = ${version}`,
|
||||
];
|
||||
if (process.env.IOS_TEAM_ID) lines.push(`DEVELOPMENT_TEAM = ${process.env.IOS_TEAM_ID}`);
|
||||
fs.writeFileSync(path.join(root, 'apple-watch/Local.xcconfig'), `${lines.join('\n')}\n`);
|
||||
}
|
||||
|
||||
function syncEmbed() {
|
||||
const enabled = embedEnabled();
|
||||
if (enabled) writeLocalConfig();
|
||||
// Without the setting there's normally nothing to undo, and no need for Ruby.
|
||||
const embedded = fs.existsSync(pbxproj) && fs.readFileSync(pbxproj, 'utf8').includes('Embed Watch Content');
|
||||
if (enabled !== embedded && fs.existsSync(pbxproj)) {
|
||||
execFileSync('ruby', [path.join(__dirname, 'embed-apple-watch.rb'), enabled ? 'embed' : 'remove'], { cwd: root, stdio: 'inherit' });
|
||||
}
|
||||
// Last: a project that still embeds the watch app can't build without this.
|
||||
if (enabled) {
|
||||
fs.mkdirSync(cliWatchMarker, { recursive: true });
|
||||
} else {
|
||||
fs.rmSync(cliWatchMarker, { recursive: true, force: true });
|
||||
// Xcode leaves what it copied in earlier builds, which would still embed the old app.
|
||||
const buildDir = path.join(root, 'platforms/ios/build');
|
||||
for (const config of fs.existsSync(buildDir) ? fs.readdirSync(buildDir) : []) {
|
||||
fs.rmSync(path.join(buildDir, config, 'faceclaw.app/Watch'), { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { embedEnabled, syncEmbed, writeLocalConfig };
|
||||
|
||||
if (require.main === module) {
|
||||
const command = process.argv[2];
|
||||
if (command === 'config') writeLocalConfig();
|
||||
else if (command === 'sync') syncEmbed();
|
||||
else {
|
||||
console.error('usage: apple-watch-embed.cjs config|sync');
|
||||
process.exit(2);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Check ELF64 LOAD/RELRO alignment in an APK; pair with zipalign -c -P 16 4."""
|
||||
import argparse
|
||||
import struct
|
||||
import zipfile
|
||||
|
||||
PAGE = 16384
|
||||
|
||||
|
||||
def alignment_errors(data):
|
||||
if len(data) < 64 or data[:4] != b"\x7fELF" or data[4] != 2 or data[5] not in (1, 2):
|
||||
return ["expected an ELF64 library"]
|
||||
endian = "<" if data[5] == 1 else ">"
|
||||
offset = struct.unpack_from(endian + "Q", data, 32)[0]
|
||||
size, count = struct.unpack_from(endian + "HH", data, 54)
|
||||
if size < 56 or offset + size * count > len(data):
|
||||
return ["invalid program headers"]
|
||||
headers = [struct.unpack_from(endian + "IIQQQQQQ", data, offset + i * size) for i in range(count)]
|
||||
errors = []
|
||||
loads = [h for h in headers if h[0] == 1]
|
||||
if not loads:
|
||||
errors.append("no LOAD segments")
|
||||
for h in loads:
|
||||
if h[7] < PAGE or h[7] % PAGE or (h[3] - h[2]) % PAGE:
|
||||
errors.append(f"LOAD alignment {h[7]} is incompatible with 16 KiB pages")
|
||||
for h in headers:
|
||||
if h[0] != 0x6474E552:
|
||||
continue
|
||||
end = h[3] + h[6]
|
||||
# A RELRO ending within a writable LOAD may protect unrelated writable
|
||||
# data on a 16 KiB device. A separate LOAD after RELRO is also safe.
|
||||
if end % PAGE and any(p[1] & 2 and p[3] <= h[3] and end < p[3] + p[6] for p in loads):
|
||||
errors.append("RELRO ends inside writable LOAD without 16 KiB alignment")
|
||||
return errors
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("apk")
|
||||
args = parser.parse_args()
|
||||
checked = 0
|
||||
failed = False
|
||||
with zipfile.ZipFile(args.apk) as archive:
|
||||
for name in archive.namelist():
|
||||
if not name.startswith(("lib/arm64-v8a/", "lib/x86_64/")) or not name.endswith(".so"):
|
||||
continue
|
||||
checked += 1
|
||||
errors = alignment_errors(archive.read(name))
|
||||
failed |= bool(errors)
|
||||
print(f"{'FAIL' if errors else 'OK'} {name}" + (": " + "; ".join(errors) if errors else ""))
|
||||
if not checked:
|
||||
parser.error("no 64-bit native libraries found")
|
||||
return int(failed)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,18 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
node --version
|
||||
java -version
|
||||
test -f "$ANDROID_HOME/platforms/android-35/android.jar"
|
||||
for version in 34.0.0 35.0.0 35.0.1; do
|
||||
"$ANDROID_HOME/build-tools/$version/aapt2" version
|
||||
done
|
||||
"$ANDROID_HOME/platform-tools/adb" version
|
||||
"$ANDROID_CMAKE_HOME/bin/cmake" --version
|
||||
"$ANDROID_CMAKE_HOME/bin/ninja" --version
|
||||
case "$(uname -s)" in
|
||||
Darwin) ndk_host=darwin-x86_64 ;;
|
||||
*) ndk_host=linux-x86_64 ;;
|
||||
esac
|
||||
test -x "$ANDROID_HOME/ndk/27.2.12479018/toolchains/llvm/prebuilt/$ndk_host/bin/clang"
|
||||
echo "Faceclaw development tools verified."
|
||||
@@ -1,50 +0,0 @@
|
||||
#!/usr/bin/env ruby
|
||||
# Adds apple-watch/Faceclaw.xcodeproj to the generated iOS project as a subproject
|
||||
# and embeds its app in the phone app's Watch/ folder, or takes all that back out.
|
||||
# See apple-watch-embed.cjs, which decides when to run this.
|
||||
require 'xcodeproj'
|
||||
|
||||
PHASE_NAME = 'Embed Watch Content'
|
||||
WATCH_TARGET = 'Faceclaw'
|
||||
|
||||
root = File.expand_path('..', __dir__)
|
||||
watch_project_path = File.join(root, 'apple-watch/Faceclaw.xcodeproj')
|
||||
project = Xcodeproj::Project.open(File.join(root, 'platforms/ios/faceclaw.xcodeproj'))
|
||||
app = project.targets.find { |target| target.name == 'faceclaw' } or abort 'No faceclaw target in the iOS project'
|
||||
|
||||
def remove_embed(project, app, watch_project_path)
|
||||
app.copy_files_build_phases.select { |phase| phase.name == PHASE_NAME }.each do |phase|
|
||||
phase.files.to_a.each(&:remove_from_project)
|
||||
phase.remove_from_project
|
||||
end
|
||||
app.dependencies.select { |dependency| dependency.display_name == WATCH_TARGET }.each(&:remove_from_project)
|
||||
reference = project.reference_for_path(watch_project_path)
|
||||
return unless reference
|
||||
|
||||
# Saving fails on any proxy still pointing at the subproject.
|
||||
project.objects.select { |object| object.isa == 'PBXContainerItemProxy' && object.container_portal == reference.uuid }
|
||||
.each(&:remove_from_project)
|
||||
entries = project.root_object.project_references
|
||||
entries.select { |entry| entry[:project_ref] == reference }.each do |entry|
|
||||
entry[:product_group].remove_from_project
|
||||
entries.delete(entry)
|
||||
end
|
||||
reference.remove_from_project
|
||||
end
|
||||
|
||||
remove_embed(project, app, watch_project_path)
|
||||
|
||||
if ARGV[0] == 'embed'
|
||||
reference = project.main_group.new_file(watch_project_path)
|
||||
watch_target = Xcodeproj::Project.open(watch_project_path).targets.find { |target| target.name == WATCH_TARGET }
|
||||
app.add_dependency(watch_target)
|
||||
|
||||
entry = project.root_object.project_references.find { |candidate| candidate[:project_ref] == reference }
|
||||
product = entry[:product_group].children.find { |child| child.path == "#{WATCH_TARGET}.app" } or abort 'The watch project has no app product'
|
||||
phase = app.new_copy_files_build_phase(PHASE_NAME)
|
||||
phase.symbol_dst_subfolder_spec = :products_directory
|
||||
phase.dst_path = '$(CONTENTS_FOLDER_PATH)/Watch'
|
||||
phase.add_file_reference(product).settings = { 'ATTRIBUTES' => ['RemoveHeadersOnCopy'] }
|
||||
end
|
||||
|
||||
project.save
|
||||
@@ -1,6 +0,0 @@
|
||||
const { syncEmbed } = require('../../scripts/apple-watch-embed.cjs');
|
||||
|
||||
// After prepare, because that's when the iOS project and its pods are finished.
|
||||
module.exports = function (hookArgs) {
|
||||
if (hookArgs.prepareData.platform === 'ios') syncEmbed();
|
||||
};
|
||||
@@ -8,7 +8,6 @@ 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' },
|
||||
{ source: 'scripts/hooks/faceclaw-watch.after-prepare.js', target: 'hooks/after-prepare/faceclaw-watch.js' },
|
||||
];
|
||||
|
||||
function installHooks() {
|
||||
|
||||
@@ -267,6 +267,9 @@ function shellEnv({ wakeAction = 'voice-input', skipConfirmation = false } = {})
|
||||
}
|
||||
const voiceDialogs = [];
|
||||
const settings = { wakeWordActionSetting: { get: () => wakeAction }, brightnessSetting: { get: () => 'auto' },
|
||||
appFullscreenSetting: () => ({ get: () => false }),
|
||||
appKeepAwakeSetting: () => ({ label: 'Keep screen awake', get: () => false }),
|
||||
toggleSettingMenuItem: setting => ({ label: setting.label }),
|
||||
assistantSkipConfirmationSetting: { get: () => skipConfirmation } };
|
||||
const { shell, rawInputEventToInputEvent } = load('app/ui/shell/shell.ts', {
|
||||
'../../graphics/shell-scene': { encodeShellScene: () => new Uint8Array([0, 0]) },
|
||||
@@ -370,6 +373,7 @@ test('ordinary apps retain long-press system menu and games retain the escape ti
|
||||
assert.deepEqual(env.input, []);
|
||||
env.shell.stack.clearToBase();
|
||||
env.app.window.claimsLongPress = () => true;
|
||||
env.shell.focusWindow('ai-chat');
|
||||
await env.shell.receiveInput(env.event('long-press'));
|
||||
assert.notEqual(env.shell.escapeMenuTimer, null);
|
||||
await env.shell.receiveInput(env.event('long-press-release'));
|
||||
|
||||
@@ -15,6 +15,8 @@ function geometry() {
|
||||
appSwitcherPositionSetting: 'left', uiDepthSetting: '0', statusBarPositionSetting: 'top',
|
||||
statusBarVisibilitySetting: 'always', windowBorderSetting: true,
|
||||
}).map(([name, value]) => [name, { value, get() { return this.value; } }]));
|
||||
const fullscreen = new Map();
|
||||
settings.appFullscreenSetting = id => ({ get: () => fullscreen.get(id) ?? false, set: value => fullscreen.set(id, value) });
|
||||
const context = { exports: {}, require: (name) => {
|
||||
if (name === '../../graphics/image') return { G2_LENS_WIDTH: 640, G2_LENS_HEIGHT: 480 };
|
||||
assert.equal(name, '../dashboard-settings');
|
||||
@@ -27,6 +29,25 @@ function geometry() {
|
||||
|
||||
const LAYOUTS = ['band-top', 'band-high', 'band-middle', 'band-low', 'band-bottom', 'tall', 'fullscreen'];
|
||||
|
||||
test('user full screen spans the panel with any switcher and survives app immersive cleanup', () => {
|
||||
const g = geometry();
|
||||
const previous = g.rect('min', 'test');
|
||||
for (const position of ['left', 'right', 'bottom', 'popup']) {
|
||||
g.settings.appSwitcherPositionSetting.value = position;
|
||||
g.settings.appFullscreenSetting('test').set(true);
|
||||
assert.deepEqual(g.rect('min', 'test'), { x: 0, y: 0, width: 640, height: 480 });
|
||||
assert.equal(g.sidebarStripVisible('window', 'test'), false);
|
||||
assert.equal(g.sidebarStripVisible('sidebar', 'test'), true);
|
||||
g.setAppImmersive('test', true);
|
||||
g.setAppImmersive('test', false);
|
||||
assert.equal(g.isImmersive('test'), true);
|
||||
assert.equal(g.isImmersive('other'), false);
|
||||
}
|
||||
g.settings.appSwitcherPositionSetting.value = 'left';
|
||||
g.settings.appFullscreenSetting('test').set(false);
|
||||
assert.deepEqual(g.rect('min', 'test'), previous);
|
||||
});
|
||||
|
||||
test('defaults preserve normal windows, EvenHub height and tall terminal sessions', () => {
|
||||
const g = geometry();
|
||||
assert.deepEqual(g.rect('min', 'navigate'), { x: 64, y: 124, width: 576, height: 260 });
|
||||
|
||||
@@ -0,0 +1,226 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const vm = require('node:vm');
|
||||
const ts = require('typescript');
|
||||
|
||||
function fixture(options = {}) {
|
||||
const source = ts.createSourceFile('shell.ts', fs.readFileSync(path.join(__dirname, '../app/ui/shell/shell.ts'), 'utf8'), ts.ScriptTarget.Latest, true);
|
||||
const shellClass = source.statements.find(node => ts.isClassDeclaration(node) && node.name.text === 'Shell');
|
||||
const names = new Set(['routeInput', 'openEscapeMenu', 'closeAllWindows', 'closeWindow', 'removeWindow',
|
||||
'foregroundWindow', 'noteWindowVisible', 'mostRecentWindowIndex', 'yieldFocusToSidebar', 'applyScreenTimeout']);
|
||||
const methods = shellClass.members.filter(node => names.has(node.name?.getText(source)));
|
||||
assert.equal(methods.length, names.size);
|
||||
const overlay = source.statements.find(node => ts.isClassDeclaration(node) && node.name.text === 'ShellOverlayMenuLayer');
|
||||
class MenuLayer {
|
||||
constructor(title, items) { this.title = title; this.items = items; }
|
||||
selectItem(index) { this.selectedIndex = index; }
|
||||
}
|
||||
const fullscreen = new Map();
|
||||
const keepAwake = new Map();
|
||||
const context = {
|
||||
exports: {}, MenuLayer, console: { warn: () => {} },
|
||||
appViewportRect: () => ({ x: 0, y: 0, width: 576 }), CONTEXT_MENU_DIM: 0.5,
|
||||
brightnessSetting: { get: () => 'auto' }, gestureHints: () => 'App menu',
|
||||
GESTURE_SHORT_THEN_LONG_PRESS: 'tap-hold', makeInputEvent: event => event,
|
||||
isWatchInput: event => event.source === 'watch', isDirectionalInput: () => false,
|
||||
appFullscreenSetting: id => ({ get: () => fullscreen.get(id) ?? false, set: value => fullscreen.set(id, value) }),
|
||||
appKeepAwakeSetting: id => ({ label: 'Keep screen awake', get: () => keepAwake.get(id) ?? false, set: value => keepAwake.set(id, value) }),
|
||||
toggleSettingMenuItem: (setting, options) => ({ label: setting.label, onSelect(ctx) {
|
||||
setting.set(!setting.get()); options.onChange(ctx);
|
||||
} }),
|
||||
};
|
||||
vm.runInNewContext(ts.transpileModule(`${overlay.getText(source)}\nexport class Shell { ${methods.map(node => node.getText(source)).join('\n')} }`, {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText, context);
|
||||
const s = new context.exports.Shell();
|
||||
const closed = [], delivered = [], warnings = [], renders = [];
|
||||
context.console.warn = message => warnings.push(message);
|
||||
const window = (id, closeable = true, extra = {}) => ({
|
||||
appId: id, windowId: id, closeable,
|
||||
handleInput: async event => delivered.push([id, event.type]),
|
||||
requestRender: () => renders.push(id),
|
||||
close: () => closed.push(id),
|
||||
...extra,
|
||||
});
|
||||
const launcher = window('launcher', false);
|
||||
const app = window('current', true, options.app);
|
||||
const background = window('background');
|
||||
const layers = [];
|
||||
s.stack = {
|
||||
isAtBase: () => !layers.length,
|
||||
push: layer => layers.push(layer),
|
||||
pop: () => layers.pop()?.onRemoved?.(),
|
||||
popIfTop: predicate => { if (!layers.length || !predicate(layers.at(-1))) return false; s.stack.pop(); return true; },
|
||||
handleInput: async event => { if (event.type === 'double-click') s.stack.pop(); },
|
||||
};
|
||||
Object.assign(s, {
|
||||
windows: [launcher, app, background], selectedIndex: 1, focus: 'sidebar', screenOn: true,
|
||||
mruWindowIds: ['current', 'background', 'launcher'], attention: new Map(),
|
||||
config: { voiceInputEnabled: false, requestShellRender() {}, onWindowsChanged() {} },
|
||||
cancelEscapeMenuTimer() {}, startEscapeMenuTimer() { s.escapeStarted = true; },
|
||||
lastInput: null,
|
||||
lastInputAtMs: 0,
|
||||
noteUserActivity() { this.lastInputAtMs = 100; },
|
||||
focusWindow(id) { this.selectedIndex = this.windows.findIndex(w => w.windowId === id); this.focus = 'window'; },
|
||||
sleep() { this.screenOn = false; },
|
||||
});
|
||||
const input = type => s.routeInput({ type, source: 'ring', timestampMs: 100 }, 1);
|
||||
const menu = () => layers.at(-1);
|
||||
const choose = label => {
|
||||
const item = menu().items.find(item => item.label === label);
|
||||
assert.ok(item, label);
|
||||
item.onSelect({ stack: s.stack });
|
||||
};
|
||||
return { s, input, menu, choose, closed, delivered, warnings, renders, launcher, app, background, window, fullscreen, keepAwake };
|
||||
}
|
||||
|
||||
test('full screen targets the captured app without inhibiting idle sleep', async () => {
|
||||
const h = fixture();
|
||||
h.s.config.getScreenTimeoutMs = () => 1000;
|
||||
let relayouts = 0;
|
||||
h.s.config.onWindowLayoutChanged = () => relayouts++;
|
||||
await h.input('long-press');
|
||||
h.s.selectedIndex = 2;
|
||||
h.choose('Enter full screen');
|
||||
assert.equal(h.fullscreen.get('current'), true);
|
||||
assert.equal(h.s.foregroundWindow().windowId, 'current');
|
||||
assert.equal(h.s.focus, 'window');
|
||||
assert.equal(relayouts, 1);
|
||||
assert.equal(h.s.applyScreenTimeout(5000), true);
|
||||
h.s.screenOn = true;
|
||||
h.s.focusWindow('current');
|
||||
await h.input('long-press');
|
||||
h.choose('Exit full screen');
|
||||
assert.equal(h.fullscreen.get('current'), false);
|
||||
assert.equal(relayouts, 2);
|
||||
assert.equal(h.s.applyScreenTimeout(7000), true);
|
||||
});
|
||||
|
||||
test('keep awake is independent of full screen and applies only to the visible app', async () => {
|
||||
const h = fixture();
|
||||
h.s.config.getScreenTimeoutMs = () => 1000;
|
||||
await h.input('long-press');
|
||||
const labels = h.menu().items.map(item => item.label);
|
||||
assert.equal(labels.indexOf('Keep screen awake'), labels.indexOf('Enter full screen') + 1);
|
||||
h.s.selectedIndex = 2;
|
||||
h.choose('Keep screen awake');
|
||||
assert.equal(h.keepAwake.get('current'), true);
|
||||
assert.equal(h.fullscreen.get('current'), undefined);
|
||||
assert.equal(h.s.foregroundWindow().windowId, 'current');
|
||||
assert.equal(h.s.applyScreenTimeout(5000), false);
|
||||
h.s.focusWindow('background');
|
||||
assert.equal(h.s.applyScreenTimeout(5500), false);
|
||||
assert.equal(h.s.applyScreenTimeout(6000), true);
|
||||
h.s.screenOn = true;
|
||||
h.s.focusWindow('current');
|
||||
await h.input('long-press'); h.choose('Enter full screen');
|
||||
assert.equal(h.s.applyScreenTimeout(7000), false);
|
||||
await h.input('long-press'); h.choose('Exit full screen');
|
||||
assert.equal(h.keepAwake.get('current'), true);
|
||||
assert.equal(h.s.applyScreenTimeout(8000), false);
|
||||
await h.input('long-press'); h.choose('Keep screen awake');
|
||||
assert.equal(h.keepAwake.get('current'), false);
|
||||
assert.equal(h.s.applyScreenTimeout(9000), true);
|
||||
});
|
||||
|
||||
test('keep awake does not suppress lock timeout or manual sleep, and options are absent for the launcher', async () => {
|
||||
const h = fixture();
|
||||
h.fullscreen.set('current', true);
|
||||
h.keepAwake.set('current', true);
|
||||
h.s.config.getScreenTimeoutMs = () => 1000;
|
||||
h.s.config.isLocked = () => true;
|
||||
assert.equal(h.s.applyScreenTimeout(5000), true);
|
||||
h.s.screenOn = true;
|
||||
h.s.config.isLocked = () => false;
|
||||
h.s.sleep();
|
||||
assert.equal(h.s.screenOn, false);
|
||||
h.s.screenOn = true;
|
||||
h.s.selectedIndex = 0;
|
||||
await h.input('long-press');
|
||||
assert.ok(!h.menu().items.some(item => /full screen/.test(item.label)));
|
||||
assert.ok(!h.menu().items.some(item => item.label === 'Keep screen awake'));
|
||||
});
|
||||
|
||||
test('switcher opens its menu on hold or tap-hold even for an app claiming holds or hold-to-talk', async () => {
|
||||
for (const type of ['long-press', 'short-then-long-press']) {
|
||||
for (const app of [{}, { claimsLongPress: () => true }, { holdToTalk: true }]) {
|
||||
const h = fixture({ app });
|
||||
await h.input(type);
|
||||
assert.ok(h.menu());
|
||||
assert.ok(h.menu().items.some(item => item.label === 'Close current app'));
|
||||
assert.ok(h.menu().items.some(item => item.label === 'Close all apps'));
|
||||
assert.equal(h.menu().items[h.menu().selectedIndex].label, 'Focus app switcher');
|
||||
assert.deepEqual(h.delivered, [['current', 'system-menu-opened']]);
|
||||
assert.equal(h.s.escapeStarted, undefined);
|
||||
assert.equal(h.s.focus, 'sidebar');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('close current app closes the captured window and preserves the launcher and background windows', async () => {
|
||||
const h = fixture();
|
||||
await h.input('long-press');
|
||||
h.s.selectedIndex = 2; // An asynchronous focus change must not redirect the close action.
|
||||
h.choose('Close current app');
|
||||
assert.deepEqual(h.closed, ['current']);
|
||||
assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher', 'background']);
|
||||
assert.equal(h.s.focus, 'sidebar');
|
||||
assert.equal(h.menu(), undefined);
|
||||
});
|
||||
|
||||
test('launcher offers close all but never close current; close all leaves only the launcher', async () => {
|
||||
const h = fixture();
|
||||
h.s.selectedIndex = 0;
|
||||
await h.input('short-then-long-press');
|
||||
assert.ok(!h.menu().items.some(item => item.label === 'Close current app'));
|
||||
h.choose('Close all apps');
|
||||
assert.deepEqual(h.closed, ['current', 'background']);
|
||||
assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher']);
|
||||
assert.equal(h.s.selectedIndex, 0);
|
||||
assert.equal(h.s.focus, 'sidebar');
|
||||
await h.input('long-press');
|
||||
assert.equal(h.menu().items.find(item => item.label === 'Close all apps').disabled(), true);
|
||||
});
|
||||
|
||||
test('close all uses normal cleanup despite reentrant removal, multiple windows per app and throwing callbacks', () => {
|
||||
const h = fixture();
|
||||
h.s.windows.push(h.window('another', true, { appId: 'current' }), h.window('pinned', false));
|
||||
h.app.close = () => { h.closed.push('current'); h.s.removeWindow('current'); };
|
||||
h.background.close = () => { h.closed.push('background'); throw new Error('failed cleanup'); };
|
||||
h.s.closeAllWindows();
|
||||
assert.deepEqual(h.closed, ['current', 'background', 'another']);
|
||||
assert.deepEqual(h.s.windows.map(w => w.windowId), ['launcher', 'pinned']);
|
||||
assert.equal(h.warnings.length, 1);
|
||||
assert.equal(h.s.foregroundWindow().windowId, 'launcher');
|
||||
});
|
||||
|
||||
test('default selection and cancel do not close apps; an open overlay never receives a second menu', async () => {
|
||||
const h = fixture();
|
||||
await h.input('long-press');
|
||||
h.choose(h.menu().items[h.menu().selectedIndex].label);
|
||||
assert.deepEqual(h.closed, []);
|
||||
await h.input('long-press');
|
||||
const menu = h.menu();
|
||||
await h.input('long-press');
|
||||
assert.equal(h.menu(), menu);
|
||||
await h.input('double-click');
|
||||
assert.equal(h.menu(), undefined);
|
||||
assert.deepEqual(h.closed, []);
|
||||
});
|
||||
|
||||
test('in-app hold actions and app menus keep their existing routing; asleep switcher stays asleep', async () => {
|
||||
for (const [app, type] of [[{ claimsLongPress: () => true }, 'long-press'], [{ holdToTalk: true }, 'long-press'], [{}, 'short-then-long-press']]) {
|
||||
const h = fixture({ app });
|
||||
h.s.focus = 'window';
|
||||
await h.input(type);
|
||||
assert.deepEqual(h.delivered, [['current', type]]);
|
||||
assert.equal(h.menu(), undefined);
|
||||
}
|
||||
const h = fixture();
|
||||
h.s.screenOn = false;
|
||||
await h.input('long-press');
|
||||
assert.equal(h.menu(), undefined);
|
||||
assert.deepEqual(h.closed, []);
|
||||
});
|
||||
@@ -1,10 +0,0 @@
|
||||
// Compile the watch app's platform-independent Swift for the Mac and run its checks.
|
||||
const { execFileSync } = require('node:child_process');
|
||||
const { mkdtempSync } = require('node:fs');
|
||||
const { tmpdir } = require('node:os');
|
||||
const { join, resolve } = require('node:path');
|
||||
const root = resolve(__dirname, '..'), dir = mkdtempSync(join(tmpdir(), 'faceclaw-apple-watch-'));
|
||||
const src = 'apple-watch/Faceclaw';
|
||||
execFileSync('xcrun', ['swiftc', '-O', `${src}/Protocol.swift`, `${src}/PadStatus.swift`, `${src}/PadGestureRecognizer.swift`,
|
||||
'tests/native/apple-watch/main.swift', '-o', join(dir, 'apple-watch-test')], { cwd: root, stdio: 'inherit' });
|
||||
execFileSync(join(dir, 'apple-watch-test'), [], { stdio: 'inherit' });
|
||||
@@ -55,6 +55,7 @@ function settingsEnv(initialUrl = '', initialModel = 'openai-compatible') {
|
||||
ASR_MODELS: {
|
||||
moonshine: { label: 'Moonshine', sizeBytes: 1 },
|
||||
'whisper-base-en': { label: 'Whisper Base English', sizeBytes: 1 },
|
||||
'whisper-base': { label: 'Whisper Base Multilingual', sizeBytes: 1 },
|
||||
},
|
||||
asrModelState: () => ({}), cancelAsrModelDownload() {},
|
||||
deleteAsrModel() {}, startAsrModelDownload() {}, onAsrModelStateChanged: () => () => {},
|
||||
|
||||
@@ -26,6 +26,7 @@ function settingsFixture(store = new Map()) {
|
||||
};
|
||||
if (id.includes('brightness-curve')) return require('../.test-build/app/g2/brightness-curve.js');
|
||||
if (id.includes('animation-speed')) return require('../.test-build/app/ui/animation-speed.js');
|
||||
if (id.includes('transcription-language')) return require('../.test-build/app/native/transcription-language.js');
|
||||
return { Layer: class {}, ASSISTANT_MODEL_CHOICES: [] };
|
||||
}};
|
||||
vm.runInNewContext(ts.transpileModule(fs.readFileSync('app/ui/dashboard-settings.ts', 'utf8'), {
|
||||
|
||||
@@ -39,6 +39,9 @@ const menu = load('app/ui/menu.ts', {
|
||||
function fixture(initial = '50', viewport = { x: 64, y: 124, width: 576, height: 260 }) {
|
||||
let value = initial, writes = 0, closed = 0;
|
||||
const settings = {
|
||||
appFullscreenSetting: () => ({ get: () => false }),
|
||||
appKeepAwakeSetting: () => ({ label: 'Keep screen awake', get: () => false }),
|
||||
toggleSettingMenuItem: setting => ({ label: setting.label }),
|
||||
brightnessSetting: { get: () => value, set: (next) => { value = next; writes++; } },
|
||||
brightnessSettingToLevel: (value) => value === 'auto' ? null : Number(value),
|
||||
};
|
||||
@@ -120,13 +123,16 @@ test('system menu hides brightness in Auto and opens its picker between Voice in
|
||||
shell.openSystemMenu('test');
|
||||
let opened = shell.stack.layers.at(-1);
|
||||
assert.deepEqual(Array.from(opened.items, (item) => item.label),
|
||||
['Close window', 'Focus app switcher', 'Voice input', 'Debug']);
|
||||
['Close current app', 'Focus app switcher', 'Voice input', 'Close all apps', 'Enter full screen', 'Keep screen awake', 'Debug']);
|
||||
shell.stack.clearToBase();
|
||||
f.settings.brightnessSetting.set('40');
|
||||
shell.openSystemMenu('test');
|
||||
opened = shell.stack.layers.at(-1);
|
||||
assert.deepEqual(Array.from(opened.items, (item) => item.label),
|
||||
['Close window', 'Focus app switcher', 'Voice input', 'Brightness', 'Debug']);
|
||||
['Close current app', 'Focus app switcher', 'Voice input', 'Close all apps', 'Enter full screen', 'Keep screen awake', 'Brightness', 'Debug']);
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' }));
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' }));
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' }));
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' }));
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'scroll-down' }));
|
||||
await shell.stack.handleInput(gestures.makeInputEvent({ type: 'click', source: 'ring' }));
|
||||
|
||||
@@ -0,0 +1,150 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const vm = require('node:vm');
|
||||
const ts = require('typescript');
|
||||
const source = file => fs.readFileSync(path.join(__dirname, '..', file), 'utf8');
|
||||
function load(file, modules, globals = {}) {
|
||||
const context = { exports: {}, require: name => {
|
||||
assert.ok(name in modules, `Unexpected import ${name}`);
|
||||
return modules[name];
|
||||
}, ...globals };
|
||||
vm.runInNewContext(ts.transpileModule(source(file), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText, context);
|
||||
return context.exports;
|
||||
}
|
||||
function fixture(settings = new Map()) {
|
||||
const listeners = new Set();
|
||||
const storage = {
|
||||
getStringSetting: (key, fallback) => settings.get(key) ?? fallback,
|
||||
setStringSetting: (key, value) => { settings.set(key, value); for (const fn of listeners) fn(key); },
|
||||
onSettingsStoreChanged: fn => { listeners.add(fn); return () => listeners.delete(fn); },
|
||||
};
|
||||
const prefs = load('app/native/calendar-selection.ts', { './settings-store': storage });
|
||||
let permitted = true;
|
||||
const calls = [];
|
||||
const calendars = [
|
||||
{ id: '1', name: 'Work', accountName: 'one@example.com', accountType: 'google' },
|
||||
{ id: '2', name: 'Work', accountName: 'two@example.com', accountType: 'google' },
|
||||
];
|
||||
const events = [
|
||||
{ id: 1, calendarId: '1', startMs: 10000, endMs: 20000, title: 'Excluded early' },
|
||||
{ id: 9, calendarId: '2', startMs: 30000, endMs: 40000, title: 'Recurrence one' },
|
||||
{ id: 9, calendarId: '2', startMs: 50000, endMs: 60000, title: 'Recurrence two' },
|
||||
];
|
||||
const modules = {
|
||||
'@nativescript/core': { Utils: { android: { getApplicationContext: () => ({}) } } },
|
||||
'../g2/android-permissions': { hasCalendarPermission: () => permitted },
|
||||
'./calendar-permissions': { hasCalendarPermission: () => permitted },
|
||||
'./frame-timings': { spanCurrent: (_name, fn) => fn() },
|
||||
'./calendar-selection': prefs,
|
||||
'./settings-store': storage,
|
||||
};
|
||||
const globals = { global: { isAndroid: true }, com: { faceclaw: { app: { FaceclawCalendarProvider: {
|
||||
getCalendarsJson: () => JSON.stringify(calendars),
|
||||
getUpcomingEventsJson: (_ctx, max, window, selection) => {
|
||||
calls.push({ max, window, selection });
|
||||
const ids = JSON.parse(selection);
|
||||
return JSON.stringify(events.filter(event => ids === null || ids.includes(event.calendarId)).slice(0, max));
|
||||
},
|
||||
} } } } };
|
||||
const api = load('app/native/calendar.ts', modules, globals);
|
||||
const sources = load('app/native/calendar-sources.ts', modules, globals);
|
||||
return { api, prefs, sources, modules, globals, settings, calls, calendars,
|
||||
permissions: value => { permitted = value; } };
|
||||
}
|
||||
|
||||
test('calendar selection distinguishes all and none, survives restart and rejects invalid data', () => {
|
||||
const f = fixture();
|
||||
assert.equal(f.prefs.readCalendarSelection(), null);
|
||||
f.prefs.setCalendarSelection([]);
|
||||
assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), []);
|
||||
f.prefs.setCalendarSelection(['2', '2', '1']);
|
||||
assert.deepEqual(Array.from(fixture(f.settings).prefs.readCalendarSelection()), ['2', '1']);
|
||||
f.prefs.setCalendarSelection(null);
|
||||
assert.equal(fixture(f.settings).prefs.readCalendarSelection(), null);
|
||||
assert.throws(() => f.prefs.setCalendarSelection(['1 OR 1=1']));
|
||||
for (const value of ['oops', '{}', '[false]', '["bad"]']) {
|
||||
f.settings.set(f.prefs.CALENDAR_SELECTION_KEY, value);
|
||||
assert.equal(f.prefs.readCalendarSelection(), null);
|
||||
}
|
||||
});
|
||||
|
||||
test('shared reader forwards IDs before limiting, preserves recurrence occurrences and invalidates all cached query variants', async () => {
|
||||
const f = fixture();
|
||||
assert.equal(f.api.readUpcomingEvents(1)[0].title, 'Excluded early');
|
||||
f.api.readUpcomingEvents(1);
|
||||
assert.equal(f.calls.length, 1);
|
||||
let notifications = 0;
|
||||
const off = f.api.onCalendarChanged(() => notifications++);
|
||||
f.prefs.setCalendarSelection(['2']);
|
||||
const rows = f.api.readUpcomingEvents(2);
|
||||
assert.deepEqual(Array.from(rows, event => event.id), [9, 9]);
|
||||
assert.equal(f.calls.at(-1).selection, '["2"]');
|
||||
assert.equal(notifications, 1);
|
||||
assert.equal((await f.api.readUpcomingEventsAsync(1))[0].title, 'Recurrence one');
|
||||
off();
|
||||
f.prefs.setCalendarSelection([]);
|
||||
assert.equal(notifications, 1);
|
||||
assert.equal(f.api.readUpcomingEvents(1).length, 0, 'selection cache key works even without subscriptions');
|
||||
assert.equal(fixture(f.settings).api.readUpcomingEvents().length, 0);
|
||||
f.prefs.setCalendarSelection(['999']);
|
||||
assert.equal(f.api.readUpcomingEvents().length, 0, 'deleted calendar does not revert to all');
|
||||
f.permissions(false);
|
||||
assert.equal(f.api.readUpcomingEvents().length, 0);
|
||||
assert.equal(f.sources.readAvailableCalendars().length, 0);
|
||||
});
|
||||
|
||||
test('calendar menu distinguishes equal names by account and ID; all, none, deleted and individual selections share preferences', () => {
|
||||
const f = fixture();
|
||||
const { CalendarFilterLayer } = load('app/apps/calendar/calendar-filter.ts', {
|
||||
'../../graphics/ui-fonts': { getDefaultSmallFont: () => ({}) },
|
||||
'../../graphics/textwrap': { truncateText: (_font, text) => text },
|
||||
'../../native/calendar-selection': f.prefs,
|
||||
'../../native/calendar-sources': f.sources,
|
||||
'../../native/calendar-permissions': { hasCalendarPermission: () => true },
|
||||
'../../ui/menu': {
|
||||
drawToggleMenuItem: () => {},
|
||||
MenuLayer: class {
|
||||
constructor(_title, items) { this.items = items; this.selectedIndex = 0; }
|
||||
selectItem(index) { this.selectedIndex = index; return this; }
|
||||
setItems(items, index) { this.items = items; this.selectedIndex = index; }
|
||||
paint() { return this.items; }
|
||||
},
|
||||
},
|
||||
}, f.globals);
|
||||
const layer = new CalendarFilterLayer();
|
||||
const ctx = { stack: { getBaseSize: () => ({ width: 576 }) } };
|
||||
const rows = () => layer.paint(ctx, () => {});
|
||||
assert.ok(rows()[2].label.includes('one@example.com'));
|
||||
assert.ok(rows()[3].label.includes('two@example.com'));
|
||||
rows()[2].onSelect();
|
||||
assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']);
|
||||
rows()[1].onSelect();
|
||||
assert.equal(f.api.readUpcomingEvents().length, 0);
|
||||
rows()[3].onSelect();
|
||||
assert.deepEqual(Array.from(f.prefs.readCalendarSelection()), ['2']);
|
||||
f.calendars.pop();
|
||||
const missing = rows().find(row => row.label === 'Unavailable calendar #2');
|
||||
assert.ok(missing);
|
||||
missing.onSelect();
|
||||
assert.equal(f.prefs.readCalendarSelection().length, 0);
|
||||
rows()[0].onSelect();
|
||||
assert.equal(f.prefs.readCalendarSelection(), null);
|
||||
});
|
||||
|
||||
test('Android provider restricts Instances with bound calendar IDs before cutoff and limit', () => {
|
||||
const kotlin = source('App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawCalendarProvider.kt');
|
||||
assert.match(kotlin, /Instances\.CALENDAR_ID/);
|
||||
assert.match(kotlin, /if \(ids != null && ids.length\(\) == 0\) return "\[\]"/);
|
||||
assert.match(kotlin, /PROJECTION,\s+selection,\s+args,/);
|
||||
assert.ok(kotlin.indexOf('selection,\n args,') < kotlin.indexOf('events.take(limit)'));
|
||||
assert.match(kotlin, /CalendarContract\.Calendars\._ID/);
|
||||
assert.match(kotlin, /CalendarContract\.Calendars\.ACCOUNT_NAME/);
|
||||
for (const file of ['app/apps/calendar/calendar.ts', 'app/apps/glanceboard/widgets/calendar-widget.ts']) {
|
||||
assert.match(source(file), /readUpcomingEvents/);
|
||||
assert.match(source(file), /native\/calendar"/);
|
||||
}
|
||||
});
|
||||
@@ -207,6 +207,8 @@ test('provider selection falls back to on-device without a key and connects the
|
||||
// A running capture is shared only on the same provider and language.
|
||||
assert.equal(transcriptionKey({ provider: 'soniox', language: ' JA ' }), 'soniox:ja');
|
||||
assert.notEqual(transcriptionKey({ provider: 'soniox' }), transcriptionKey({ provider: 'soniox', language: 'ja' }));
|
||||
assert.equal(transcriptionKey({ provider: 'onboard-whisper' }), transcriptionKey({ provider: 'onboard-whisper', language: 'en' }));
|
||||
assert.notEqual(transcriptionKey({ provider: 'onboard-whisper' }), transcriptionKey({ provider: 'onboard-whisper', language: '' }));
|
||||
const statuses = [];
|
||||
const options = { onTranscript() {}, onStatus: status => statuses.push(status), onError() {} };
|
||||
const selection = { provider: 'onboard', elevenLabsApiKey: '', openAiApiKey: ' ', sonioxApiKey: 'soniox-key' };
|
||||
@@ -225,13 +227,13 @@ test('provider selection falls back to on-device without a key and connects the
|
||||
});
|
||||
|
||||
test('a spoken-language hint reaches each provider on the wire, and is left out to auto-detect', () => {
|
||||
for (const language of ['ja', '']) {
|
||||
for (const language of ['fr', 'ja', '']) {
|
||||
const elevenlabs = harness('elevenlabs', true, { language });
|
||||
assert.equal(new URL(elevenlabs.sockets[0].url).searchParams.get('language_code'), language || null);
|
||||
|
||||
const soniox = harness('soniox', true, { language });
|
||||
soniox.open();
|
||||
assert.deepEqual(JSON.parse(soniox.sockets[0].sent[0]).language_hints, language ? ['ja'] : undefined);
|
||||
assert.deepEqual(JSON.parse(soniox.sockets[0].sent[0]).language_hints, language ? [language] : undefined);
|
||||
|
||||
const openai = harness('openai', true, { language });
|
||||
openai.open();
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { loader } = require('./helpers/load-typescript.cjs');
|
||||
|
||||
test('Notifications menu dismisses all, including beyond the visible list, and leaves filters untouched', () => {
|
||||
let options, active = Array.from({ length: 80 }, (_, i) => ({ key: String(i) }));
|
||||
let dismissals = 0, renders = 0, pops = 0;
|
||||
const load = loader({}, {
|
||||
'../../ui/notifications': { NotificationsListLayer: class {} },
|
||||
'../../ui/notification-filter': { NotificationFilterLayer: class {} },
|
||||
'../../native/notification-icons': {
|
||||
ALL_NOTIFICATIONS: 0x7fffffff,
|
||||
readActiveNotifications(max) { assert.equal(max, 0x7fffffff); return active; },
|
||||
dismissAllNotifications() { dismissals++; active = []; return true; },
|
||||
onAndroidNotificationsChanged: () => () => {},
|
||||
},
|
||||
'../../ui/shell/in-process-window': {
|
||||
YieldAtRootLayer: class {},
|
||||
createInProcessWindow(value) { options = value; return { requestRender() { renders++; } }; },
|
||||
},
|
||||
});
|
||||
load('app/apps/notifications/notifications-app.ts').createNotificationsAppWindow({});
|
||||
const items = options.menuItems();
|
||||
assert.equal(items[0].label, 'Notification filter');
|
||||
const action = items.find(x => x.label === 'Dismiss all notifications');
|
||||
assert.equal(action.disabled(), false);
|
||||
assert.equal(dismissals, 0);
|
||||
action.onSelect({ stack: { pop() { pops++; } } });
|
||||
assert.equal(dismissals, 1);
|
||||
assert.equal(pops, 1);
|
||||
assert.equal(renders, 1);
|
||||
assert.equal(action.disabled(), true);
|
||||
});
|
||||
|
||||
test('Android bulk action uses the native listener and propagates unavailable access', () => {
|
||||
let calls = 0, allowed = false;
|
||||
const load = loader({ global: { isAndroid: true }, com: { faceclaw: { app: {
|
||||
FaceclawMediaNotificationListenerService: { dismissAllNotifications() { calls++; return allowed; } },
|
||||
} } } }, {
|
||||
'../graphics/image': {}, './frame-timings': {}, '../util/array-util': {},
|
||||
'./notification-sources': {}, './image-files': { PHOTO_TONE: { gamma: 1 } }, './notification-types': { NOTIFICATION_ICON_SIZE: 24 },
|
||||
});
|
||||
const api = load('app/native/notification-icons.ts');
|
||||
assert.equal(api.dismissAllNotifications(), false);
|
||||
allowed = true;
|
||||
assert.equal(api.dismissAllNotifications(), true);
|
||||
assert.equal(calls, 2);
|
||||
});
|
||||
|
||||
test('iOS snapshots all ANCS keys and continues when a notification cannot be dismissed', () => {
|
||||
const load = loader({}, {
|
||||
'../graphics/pebble-icons': {}, '../g2/ancs-client': {}, './notification-app-icons': {}, './notification-sources': {},
|
||||
});
|
||||
const api = load('app/native/notification-icons.ios.ts');
|
||||
assert.equal(api.dismissAllNotifications(), false);
|
||||
const active = Array.from({ length: 80 }, (_, i) => ({ key: String(i) })), attempted = [];
|
||||
api.bindIosNotifications({
|
||||
read(max) { assert.equal(max, api.ALL_NOTIFICATIONS); return active; },
|
||||
dismiss(key) {
|
||||
attempted.push(key);
|
||||
if (key === '1') return false;
|
||||
active.splice(active.findIndex(x => x.key === key), 1);
|
||||
return true;
|
||||
},
|
||||
});
|
||||
assert.equal(api.dismissAllNotifications(), false);
|
||||
assert.equal(attempted.length, 80);
|
||||
assert.deepEqual(active, [{ key: '1' }]);
|
||||
});
|
||||
@@ -12,6 +12,7 @@ function settingsFixture(store = new Map()) {
|
||||
};
|
||||
if (id.includes('brightness-curve')) return require('../.test-build/app/g2/brightness-curve.js');
|
||||
if (id.includes('animation-speed')) return require('../.test-build/app/ui/animation-speed.js');
|
||||
if (id.includes('transcription-language')) return require('../.test-build/app/native/transcription-language.js');
|
||||
return { Layer: class {}, ASSISTANT_MODEL_CHOICES: [] };
|
||||
}};
|
||||
vm.runInNewContext(ts.transpileModule(fs.readFileSync('app/ui/dashboard-settings.ts', 'utf8'), {
|
||||
@@ -64,3 +65,32 @@ test('Full Screen is offered only with a bottom or popup app switcher', () => {
|
||||
assert.deepEqual(Array.from(api.DISPLAY_LAYOUT_VALUES, (value) => api.displayLayoutLabel(value)),
|
||||
['Band · Top', 'Band · High', 'Band · Middle', 'Band · Low', 'Band · Bottom', 'Tall', 'Full Screen']);
|
||||
});
|
||||
|
||||
test('per-app full screen defaults off, persists across restart and preserves display preferences', () => {
|
||||
const store = new Map([['display.layout', 'band-low'], ['terminal.displayLayout', 'tall']]);
|
||||
const prefs = settingsFixture(store);
|
||||
assert.equal(prefs.appFullscreenSetting('terminal').get(), false);
|
||||
prefs.appFullscreenSetting('terminal').set(true);
|
||||
const restarted = settingsFixture(store);
|
||||
assert.equal(restarted.appFullscreenSetting('terminal').get(), true);
|
||||
assert.equal(restarted.appFullscreenSetting('other').get(), false);
|
||||
restarted.appFullscreenSetting('terminal').set(false);
|
||||
assert.equal(restarted.displayLayoutSetting.get(), 'band-low');
|
||||
assert.equal(store.get('terminal.displayLayout'), 'tall');
|
||||
});
|
||||
|
||||
test('keep awake persists per app independently of full screen, including existing full-screen choices', () => {
|
||||
const store = new Map([['display.fullscreen.terminal', true]]);
|
||||
let prefs = settingsFixture(store);
|
||||
assert.equal(prefs.appFullscreenSetting('terminal').get(), true);
|
||||
assert.equal(prefs.appKeepAwakeSetting('terminal').get(), false);
|
||||
prefs.appKeepAwakeSetting('terminal').set(true);
|
||||
prefs = settingsFixture(store);
|
||||
assert.equal(prefs.appKeepAwakeSetting('terminal').get(), true);
|
||||
assert.equal(prefs.appKeepAwakeSetting('other').get(), false);
|
||||
prefs.appFullscreenSetting('terminal').set(false);
|
||||
assert.equal(prefs.appKeepAwakeSetting('terminal').get(), true);
|
||||
prefs.appKeepAwakeSetting('terminal').set(false);
|
||||
prefs = settingsFixture(store);
|
||||
assert.equal(prefs.appKeepAwakeSetting('terminal').get(), false);
|
||||
});
|
||||
@@ -0,0 +1,81 @@
|
||||
const test = require('node:test');
|
||||
const assert = require('node:assert/strict');
|
||||
const { loader } = require('./helpers/load-typescript.cjs');
|
||||
const { GrayImage } = require('../.test-build/app/graphics/image.js');
|
||||
|
||||
function fixture() {
|
||||
let options, hooks;
|
||||
const paints = [], heights = [];
|
||||
const session = {
|
||||
manifest: { name: 'Test', packageId: 'test.app' },
|
||||
renderWindowIcon() {}, contextMenuItems: () => [], keepsScreenOn: () => false,
|
||||
attachWindow(value) { hooks = value; },
|
||||
paint(size, focused) {
|
||||
paints.push({ ...size, focused });
|
||||
const image = new GrayImage(size.width, size.height);
|
||||
image.setPixel(0, 0, 255);
|
||||
image.setPixel(size.width - 1, size.height - 1, 120);
|
||||
// Deliberately overflow a deferred text run: stock clips it at 576x288.
|
||||
image.drawFwText({ bakeFwTextRun(target, run, dx, dy) {
|
||||
target.fillRect(run.x + dx, run.y + dy, 20, 20, run.value);
|
||||
} }, 570, 280, 200, [{}]);
|
||||
return image;
|
||||
},
|
||||
};
|
||||
const load = loader({}, {
|
||||
'../../graphics/image': { GrayImage },
|
||||
'./compositor': { EVENHUB_SCREEN_WIDTH: 576, EVENHUB_SCREEN_HEIGHT: 288 },
|
||||
'../../ui/gestures': {}, '../../ui/shell/shell': { shell: {} }, './session': {},
|
||||
'../../ui/shell/chrome-layer': { windowIcon: () => () => null, makeImageWindowIcon: () => () => null },
|
||||
'./installed-apps': {},
|
||||
'../../ui/shell/in-process-window': { createInProcessWindow(value) {
|
||||
options = value;
|
||||
return { window: {}, stack: {}, requestRender() {}, setHeightMode(mode) { heights.push(mode); } };
|
||||
} },
|
||||
});
|
||||
load('app/apps/evenhub/evenhub-window.ts').createEvenHubWindow('test', 'test', session, {}, () => {}, () => {});
|
||||
return { paints, heights, hooks: () => hooks,
|
||||
paint(width, height, focused = true) {
|
||||
return options.baseLayer.paint({ stack: { getBaseSize: () => ({ width, height }), isFocused: () => focused } });
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
test('stock EvenHub canvas remains 576x288 through full-screen entry, resize and exit', () => {
|
||||
const f = fixture();
|
||||
for (const [width, height] of [[576, 288], [640, 480], [576, 452], [640, 480], [576, 288]]) {
|
||||
const image = f.paint(width, height);
|
||||
assert.deepEqual(f.paints.at(-1), { width: 576, height: 288, focused: true });
|
||||
assert.equal(image.width, width);
|
||||
assert.equal(image.height, height);
|
||||
}
|
||||
});
|
||||
|
||||
test('full screen centers stock pixels at native scale and clips overflowing text to the stock canvas', () => {
|
||||
const f = fixture();
|
||||
const stock = f.paint(576, 288).withDrawsBaked();
|
||||
const full = f.paint(640, 480).withDrawsBaked();
|
||||
for (let y = 0; y < 480; y++) {
|
||||
for (let x = 0; x < 640; x++) {
|
||||
const expected = x >= 32 && x < 608 && y >= 96 && y < 384 ? stock.getPixel(x - 32, y - 96) : 0;
|
||||
assert.equal(full.getPixel(x, y), expected);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('only an explicit extended-layout request opts into the taller canvas', () => {
|
||||
const f = fixture();
|
||||
f.paint(640, 480, false);
|
||||
assert.deepEqual(f.paints.at(-1), { width: 576, height: 288, focused: false });
|
||||
f.hooks().setTallCanvas(true);
|
||||
assert.deepEqual(f.heights, ['max']);
|
||||
f.paint(576, 452);
|
||||
assert.equal(f.paints.at(-1).height, 452);
|
||||
f.paint(640, 480);
|
||||
assert.equal(f.paints.at(-1).width, 576);
|
||||
assert.equal(f.paints.at(-1).height, 480);
|
||||
f.hooks().setTallCanvas(false);
|
||||
f.paint(640, 480);
|
||||
assert.deepEqual(f.heights, ['max', 'medium']);
|
||||
assert.equal(f.paints.at(-1).height, 288);
|
||||
});
|
||||
@@ -6,6 +6,7 @@ const ts = require('typescript');
|
||||
const path = require('node:path');
|
||||
// The provider settings ios-preview-controller hands the voice bridge.
|
||||
const voiceSettings = { voiceProviderSetting: { get: () => 'onboard' }, elevenLabsApiKeySetting: { get: () => '' },
|
||||
getVoiceTranscriptionLanguage: () => '',
|
||||
openAiApiKeySetting: { get: () => '' }, sonioxApiKeySetting: { get: () => '' },
|
||||
whisperServerUrlSetting: { get: () => '' }, whisperServerModelSetting: { get: () => '' },
|
||||
whisperServerLanguageSetting: { get: () => '' }, whisperServerApiKeySetting: { get: () => '' } };
|
||||
@@ -168,6 +169,7 @@ test('settings-driven repaint runs after font cache invalidation, regardless of
|
||||
let cachedFont = 'Light';
|
||||
const api = load('app/ui/dashboard-settings.ts', { global: { isIOS: true },
|
||||
require: id => id.includes('settings-store') ? { onSettingsStoreChanged: fn => listeners.push(fn) }
|
||||
: id.endsWith('/transcription-language') ? load('app/native/transcription-language.ts', {})
|
||||
: { Layer: class {}, ASSISTANT_MODEL_CHOICES: [] },
|
||||
setTimeout: fn => tasks.push(fn),
|
||||
});
|
||||
@@ -384,7 +386,7 @@ test('iOS continuous capture is shared by windows and restarts after a disconnec
|
||||
recordTo: name => { bridge.recording = name; },
|
||||
setRawSession: session => { bridge.rawSession = session; } };
|
||||
const settings = { ...voiceSettings, voiceProviderSetting: { get: () => 'whisper-server' },
|
||||
whisperServerUrlSetting: { get: () => 'http://whisper.local:8000' }, whisperServerLanguageSetting: { get: () => 'en' },
|
||||
whisperServerUrlSetting: { get: () => 'http://whisper.local:8000' }, getVoiceTranscriptionLanguage: () => 'en',
|
||||
saveTranscribeAudioSetting: { get: () => true } };
|
||||
const { IosPreviewController } = load('app/g2/ios-preview-controller.ts', {
|
||||
require: id => id === '../native/ios-voice-input' ? { iosVoiceInput: bridge } : id === '../ui/dashboard-settings' ? settings
|
||||
|
||||
@@ -199,6 +199,7 @@ test('Calendar window subscribes, refreshes periodically, and cleans up on close
|
||||
'../../native/calendar': { onCalendarChanged: fn => { listener = fn; return () => unsubscribed++; } },
|
||||
'../../ui/shell/chrome-layer': { makeImageWindowIcon() {}, windowIcon() {} },
|
||||
'./calendar': { CalendarLayer: class {} }, './calendar-icon': {},
|
||||
'./calendar-filter': { calendarSelectionMenuItems: () => [] },
|
||||
'../../ui/shell/in-process-window': { YieldAtRootLayer: class {}, createInProcessWindow: value => { options = value; return app; } },
|
||||
}, { setInterval: fn => { tick = fn; return 1; }, clearInterval: () => cleared++ });
|
||||
createCalendarAppWindow({ onClosed: () => closed++ });
|
||||
|
||||
@@ -157,7 +157,6 @@ function fixture() {
|
||||
'./lock-screen': { LOCK_SCREEN_SURFACE_ID: 'lock-screen', createLockScreenImage: () => new images.GrayImage(640, 480, 123) },
|
||||
'./glasses-presence': load('app/g2/glasses-presence.ts', {}),
|
||||
'./device-addresses': { loadDeviceAddresses: () => ({ right: 'AA', left: 'BB', ring: '' }) }, './ios-peripheral-identity': { deviceAddressError: () => null },
|
||||
'./wear-remote': { WearRemote: class { schedulePublish() {} } },
|
||||
'./firmware-compat': load('app/g2/firmware-compat.ts', {}), './reconnect-policy': load('app/g2/reconnect-policy.ts', {}),
|
||||
'../apps/launcher': { launcherEntries: () => [] },
|
||||
'../apps/evenhub/installed-apps': {}, '../apps/evenhub/manager': { onPhoneShownChanged: () => () => {}, phoneUiButton: () => null },
|
||||
|
||||
Loaded 100 of 109 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user