@glassly/engine 0.3.8-dev.999 → 0.4.0-beta.1019

package/src/services/neuralBand/NeuralBandInput.ts

@@ -6,7 +6,12 @@
  * latest claim is also kept on its own, since the pairing screen runs before
  * the band's id reaches JS.
  */
-import type {NeuralBandClaimEvent, NeuralBandHandwritingEvent, NeuralBandPointerEvent} from "@glassly/bluetooth-sdk"
+import type {
+  NeuralBandClaimEvent,
+  NeuralBandFirmwareEvent,
+  NeuralBandHandwritingEvent,
+  NeuralBandPointerEvent,
+} from "@glassly/bluetooth-sdk"
 import {MiniappStreamType} from "@glassly/miniapp"
 
 import type {KeyboardEventPayload} from "../GlassesKeyboardInput"
@@ -34,6 +39,8 @@ export interface NeuralBandHandwritingUpdate {
   status: NeuralBandHandwritingStatus
 }
 
+export type NeuralBandFirmwareStatus = Omit<NeuralBandFirmwareEvent, "type" | "controllerId"> & {known: boolean}
+
 export interface NeuralBandInputOptions {
   forward?: (stream: string, payload: unknown) => void
   now?: () => number
@@ -67,13 +74,25 @@ function codeFor(char: string): string {
 
 const IDLE_CLAIM: NeuralBandClaimStatus = {stage: "idle", sessionExpired: false}
 const IDLE_HANDWRITING: NeuralBandHandwritingStatus = {phase: "idle", message: "", text: ""}
+const IDLE_FIRMWARE: NeuralBandFirmwareStatus = {
+  known: false,
+  connected: false,
+  hasMetaSession: false,
+  checked: false,
+  updateAvailable: false,
+  phase: "idle",
+  progress: 0,
+  message: "",
+}
 
 export class NeuralBandInput {
   private latestClaim: NeuralBandClaimStatus = IDLE_CLAIM
   private claims = new Map<string, NeuralBandClaimStatus>()
   private handwriting = new Map<string, NeuralBandHandwritingStatus>()
+  private firmware = new Map<string, NeuralBandFirmwareStatus>()
   private claimListeners = new Set<(status: NeuralBandClaimStatus) => void>()
   private handwritingListeners = new Set<(update: NeuralBandHandwritingUpdate) => void>()
+  private firmwareListeners = new Set<(update: {id: string; status: NeuralBandFirmwareStatus}) => void>()
   private readonly forward: (stream: string, payload: unknown) => void
   private readonly now: () => number
 
@@ -102,6 +121,15 @@ export class NeuralBandInput {
     return () => this.handwritingListeners.delete(cb)
   }
 
+  firmwareStatus(controllerId: string): NeuralBandFirmwareStatus {
+    return this.firmware.get(controllerId) ?? IDLE_FIRMWARE
+  }
+
+  onFirmwareStatus(cb: (update: {id: string; status: NeuralBandFirmwareStatus}) => void): () => void {
+    this.firmwareListeners.add(cb)
+    return () => this.firmwareListeners.delete(cb)
+  }
+
   /** A new pairing attempt starts from a clean slate. */
   resetClaim(): void {
     this.latestClaim = IDLE_CLAIM
@@ -112,6 +140,14 @@ export class NeuralBandInput {
   forget(controllerId: string): void {
     this.claims.delete(controllerId)
     this.handwriting.delete(controllerId)
+    this.firmware.delete(controllerId)
+  }
+
+  handleFirmware(event: NeuralBandFirmwareEvent): void {
+    const {type: _type, controllerId, ...rest} = event
+    const status: NeuralBandFirmwareStatus = {...rest, known: true}
+    this.firmware.set(controllerId, status)
+    for (const cb of this.firmwareListeners) cb({id: controllerId, status})
   }
 
   handleClaim(event: NeuralBandClaimEvent): void {

package/src/services/neuralBand/NeuralBandSettingsSync.ts

@@ -1,16 +1,23 @@
 /**
- * Pushes the Neural Band user settings (air mouse, wearing hand) to every
- * connected band: to each band as it connects, and to all of them whenever
- * either setting changes. The native side keeps nothing across connections.
+ * Pushes the Neural Band user settings (air mouse, wearing hand, vibration) to
+ * every connected band: to each band as it connects, and to all of them
+ * whenever a setting changes. The native side keeps nothing across
+ * connections. Handwriting is gated, not pushed: HandwritingGate runs it while
+ * the setting is on and a miniapp has a text field open.
  */
 import BluetoothSdk from "@glassly/bluetooth-sdk/internal"
 
 import {useGlassesStore} from "../../stores/glasses"
 import {SETTINGS, useSettingsStore} from "../../stores/settings"
 import {ControllerTypes} from "../../types/enums"
+import {BgTimer} from "../../utils/timers"
 import {readyControllers} from "../controllers"
+import localMiniappRuntime from "../LocalMiniappRuntime"
+import {HandwritingGate} from "./HandwritingGate"
+import neuralBandInput from "./NeuralBandInput"
 
 let unsubscribers: (() => void)[] = []
+let handwriting: HandwritingGate | null = null
 
 function connectedBandIds(): string[] {
   return readyControllers(useGlassesStore.getState().controllers)
@@ -32,10 +39,39 @@ function pushHand(id: string): void {
   )
 }
 
+function pushVibration(id: string): void {
+  const enabled = useSettingsStore.getState().getSetting(SETTINGS.neural_band_vibration.key) !== false
+  void BluetoothSdk.neuralBandSetGestureHaptics(id, enabled).catch((err) =>
+    console.warn("NeuralBandSettingsSync: vibration push failed:", err),
+  )
+}
+
+function startHandwritingGate(): (() => void)[] {
+  const gate = new HandwritingGate({
+    enabled: () => useSettingsStore.getState().getSetting(SETTINGS.neural_band_handwriting.key) !== false,
+    textFieldOpen: () => localMiniappRuntime.hasOpenTextField(),
+    setHandwriting: (id, enabled) => BluetoothSdk.neuralBandSetHandwriting(id, enabled),
+    setTimeout: (fn, ms) => BgTimer.setTimeout(fn, ms),
+    clearTimeout: (handle) => BgTimer.clearTimeout(handle as number),
+  })
+  handwriting = gate
+  gate.setBands(connectedBandIds())
+  return [
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.neural_band_handwriting.key),
+      () => gate.update(),
+    ),
+    localMiniappRuntime.onTextFieldChange(() => gate.update()),
+    neuralBandInput.onHandwritingStatus(({id, status}) => gate.status(id, status.phase)),
+    () => gate.dispose(),
+  ]
+}
+
 export function startNeuralBandSettingsSync(): void {
   if (unsubscribers.length > 0) return
   let connected = new Set(connectedBandIds())
   unsubscribers = [
+    ...startHandwritingGate(),
     useGlassesStore.subscribe(
       () => connectedBandIds().sort().join(","),
       () => {
@@ -44,8 +80,10 @@ export function startNeuralBandSettingsSync(): void {
           if (connected.has(id)) continue
           pushAirMouse(id)
           pushHand(id)
+          pushVibration(id)
         }
         connected = next
+        handwriting?.setBands([...next])
       },
     ),
     useSettingsStore.subscribe(
@@ -56,10 +94,15 @@ export function startNeuralBandSettingsSync(): void {
       (s) => s.getSetting(SETTINGS.neural_band_hand.key),
       () => connectedBandIds().forEach(pushHand),
     ),
+    useSettingsStore.subscribe(
+      (s) => s.getSetting(SETTINGS.neural_band_vibration.key),
+      () => connectedBandIds().forEach(pushVibration),
+    ),
   ]
 }
 
 export function stopNeuralBandSettingsSync(): void {
   for (const unsubscribe of unsubscribers) unsubscribe()
   unsubscribers = []
+  handwriting = null
 }

package/src/stores/appVisibility.ts

@@ -28,7 +28,6 @@ export const DEV_TOOLS_PACKAGES: ReadonlySet<string> = new Set([
   "com.glassly.example",
   "com.glassly.tetris",
   "com.glassly.compass",
-  "com.glassly.showcase",
 ])
 
 /** True when the app is dev-only and developer tools are off. */

package/src/stores/settings.ts

@@ -848,6 +848,24 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // Meta Neural Band handwriting typing into miniapps. Enabled means the band runs
+  // its handwriting model while a miniapp has a text field open on the glasses
+  // (HandwritingGate); the model streams the whole time it runs, so never otherwise.
+  neural_band_handwriting: {
+    key: "neural_band_handwriting",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  // The band's own buzz on each gesture (its haptics pattern 1; pattern 2 is silent).
+  neural_band_vibration: {
+    key: "neural_band_vibration",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   // Watch (Apple Watch, Wear OS): draw the glasses' current frame behind the watch
   // trackpad. Frames cross the watch link while the watch app is up, so it stays off
   // unless asked for.

package/src/types/enums.ts

@@ -24,4 +24,5 @@ export enum ControllerTypes {
   GAMEBRICK = "IINE Gamebrick",
   IINE_ANANKE = "IINE Ananke Gen 2",
   ZERO2 = "8BitDo Zero 2",
+  MICRO = "8BitDo Micro",
 }