diff --git a/.gitignore b/.gitignore index 6659b26a..326fbf1f 100644 --- a/.gitignore +++ b/.gitignore @@ -70,3 +70,9 @@ 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/ diff --git a/ACKNOWLEDGEMENTS.md b/ACKNOWLEDGEMENTS.md index a054eae1..4b7709b0 100644 --- a/ACKNOWLEDGEMENTS.md +++ b/ACKNOWLEDGEMENTS.md @@ -13,6 +13,22 @@ and others who contributed to documenting the G2's bluetooth protocol and firmwa G2 microphone LC3 decoding uses Google's liblc3: https://github.com/google/liblc3 +Even G1 support builds on ScouterKit (MIT License), by the ScouterKit authors: +https://github.com/mafik/scouter_kit. The firmware Faceclaw installs on a G1 is a +modified build of its g1v0, using the Zephyr RTOS and Nordic's nRF Connect SDK; the +parts of it that are Even Realities' own are downloaded from Even, not shipped here. + +RayNeo iO support builds on the Glassly SDK and custom firmware by Tetramo, Inc. +and Mentra Labs, Inc. (MIT License): https://github.com/tetramo-labs/glassly and +https://github.com/tetramo-labs/glassly-rayneo-cfw. The iO wire codecs in +native/kotlin/shared/.../rayneo/RayNeoIoProtocol.kt follow their protocol work. + +Bluetooth keyboard support on the G2 uses the keyboard bridge Tetramo, Inc. wrote +for their Glassly custom firmware (https://github.com/tetramo-labs/g2flash). +Faceclaw's client for it, in app/g2/keyboard/ and app/apps/terminal/terminal-keys.ts, +follows the reference client in that repository and the keyboard handling in the +Glassly app (MIT License): https://github.com/tetramo-labs/glassly. + iPhone notification icons are Pebble's notification and timeline icons, from https://github.com/pebble-dev/iconography: the original Pebble Technology icons and Rebble community additions. They are licensed under the Apache License 2.0; diff --git a/App_Resources/Android/app.gradle b/App_Resources/Android/app.gradle index 997e1f4d..f610bbff 100644 --- a/App_Resources/Android/app.gradle +++ b/App_Resources/Android/app.gradle @@ -19,6 +19,9 @@ dependencies { // app's captions (translation models download on demand, per language). implementation 'com.google.mlkit:language-id:17.0.6' implementation 'com.google.mlkit:translate:17.0.3' + // Pure-Java Opus decoder for the RayNeo iO's microphone (16 kHz mono Opus over + // BLE); the same one Glassly uses. See AndroidSpeechEngines.OpusDecoderAdapter. + implementation 'io.github.jaredmdobson:concentus:1.0.1' } def faceclawSherpaOnnxVersion = "1.13.0" @@ -261,15 +264,21 @@ if (faceclawVersionFile.exists()) { faceclawVersionName = faceclawVersionMatch.group(1) } } +def faceclawBuildRevision = System.getenv("FACECLAW_ANDROID_BUILD_REVISION") ?: "0" +if (!(faceclawBuildRevision ==~ /[0-4]/)) { + throw new GradleException("FACECLAW_ANDROID_BUILD_REVISION must be an integer from 0 to 4") +} def faceclawVersionCode = { // Prerelease labels belong in versionName, not the numeric versionCode. def parts = (faceclawVersionName.split('-')[0].tokenize('.') + ["0", "0"]).take(3)*.toInteger() - return parts[0] * 10000 + parts[1] * 100 + parts[2] + // Last digit: build revision * 2, plus form factor (phone 0, Wear OS 1). + // Play requires distinct version codes even on separate form-factor tracks. + return (parts[0] * 10000 + parts[1] * 100 + parts[2]) * 10 + faceclawBuildRevision.toInteger() * 2 }() android { - compileSdkVersion 35 - buildToolsVersion "35" + compileSdkVersion 36 + buildToolsVersion "36.0.0" // ndkVersion "" sourceSets.main { @@ -279,7 +288,7 @@ android { defaultConfig { minSdkVersion 24 - targetSdkVersion 35 + targetSdkVersion 36 ndk { // The NativeScript platform build.gradle has already added all four // ABIs by the time app.gradle is applied, and abiFilters is additive, diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt index 2921e222..f5ffece3 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSessionLink.kt @@ -46,6 +46,15 @@ class AndroidSessionLink(private val bleManager: FaceclawBleManager) : SessionLi override fun isBonded(address: String): Boolean = bleManager.isBonded(address) + override fun requestBond(address: String) = bleManager.requestBond(address) + + override fun removeBond(address: String): Boolean = bleManager.removeBond(address) + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = + bleManager.hasCharacteristic(address, characteristicUuid) + + override fun refreshServices(address: String, timeoutMs: Int): Boolean = bleManager.refreshServices(address, timeoutMs) + override fun prepareBenchmarkLink(address: String, mode: Int) = bleManager.prepareBenchmarkLink(address, mode) override fun recordDisplayFrameSent() = FaceclawBleManager.recordDisplayFrameSent() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt index 2b149f09..83357d08 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidSpeechEngines.kt @@ -94,6 +94,44 @@ internal object AndroidSpeechEngines { override fun close() = decoder.close() } + /** + * The RayNeo iO's microphone: one 16 kHz mono Opus packet per BLE message (its remote + * audio stream, GlassesSessionIo), decoded with Concentus. No G2 DSP metadata; packets + * carry no counter, so "missing" stays 0 and a lost one is just a gap. + */ + class OpusDecoderAdapter : AudioPacketDecoder { + private val decoder = io.github.jaredmdobson.OpusDecoder(RayNeoIoProtocol.VOICE_SAMPLE_RATE, 1) + private var packets = 0L + private var errors = 0L + + override fun decodePacket(packet: ByteArray?, pcmOut: ShortArray?): Int { + if (packet == null || packet.isEmpty() || pcmOut == null) return 0 + return try { + val count = decoder.decode(packet, 0, packet.size, pcmOut, 0, pcmOut.size, false) + packets++ + count + } catch (e: io.github.jaredmdobson.OpusException) { + errors++ + if (errors == 1L || errors % 100 == 0L) { + android.util.Log.w("FaceclawVoice", "Opus decode error ($errors so far): ${e.message}") + } + 0 + } + } + + /** 120 ms, Opus's longest frame. */ + override val maxSamplesPerPacket: Int get() = RayNeoIoProtocol.VOICE_SAMPLE_RATE * 120 / 1000 + override val hasFrameMeta: Boolean get() = false + override val lastAngleDegrees: Int get() = 0 + override val lastSsr: Int get() = 0 + override val realPackets: Long get() = packets + override val duplicatePackets: Long get() = 0 + override val missingPackets: Long get() = 0 + override val decodeErrors: Long get() = errors + + override fun close() = decoder.resetState() + } + /** * Open the phone's own microphone at the pipeline's native format (16 kHz * mono PCM16), or null when it cannot start — the permission is missing diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt index 3e7d264e..c4ef4a5b 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/AndroidStockLink.kt @@ -48,6 +48,17 @@ class AndroidStockLink(context: Context) : StockLink, FaceclawBleListener { else -> BondState.UNKNOWN } + override fun negotiatedMtu(address: String): Int = bleManager.getNegotiatedMtu(address) + + override fun requestBond(address: String) = bleManager.requestBond(address) + + override fun removeBond(address: String): Boolean = bleManager.removeBond(address) + + override fun hasCharacteristic(address: String, characteristicUuid: String): Boolean = + bleManager.hasCharacteristic(address, characteristicUuid) + + override fun refreshServices(address: String, timeoutMs: Int): Boolean = bleManager.refreshServices(address, timeoutMs) + override fun disconnect(address: String) = bleManager.disconnect(address) override fun close() = bleManager.close() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt index df92ac5f..531244ce 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleCommunicator.kt @@ -189,6 +189,28 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun setRequiredFirmwareRevision(revision: Int) = core.setRequiredFirmwareRevision(revision) + /** + * Drive a RayNeo iO (constructed with its address as both arms and no ring). The phone's + * protocol identity is derived from ANDROID_ID so it survives reinstalls: the glasses bind + * to the first identity that authenticates and refuse others until put in pairing mode. + */ + fun useRayNeoIo() { + val androidId = try { + android.provider.Settings.Secure.getString(appContext.contentResolver, android.provider.Settings.Secure.ANDROID_ID) + } catch (_: Exception) { + null + } + val seed = "faceclaw-rayneo-phone-id:" + (androidId ?: android.os.Build.FINGERPRINT) + val phoneId = java.security.MessageDigest.getInstance("SHA-256").digest(seed.toByteArray(Charsets.UTF_8)).copyOf(6) + val model = android.os.Build.MODEL ?: "Android" + core.useRayNeoIo(phoneId, model, android.os.Build.MANUFACTURER ?: "Android", model) + } + + fun isRayNeoIo(): Boolean = core.isRayNeoIo() + + /** Drive an Even G1 on g1v0 (two arms, as a G2 pair's addresses). */ + fun useG1() = core.useG1() + fun start() { if (core.start()) { activeInstance = this @@ -235,6 +257,9 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun setFaceclawWakeLeaseEnabled(enabled: Boolean): Boolean = core.setFaceclawWakeLeaseEnabled(enabled) + /** See [GlassesSessionCore.setVoiceWakeEnabled]. */ + fun setVoiceWakeEnabled(enabled: Boolean) = core.setVoiceWakeEnabled(enabled) + fun awaitEvenHubSessionReady(timeoutMs: Int): Boolean = core.awaitEvenHubSessionReady(timeoutMs) fun setImuReportEnabled(enable: Boolean, reportFrq: Int) = core.setImuReportEnabled(enable, reportFrq) @@ -304,6 +329,13 @@ class FaceclawBleCommunicator(context: Context, rightAddress: String?, leftAddre fun sendFaceclawMicControl(record: ByteArray?, label: String, rightTemple: Boolean, leftTemple: Boolean): Boolean = core.sendFaceclawMicControl(record, label, rightTemple, leftTemple) + fun addKeyboardEventListener(listener: FaceclawKeyboardEventListener?) = core.addKeyboardEventListener(listener) + + fun removeKeyboardEventListener(listener: FaceclawKeyboardEventListener?) = core.removeKeyboardEventListener(listener) + + fun sendFaceclawKeyboardControl(record: ByteArray?, label: String): Boolean = + core.sendFaceclawKeyboardControl(record, label) + fun startG2AudioForwarding(listener: FaceclawAudioPacketListener?): Boolean = core.startG2AudioForwarding(listener) fun stopG2AudioForwarding() = core.stopG2AudioForwarding() diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt index fd303744..3782e821 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawBleManager.kt @@ -27,6 +27,11 @@ import java.util.concurrent.atomic.AtomicLong class FaceclawBleManager(context: Context) { companion object { private const val TAG = "FaceclawBle" + + /** Not public API, but long stable, and the only way short of sending the user to Settings. */ + fun removeBond(device: BluetoothDevice): Boolean = + device.bondState == BluetoothDevice.BOND_NONE || device.javaClass.getMethod("removeBond").invoke(device) == true + private val WRITE_RETRY_DELAYS_MS = intArrayOf(1, 1, 1, 2, 4, 8, 12, 20, 35, 100, 200) // Gap after each LE 2M PHY request before checking whether it landed and asking @@ -160,6 +165,36 @@ class FaceclawBleManager(context: Context) { } } + /** + * Remove this phone's half of a pairing the other side no longer has. False when the platform refused. + */ + fun removeBond(address: String?): Boolean { + if (address == null || address.trim().isEmpty()) { + return false + } + return try { + removeBond(bluetoothAdapter.getRemoteDevice(address)) + } catch (t: Throwable) { + Log.w(TAG, "removeBond failed: $address", t) + false + } + } + + /** Start bonding, without waiting: the OS may ask the user, and [isBonded] tells when it is done. */ + fun requestBond(address: String?) { + if (address == null || address.trim().isEmpty()) { + return + } + try { + val device = bluetoothAdapter.getRemoteDevice(address) + if (device.bondState == BluetoothDevice.BOND_NONE) { + Log.i(TAG, "requestBond " + address + ": " + device.createBond()) + } + } catch (t: Throwable) { + Log.w(TAG, "requestBond failed: " + address, t) + } + } + /** * Android's bond state for this address (BluetoothDevice.BOND_NONE / * BOND_BONDING / BOND_BONDED), or -1 when it cannot be determined. @@ -364,6 +399,31 @@ class FaceclawBleManager(context: Context) { return status == BluetoothGatt.GATT_SUCCESS } + /** After discovery: whether the service table has this characteristic. */ + fun hasCharacteristic(address: String, characteristicUuid: String): Boolean { + synchronized(bluetoothApiLock) { + val gatt = links[address]?.gatt ?: return false + val target = UUID.fromString(characteristicUuid) + return gatt.services.any { it.getCharacteristic(target) != null } + } + } + + /** + * Forget the service table Android remembers for a bonded device and read it again. A G1 arm keeps its address across an + * install that changes its services, and a cached table would make new firmware look like the old one. + */ + fun refreshServices(address: String, timeoutMs: Int): Boolean { + synchronized(bluetoothApiLock) { + val gatt = links[address]?.gatt ?: return false + try { + gatt.javaClass.getMethod("refresh").invoke(gatt) + } catch (t: Throwable) { + Log.w(TAG, "refresh failed: $address", t) + } + } + return discoverServices(address, timeoutMs) + } + fun enableNotifications(address: String, characteristicUuid: String, enable: Boolean, timeoutMs: Int): Boolean { synchronized(bluetoothApiLock) { val gatt = requireGatt(address) diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt index b43bcaae..13074560 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawDeviceDiscovery.kt @@ -129,13 +129,21 @@ class FaceclawDeviceDiscovery(context: Context) { && manufacturerData[0] == 0x45.toByte() && manufacturerData[1] == 0x52.toByte()) { return true } + // RayNeo iO: manufacturer company 0x5716 ([07][MAC]...) outside pairing mode; + // in pairing mode only the "RayNeo iO-xxxx" name identifies it. + if (manufacturerData != null && manufacturerData.size >= 2 + && manufacturerData[0] == 0x16.toByte() && manufacturerData[1] == 0x57.toByte()) { + return true + } if (name == null) { return false } val upper = name.uppercase() // A bare "R1" substring also matches unrelated hardware ("Oppo Enco // R1"), and TS only classifies rings from the stock name prefix. - return upper.contains("G2") || upper.startsWith("EVEN R1") + // Even G1: its stock name, or g1v0's G1CFW_L_XXXXXX (before 0.5.66: G1v0_L, G1v0S_R). + return upper.contains("G2") || upper.startsWith("EVEN R1") || upper.startsWith("RAYNEO") || + upper.startsWith("EVEN G1") || upper.startsWith("G1CFW_") || upper.startsWith("G1V0") } private fun buildJson( diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt new file mode 100644 index 00000000..bcb22f7d --- /dev/null +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawG1Flasher.kt @@ -0,0 +1,106 @@ +package com.faceclaw.app + +import android.content.Context +import android.os.Handler +import android.os.Looper + +/** + * Android host for the shared [G1ArmFlashFlow]: owns the GATT link and the worker thread for one G1 arm's install, its + * restore to Even's firmware, or a question about what it runs, and delivers listener callbacks on the main thread. For app/native/g1-flasher.ts. + */ +class FaceclawG1Flasher( + context: Context, + address: String?, + side: String?, + firmwarePath: String?, + netCorePath: String?, + mode: String?, + connectWindowMs: Int, +) { + private val link = AndroidStockLink(context.applicationContext) + private val mainHandler = Handler(Looper.getMainLooper()) + private val lock = Any() + + @Volatile + private var listener: FaceclawFirmwareFlasherListener? = null + + @Volatile + private var worker: Thread? = null + + private val flow = + G1ArmFlashFlow( + link, + address ?: "", + side ?: "", + firmwarePath ?: "", + netCorePath ?: "", + G1ArmFlashFlow.mode(mode ?: ""), + connectWindowMs, + object : FaceclawFirmwareFlasherListener { + override fun onLog(line: String?) { + android.util.Log.i(G1ArmFlashFlow.TAG, line ?: "") + post { it.onLog(line) } + } + + override fun onProgress( + lens: String?, + componentIndex: Int, + componentCount: Int, + blockIndex: Int, + blockCount: Int, + bytesSent: Long, + bytesTotal: Long, + ) = post { it.onProgress(lens, componentIndex, componentCount, blockIndex, blockCount, bytesSent, bytesTotal) } + + override fun onState(state: String?, detail: String?) = post { it.onState(state, detail ?: "") } + + override fun onComplete(success: Boolean, detail: String?) = post { it.onComplete(success, detail ?: "") } + }, + ) + + fun setListener(listener: FaceclawFirmwareFlasherListener?) { + this.listener = listener + } + + fun start() { + synchronized(lock) { + if (worker != null) { + return + } + val w = Thread({ flow.run() }, "faceclaw-g1-flash") + worker = w + w.start() + } + } + + fun cancel() { + flow.cancel() + } + + fun close() { + cancel() + try { + link.close() + } catch (ignored: Exception) { + } + } + + companion object { + /** The phone's pairing with an address these glasses no longer use. */ + @JvmStatic + fun forgetPairing(context: Context, address: String?) { + if (address == null) return + val manager = context.applicationContext.getSystemService(Context.BLUETOOTH_SERVICE) as android.bluetooth.BluetoothManager + FaceclawBleManager.removeBond(manager.adapter.getRemoteDevice(address)) + } + } + + private fun post(action: (FaceclawFirmwareFlasherListener) -> Unit) { + mainHandler.post { + val current = listener + if (current != null) { + action(current) + } + } + } +} diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt index ad0531bb..239f08cc 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawVoiceController.kt @@ -114,7 +114,24 @@ class FaceclawVoiceController(context: Context) { } } - override fun createPacketDecoder(): AudioPacketDecoder = AndroidSpeechEngines.Lc3DecoderAdapter() + override fun micArrayLink(): MicArrayLink? { + val currentCommunicator = communicator ?: return null + return object : MicArrayLink { + override fun startForwarding(listener: FaceclawAudioPacketListener): Boolean = + currentCommunicator.startG2AudioForwarding(listener) + + override fun stopForwarding() = currentCommunicator.stopG2AudioForwarding() + + override fun isForwarding(): Boolean = currentCommunicator.isAudioCaptureActive() + + override fun sendControl(record: ByteArray, label: String, rightTemple: Boolean, leftTemple: Boolean): Boolean = + currentCommunicator.sendFaceclawMicControl(record, label, rightTemple, leftTemple) + } + } + + override fun createPacketDecoder(): AudioPacketDecoder = + if (communicator?.isRayNeoIo() == true) AndroidSpeechEngines.OpusDecoderAdapter() + else AndroidSpeechEngines.Lc3DecoderAdapter() override fun openPhoneMic(): PcmAudioSource? = AndroidSpeechEngines.openPhoneMic(PHONE_MIC_CHUNK_SAMPLES) @@ -134,12 +151,15 @@ class FaceclawVoiceController(context: Context) { override fun release() {} } } - - override fun recordingSink(): RecordingSink = RecordingSink { pcmBytes, sampleRate -> saveRecording(pcmBytes, sampleRate) } } private val session = VoiceCaptureSession(host) + // The recording of this controller's live captures (see startRecording). It outlives any one + // capture, and is only handed to the session while recording is enabled. + private var recording: MicRecordingWriter? = null + private var recordingEnabled = true + fun setListener(listener: FaceclawVoiceControllerListener?) { session.setListener(listener) } @@ -153,11 +173,6 @@ class FaceclawVoiceController(context: Context) { session.setUsePhoneMic(usePhoneMic) } - /** When true, the decoded mic PCM for each session is saved as a WAV. */ - fun setSaveRecordings(saveRecordings: Boolean) { - session.setSaveRecordings(saveRecordings) - } - /** * Which on-device model {@link #start}("onboard") should load: "whisper" * selects the second on-device model (sherpa-onnx offline Whisper); any @@ -206,6 +221,88 @@ class FaceclawVoiceController(context: Context) { session.setBeamFilter(enabled, centerDeg, halfWidthDeg) } + /** + * Capture glasses sessions from the temples' own microphones (the custom firmware's + * mic_control stream) instead of the stock mixed stream. [configureRecord] is the CONFIGURE + * record to arm both temples with; null goes back to the mixed stream. Must be set before + * {@link #start}. + */ + fun setMicArray(configureRecord: ByteArray?) { + session.setMicArray(configureRecord) + } + + /** + * Have the next {@link #start} play the recording at [path] (a .mka file) from [startMs] in + * place of any microphone; null goes back to the microphones. Progress arrives through the + * listener's onReplay. + */ + fun setReplay(path: String?, startMs: Long) { + session.setReplay(path, startMs) + } + + /** Continue the running replay from [positionMs] into its recording. */ + fun seekReplay(positionMs: Long) { + session.seekReplay(positionMs) + } + + fun setReplayPaused(paused: Boolean) { + session.setReplayPaused(paused) + } + + /** + * Record live captures to a new Matroska audio file at [path], from now until + * {@link #stopRecording}, across however many captures run in between: every source's audio + * as it arrives, before any processing. [configJson] describes the capture and is stored in + * the file. Returns false when the file cannot be created. + */ + @Synchronized + fun startRecording(path: String, configJson: String?): Boolean { + stopRecording() + return try { + val parent = File(path).parentFile + if (parent != null && !parent.exists()) parent.mkdirs() + recording = MicRecordingWriter(openFileOutput(path), configJson, System.currentTimeMillis()) + session.setRecorder(if (recordingEnabled) recording else null) + true + } catch (t: Throwable) { + Log.w(TAG, "could not create recording $path", t) + recording = null + false + } + } + + /** + * Whether captures are written to the recording right now: off while the capture running + * isn't one that is to be recorded. + */ + @Synchronized + fun setRecordingEnabled(enabled: Boolean) { + recordingEnabled = enabled + session.setRecorder(if (enabled) recording else null) + } + + /** Whether a recording is open and still being written (false once writing to it failed). */ + @Synchronized + fun isRecording(): Boolean = recording?.failed == false + + /** + * Note a change in what is being captured (a JSON object) at the recording's current + * position; the audio after it is placed afresh on the recording's timeline. + */ + @Synchronized + fun noteRecordingEvent(json: String) { + recording?.event(json) + } + + /** Complete the recording's file. Returns its length in ms, or -1 when none was open. */ + @Synchronized + fun stopRecording(): Long { + val current = recording ?: return -1 + recording = null + session.setRecorder(null) + return current.finish() + } + fun start(requestedMode: String?) { session.start(requestedMode, 0) } @@ -231,29 +328,6 @@ class FaceclawVoiceController(context: Context) { stop() } - /** Save the session's decoded mic PCM as a 16 kHz mono 16-bit WAV. */ - private fun saveRecording(pcmBytes: ByteArray, sampleRate: Int) { - try { - val dir = File(appContext.getExternalFilesDir(null), "voice-recordings") - if (!dir.exists() && !dir.mkdirs()) { - Log.w(TAG, "could not create voice-recordings dir") - return - } - val stamp = java.text.SimpleDateFormat("yyyyMMdd-HHmmss-SSS", java.util.Locale.US) - .format(java.util.Date()) - val file = File(dir, "voice-$stamp.wav") - java.io.FileOutputStream(file).use { fos -> - fos.write(BinaryEncoding.wavHeader(pcmBytes.size, sampleRate, 1)) - fos.write(pcmBytes) - } - Log.i(TAG, "saved voice recording " + file.absolutePath - + " samples=" + (pcmBytes.size / 2) - + " sec=" + String.format(java.util.Locale.US, "%.2f", pcmBytes.size / 2.0 / sampleRate)) - } catch (t: Throwable) { - Log.w(TAG, "failed to save voice recording", t) - } - } - /** * The on-device model directory for the given kind, populated by the * download flow in asr-model.ts (releases before 0.5.0 copied the diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FontFileRenderer.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FontFileRenderer.kt index fa33d1c3..b4597b71 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FontFileRenderer.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FontFileRenderer.kt @@ -167,6 +167,7 @@ class FontFileRenderer private constructor() { * [width u16][height u16] * [width*height coverage bytes, gamma-mapped] * An ink-free glyph (space) has width = height = 0 but a valid advance. + * A color glyph (emoji) carries its ColorGlyphArt shade as its coverage. * Empty array when the font cannot be loaded or the render fails. */ @JvmStatic @@ -196,11 +197,16 @@ class FontFileRenderer private constructor() { } val penX = pad - bounds.left val baselineY = pad - bounds.top - val bitmap = Bitmap.createBitmap(bw, bh, Bitmap.Config.ALPHA_8) + // Drawn in color: an emoji the system fallback supplies from a color font + // would keep only its silhouette in an alpha-only bitmap. ColorGlyphArt shades + // color glyphs and passes white ones through as their alpha. + val bitmap = Bitmap.createBitmap(bw, bh, Bitmap.Config.ARGB_8888) val canvas = Canvas(bitmap) canvas.drawText(text, penX.toFloat(), baselineY.toFloat(), paint) - val pixels = alpha8Pixels(bitmap, bw, bh) + val argb = IntArray(bw * bh) + bitmap.getPixels(argb, 0, bw, 0, 0, bw, bh) bitmap.recycle() + val pixels = ColorGlyphArt.coverage(argb) // Trim to the tight ink box; bearing/inkTop become pen- and // line-relative inside the shared packer. diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/ImageFileLoader.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/ImageFileLoader.kt index 1df754f9..5b0167b2 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/ImageFileLoader.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/ImageFileLoader.kt @@ -108,6 +108,64 @@ class ImageFileLoader private constructor() { } } + /** Longest side decodeRgbaFromBytes decodes at; larger images are subsampled. */ + private const val MAX_RGBA_SIDE = 4096 + + /** + * Decode encoded image bytes (JPEG, PNG, WebP, GIF's first frame, BMP) + * to [widthLo, widthHi, heightLo, heightHi, R, G, B, A, ...] at native + * size, not premultiplied, so a transparent pixel keeps its colour; + * empty when undecodable. The EvenHub host converts these to grey the + * way the Even app does (app/apps/evenhub/image-pipeline.ts). + */ + @JvmStatic + fun decodeRgbaFromBytes(buffer: java.nio.ByteBuffer?): ByteArray { + if (buffer == null) return ByteArray(0) + try { + val source = buffer.duplicate() + source.rewind() + val data = ByteArray(source.remaining()) + source.get(data) + if (data.isEmpty()) return ByteArray(0) + val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true } + BitmapFactory.decodeByteArray(data, 0, data.size, bounds) + if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return ByteArray(0) + var sample = 1 + while (maxOf(bounds.outWidth, bounds.outHeight) / sample > MAX_RGBA_SIDE) sample *= 2 + val options = BitmapFactory.Options().apply { + inPreferredConfig = Bitmap.Config.ARGB_8888 + inPremultiplied = false + inSampleSize = sample + } + val bitmap = BitmapFactory.decodeByteArray(data, 0, data.size, options) ?: return ByteArray(0) + val width = bitmap.width + val height = bitmap.height + val argb = IntArray(width * height) + bitmap.getPixels(argb, 0, width, 0, 0, width, height) + bitmap.recycle() + val packet = ByteArray(4 + argb.size * 4) + packet[0] = (width and 0xff).toByte() + packet[1] = ((width shr 8) and 0xff).toByte() + packet[2] = (height and 0xff).toByte() + packet[3] = ((height shr 8) and 0xff).toByte() + for (i in argb.indices) { + val pixel = argb[i] + val o = 4 + i * 4 + packet[o] = (pixel shr 16).toByte() + packet[o + 1] = (pixel shr 8).toByte() + packet[o + 2] = pixel.toByte() + packet[o + 3] = (pixel ushr 24).toByte() + } + return packet + } catch (e: Exception) { + Log.w(TAG, "RGBA image decode failed", e) + return ByteArray(0) + } catch (e: OutOfMemoryError) { + Log.w(TAG, "RGBA image decode failed", e) + return ByteArray(0) + } + } + /** * Scale a bitmap to fit within maxWidth x maxHeight (preserving aspect, * never upscaling) and convert it to the grayscale packet format. diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/PreviewBitmapUtil.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/PreviewBitmapUtil.kt index 75135480..c7a53588 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/PreviewBitmapUtil.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/PreviewBitmapUtil.kt @@ -62,7 +62,7 @@ class PreviewBitmapUtil private constructor() { /** * A white-on-transparent bitmap of an 8bpp glasses icon (gray becomes * alpha; black, which the glasses show as unlit, is transparent), for - * showing glasses artwork on the phone's dark action bar. + * showing glasses artwork in the phone UI, which tints it to suit. */ @JvmStatic fun whiteIconFromGray(gray: ByteBuffer?, width: Int, height: Int): Bitmap { diff --git a/App_Resources/Android/src/main/res/drawable/ic_tab_keyboard.xml b/App_Resources/Android/src/main/res/drawable/ic_control_keyboard.xml similarity index 72% rename from App_Resources/Android/src/main/res/drawable/ic_tab_keyboard.xml rename to App_Resources/Android/src/main/res/drawable/ic_control_keyboard.xml index 4e531df8..95c0470a 100644 --- a/App_Resources/Android/src/main/res/drawable/ic_tab_keyboard.xml +++ b/App_Resources/Android/src/main/res/drawable/ic_control_keyboard.xml @@ -1,7 +1,7 @@ - + - + icon #1368757); base fill is overridden by tint-color in remote-controls.css. --> + + + + diff --git a/App_Resources/iOS/Assets.xcassets/ic_tab_keyboard.imageset/Contents.json b/App_Resources/iOS/Assets.xcassets/ic_control_keyboard.imageset/Contents.json similarity index 74% rename from App_Resources/iOS/Assets.xcassets/ic_tab_keyboard.imageset/Contents.json rename to App_Resources/iOS/Assets.xcassets/ic_control_keyboard.imageset/Contents.json index aae26278..b98be0ae 100644 --- a/App_Resources/iOS/Assets.xcassets/ic_tab_keyboard.imageset/Contents.json +++ b/App_Resources/iOS/Assets.xcassets/ic_control_keyboard.imageset/Contents.json @@ -2,7 +2,7 @@ "images": [ { "idiom": "universal", - "filename": "ic_tab_keyboard@3x.png", + "filename": "ic_control_keyboard@3x.png", "scale": "3x" } ], diff --git a/App_Resources/iOS/Assets.xcassets/ic_tab_keyboard.imageset/ic_tab_keyboard@3x.png b/App_Resources/iOS/Assets.xcassets/ic_control_keyboard.imageset/ic_control_keyboard@3x.png similarity index 100% rename from App_Resources/iOS/Assets.xcassets/ic_tab_keyboard.imageset/ic_tab_keyboard@3x.png rename to App_Resources/iOS/Assets.xcassets/ic_control_keyboard.imageset/ic_control_keyboard@3x.png diff --git a/App_Resources/iOS/Assets.xcassets/ic_tab_mic.imageset/Contents.json b/App_Resources/iOS/Assets.xcassets/ic_control_mic.imageset/Contents.json similarity index 76% rename from App_Resources/iOS/Assets.xcassets/ic_tab_mic.imageset/Contents.json rename to App_Resources/iOS/Assets.xcassets/ic_control_mic.imageset/Contents.json index b5dfb395..43d26907 100644 --- a/App_Resources/iOS/Assets.xcassets/ic_tab_mic.imageset/Contents.json +++ b/App_Resources/iOS/Assets.xcassets/ic_control_mic.imageset/Contents.json @@ -2,7 +2,7 @@ "images": [ { "idiom": "universal", - "filename": "ic_tab_mic@3x.png", + "filename": "ic_control_mic@3x.png", "scale": "3x" } ], diff --git a/App_Resources/iOS/Assets.xcassets/ic_tab_mic.imageset/ic_tab_mic@3x.png b/App_Resources/iOS/Assets.xcassets/ic_control_mic.imageset/ic_control_mic@3x.png similarity index 100% rename from App_Resources/iOS/Assets.xcassets/ic_tab_mic.imageset/ic_tab_mic@3x.png rename to App_Resources/iOS/Assets.xcassets/ic_control_mic.imageset/ic_control_mic@3x.png diff --git a/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/Contents.json b/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/Contents.json new file mode 100644 index 00000000..15ba8958 --- /dev/null +++ b/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/Contents.json @@ -0,0 +1,13 @@ +{ + "images": [ + { + "idiom": "universal", + "filename": "ic_control_settings@3x.png", + "scale": "3x" + } + ], + "info": { + "author": "xcode", + "version": 1 + } +} diff --git a/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/ic_control_settings@3x.png b/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/ic_control_settings@3x.png new file mode 100644 index 00000000..91306b40 Binary files /dev/null and b/App_Resources/iOS/Assets.xcassets/ic_control_settings.imageset/ic_control_settings@3x.png differ diff --git a/App_Resources/iOS/Info.plist b/App_Resources/iOS/Info.plist index 77b3edd1..d2f2fe6a 100644 --- a/App_Resources/iOS/Info.plist +++ b/App_Resources/iOS/Info.plist @@ -13,7 +13,7 @@ CFBundleDisplayName Faceclaw CFBundleShortVersionString - 0.8.6 + 0.9.0 CFBundleVersion 1 LSRequiresIPhoneOS @@ -57,6 +57,26 @@ Faceclaw connects to the terminal servers and developer app URLs you configure on your local network. UILaunchScreen + + UIApplicationSceneManifest + + UIApplicationSupportsMultipleScenes + + UISceneConfigurations + + UIWindowSceneSessionRoleApplication + + + UISceneConfigurationName + Default Configuration + UISceneDelegateClassName + SceneDelegate + + + + UISupportedInterfaceOrientations UIInterfaceOrientationPortrait diff --git a/App_Resources/iOS/build.xcconfig b/App_Resources/iOS/build.xcconfig index 331a8be9..e8254dfe 100644 --- a/App_Resources/iOS/build.xcconfig +++ b/App_Resources/iOS/build.xcconfig @@ -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 -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 -framework WatchConnectivity -weak_framework FoundationModels ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; diff --git a/App_Resources/iOS/src/FaceclawFontRenderer.m b/App_Resources/iOS/src/FaceclawFontRenderer.m index d7598ca6..823f93b3 100644 --- a/App_Resources/iOS/src/FaceclawFontRenderer.m +++ b/App_Resources/iOS/src/FaceclawFontRenderer.m @@ -1,6 +1,7 @@ #import "FaceclawFontRenderer.h" #import #import +#import #import // Immutable font descriptors may be shared; layout objects never cross threads. @@ -42,8 +43,9 @@ static BOOL HasColorRun(CTLineRef line) { } // iOS falls back to Apple Color Emoji for default-text symbols the face lacks // (▶ U+25B6 in Roboto), where Android's minikin picks a text font; the -// alpha-only raster keeps just the emoji's silhouette (▶ becomes a solid -// rounded square). Request text presentation (U+FE0E) for each lone codepoint +// emoji is a tile (▶ becomes a rounded square: a silhouette in the alpha-only +// line rasters, a shaded tile in glyph cells), which reads worse than the +// text symbol. Request text presentation (U+FE0E) for each lone codepoint // that fell back to a color font, wherever a text font can supply it. Returns // `text` itself when nothing changes. static NSString *PreferTextPresentation(CTFontRef font, NSString *text, CTLineRef line, BOOL glyphLayout) { @@ -78,18 +80,34 @@ static BOOL ValidText(NSString *text) { return text != nil && text.length <= 100 static BOOL ValidRaster(NSInteger width, NSInteger height) { return width > 0 && height > 0 && width <= 65535 && height <= 65535 && width * height <= 4000000; } +static void ConfigureTextContext(CGContextRef ctx) { + CGContextSetShouldAntialias(ctx, true); + CGContextSetShouldSmoothFonts(ctx, false); // Grayscale coverage, never LCD subpixel color. + CGContextSetShouldSubpixelPositionFonts(ctx, true); + CGContextSetShouldSubpixelQuantizeFonts(ctx, false); + CGContextSetTextMatrix(ctx, CGAffineTransformIdentity); +} static CGContextRef CreateContext(NSMutableData *pixels, NSInteger width, NSInteger height) CF_RETURNS_RETAINED { CGContextRef ctx = CGBitmapContextCreate(pixels.mutableBytes, width, height, 8, width, NULL, (CGBitmapInfo)kCGImageAlphaOnly); if (ctx) { - CGContextSetShouldAntialias(ctx, true); - CGContextSetShouldSmoothFonts(ctx, false); // Grayscale coverage, never LCD subpixel color. - CGContextSetShouldSubpixelPositionFonts(ctx, true); - CGContextSetShouldSubpixelQuantizeFonts(ctx, false); - CGContextSetTextMatrix(ctx, CGAffineTransformIdentity); + ConfigureTextContext(ctx); CGContextSetGrayFillColor(ctx, 1, 1); } return ctx; } +// Premultiplied RGBA bytes, for a line with a color (emoji) run: an alpha-only raster keeps +// just the emoji's silhouette, so its colors go to ColorGlyphArt to be shaded instead. +static CGContextRef CreateColorContext(NSMutableData *pixels, NSInteger width, NSInteger height) CF_RETURNS_RETAINED { + CGColorSpaceRef space = CGColorSpaceCreateWithName(kCGColorSpaceSRGB); + CGContextRef ctx = CGBitmapContextCreate(pixels.mutableBytes, width, height, 8, width * 4, space, + (CGBitmapInfo)kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big); + CGColorSpaceRelease(space); + if (ctx) { + ConfigureTextContext(ctx); + CGContextSetRGBFillColor(ctx, 1, 1, 1, 1); + } + return ctx; +} static void U16(uint8_t *out, NSInteger value) { out[0] = value & 255; out[1] = (value >> 8) & 255; } static void GammaCopy(uint8_t *dst, const uint8_t *src, NSInteger count, double gamma) { if (!isfinite(gamma) || gamma <= 0) gamma = 1; @@ -150,10 +168,13 @@ static NSData *ImagePacket(NSData *pixels, NSInteger width, NSInteger height, do NSInteger bottom = floor(CGRectGetMinY(bounds)) - 2; NSInteger width = ceil(CGRectGetMaxX(bounds)) + 2 - left, height = top - bottom; if (!ValidRaster(width, height)) { CFRelease(line); CFRelease(font); return [NSData data]; } - NSMutableData *pixels = [NSMutableData dataWithLength:width * height]; - CGContextRef ctx = CreateContext(pixels, width, height); + BOOL color = HasColorRun(line); + NSMutableData *raster = [NSMutableData dataWithLength:width * height * (color ? 4 : 1)]; + CGContextRef ctx = color ? CreateColorContext(raster, width, height) : CreateContext(raster, width, height); if (!ctx) { CFRelease(line); CFRelease(font); return [NSData data]; } CGContextSetTextPosition(ctx, -left, -bottom); CTLineDraw(line, ctx); CGContextRelease(ctx); + NSData *pixels = color ? [[FaceclawKitIosColorGlyph shared] shadeRgba:raster] : raster; + if ((NSInteger)pixels.length != width * height) { CFRelease(line); CFRelease(font); return [NSData data]; } const uint8_t *src = pixels.bytes; NSInteger x0 = width, y0 = height, x1 = -1, y1 = -1; for (NSInteger y = 0; y < height; y++) for (NSInteger x = 0; x < width; x++) if (src[y * width + x]) { diff --git a/App_Resources/iOS/src/FaceclawGraphics.h b/App_Resources/iOS/src/FaceclawGraphics.h index 2f71ddcd..f948c1e3 100644 --- a/App_Resources/iOS/src/FaceclawGraphics.h +++ b/App_Resources/iOS/src/FaceclawGraphics.h @@ -14,4 +14,10 @@ + (NSData *)bgraPacket:(CGImageRef)image maxSize:(NSInteger)maxSize; /** bgraPacket of encoded image bytes (JPEG, PNG, ...); nil when undecodable. */ + (NSData *)bgraPacketFromImageData:(NSData *)data maxSize:(NSInteger)maxSize; +/** + * [widthLo, widthHi, heightLo, heightHi, RGBA...] of encoded image bytes at native size + * (at most 4096 px a side), first frame only; nil when undecodable. CoreGraphics + * premultiplies, so transparent pixels come out black. For the EvenHub image pipeline. + */ ++ (NSData *)rgbaPacketFromImageData:(NSData *)data; @end diff --git a/App_Resources/iOS/src/FaceclawGraphics.m b/App_Resources/iOS/src/FaceclawGraphics.m index cd8f3f16..fbc7fb9e 100644 --- a/App_Resources/iOS/src/FaceclawGraphics.m +++ b/App_Resources/iOS/src/FaceclawGraphics.m @@ -158,4 +158,26 @@ CGImageRelease(image); return packet; } ++ (NSData *)rgbaPacketFromImageData:(NSData *)data { + if (!data.length) return nil; + CGImageSourceRef source = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL); + if (!source) return nil; + CGImageRef image = CGImageSourceCreateImageAtIndex(source, 0, NULL); + CFRelease(source); + if (!image) return nil; + size_t width = CGImageGetWidth(image), height = CGImageGetHeight(image); + if (width == 0 || height == 0 || width > 4096 || height > 4096) { CGImageRelease(image); return nil; } + uint8_t dimensions[] = { width & 255, (width >> 8) & 255, height & 255, (height >> 8) & 255 }; + NSMutableData *packet = [NSMutableData dataWithBytes:dimensions length:4]; + [packet increaseLengthBy:width * height * 4]; + CGColorSpaceRef space = CGColorSpaceCreateDeviceRGB(); + CGContextRef context = CGBitmapContextCreate((uint8_t *)packet.mutableBytes + 4, width, height, 8, width * 4, space, + kCGBitmapByteOrder32Big | (CGBitmapInfo)kCGImageAlphaPremultipliedLast); + CGColorSpaceRelease(space); + if (!context) { CGImageRelease(image); return nil; } + CGContextDrawImage(context, CGRectMake(0, 0, width, height), image); + CGContextRelease(context); + CGImageRelease(image); + return packet; +} @end diff --git a/App_Resources/iOS/src/FaceclawWatchBridge.h b/App_Resources/iOS/src/FaceclawWatchBridge.h new file mode 100644 index 00000000..1cde6ba8 --- /dev/null +++ b/App_Resources/iOS/src/FaceclawWatchBridge.h @@ -0,0 +1,43 @@ +#import + +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 diff --git a/App_Resources/iOS/src/FaceclawWatchBridge.m b/App_Resources/iOS/src/FaceclawWatchBridge.m new file mode 100644 index 00000000..a20d74ac --- /dev/null +++ b/App_Resources/iOS/src/FaceclawWatchBridge.m @@ -0,0 +1,272 @@ +#import "FaceclawWatchBridge.h" +#import +#import + +// 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 () +@property(nonatomic, copy, nullable) void (^messageHandler)(NSString *, NSString *); +@property(nonatomic, copy, nullable) void (^connectionHandler)(void); +@property(nonatomic, strong) NSMutableArray *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 *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 *)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 *)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 *)context { + dispatch_async(dispatch_get_main_queue(), ^{ [self deliverBatteryFrom:context]; }); +} + +@end diff --git a/App_Resources/iOS/src/module.modulemap b/App_Resources/iOS/src/module.modulemap index 2ef469f1..9bc01ad2 100644 --- a/App_Resources/iOS/src/module.modulemap +++ b/App_Resources/iOS/src/module.modulemap @@ -14,5 +14,6 @@ module FaceclawGraphics { header "FaceclawLoopbackRedirect.h" header "FaceclawWebSignIn.h" header "FaceclawResourceUsage.h" + header "FaceclawWatchBridge.h" export * } diff --git a/CHANGELOG b/CHANGELOG index 125d7a77..78c74f45 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,5 +1,26 @@ # Changelog +## 0.9.0 - 2026-11-08 + +### Major Features + +* Add support for the Even Realities G1 +* Add support for the Apple Watch + +### Minor Features +* Show charging case battery for the G2 +* Terminals now default to opening in the same window rather than opening a new window +* Better rendering of color emojis +* Inrease the max timeout for glanceboard show-on-tap display +* Fix some minor issues in the oboarding flow +* Add option to auto-close notification popups after a delay + +### Bug Fixes + +* Fix an issue that would cause microphone permission check to fail if you swiped away the Android Activity +* Fix an issue that broke the Nightscout widget on the status bar on iOS +* Fix an issue were EvenHub app texet containers weren't indented correctly + ## 0.8.6 - 2026-11-01 * Connect directly to the R1 ring rather than indirectly via the glasses diff --git a/CLAUDE.md b/CLAUDE.md index 128f6379..839e965e 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -13,7 +13,14 @@ 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. -`build.sh` and `build_wear.sh` build the Android and Wear OS apps respectively. +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_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 @@ -36,7 +43,10 @@ local checkout above this workspace at ../g2-kit-unofficial. This Android app uses a modded firmware for the G2 smart glasses. Source code to the corresponding firmware modifications lives in https://github.com/jimrandomh/g2flash; there is a compiled version of the -firmware patch-set in app/g2/firmware/cfw-patches.ts. Strongly prefer making -changes to the Android app over making changes to changes to the firmware, as -firmware development is considerably more fraught. +firmware patch-set in app/g2/firmware/cfw-patches.ts, regenerated by +scripts/update_deltas.sh. Even G1 glasses run g1v0, a firmware from ScouterKit +(currently checked out at ~/src/scouter_kit, in g1_firmware/); Faceclaw embeds +it in app/g1/firmware/, regenerated by scripts/update_g1_firmware.sh VERSION. +Strongly prefer making changes to the Android app over making changes to the +firmware, as firmware development is considerably more fraught. diff --git a/PRIVACY b/PRIVACY index f906afdf..7b17a895 100644 --- a/PRIVACY +++ b/PRIVACY @@ -5,6 +5,8 @@ collects and shares information when you use an iOS TestFlight build, even when Faceclaw statistics are set to None. Information you voluntarily send us, such as feedback, may also identify you. This policy describes these separate channels and the third-party services you can choose to use. +On Android, Google ML Kit also collects SDK diagnostics separately from +Faceclaw statistics, as described below. ## Usage Statistics @@ -16,7 +18,8 @@ your choice at any time in Settings > Privacy > Faceclaw statistics. Until you choose, it is None. This setting controls only Faceclaw's own statistics. With None, Faceclaw sends and stores none of its own usage statistics. This -does not disable Apple's TestFlight reports or services you choose to use. +does not disable Apple's TestFlight reports, Google ML Kit diagnostics, or +services you choose to use. With Minimal, Faceclaw keeps counts on your phone and sends them about once a day to stats.faceclaw.org, a server run by Faceclaw's developers: @@ -48,6 +51,27 @@ phone, and stops all reports; turning them back on starts a new identifier. The statistics server doesn't record the IP addresses reports come from. +## Android and Google ML Kit + +Android translation and language identification use Google ML Kit. The +developer QR-code scanner uses Google's code scanner. Text and scanner +images are processed on-device, but the SDKs send Google diagnostic and +usage metrics over HTTPS: device/app details, installation identifiers, +timings, errors, feature events, input/output sizes, and detected or +configured languages. Translation also uses Firebase installation and +remote-configuration services. This reporting is separate from the +Faceclaw statistics setting; selecting None does not turn it off. Faceclaw +does not provide a switch to disable these SDK diagnostics. + +These metrics do not include the text being translated or scanned images. +Cloud transcription and assistant providers are separate, as described below. +For Google's handling of SDK metrics, see: + + https://developers.google.com/ml-kit/android-data-disclosure + https://developers.google.com/ml-kit/terms + https://policies.google.com/privacy + + ## iOS and TestFlight For TestFlight builds, Apple automatically collects crash reports and beta diff --git a/README.md b/README.md index 39655e62..fc17edc5 100644 --- a/README.md +++ b/README.md @@ -39,7 +39,7 @@ The instructions below build the Android app. If you want to customize faceclaw, the best way to do it is to download the source code and using a coding agent such as Codex or Claude Code. -To compile, you will need an Android SDK environment with SDK version 35 +To compile, you will need an Android SDK environment with SDK version 36 installed and licenses accepted, and the ANDROID_HOME pointing to the install. You will need Nativescript installed, and a JDK environment (v21), with the JAVA_HOME environment variable pointed at it. You will also need a reasonably @@ -163,6 +163,9 @@ 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 diff --git a/app/analytics/privacy-disclosure.ts b/app/analytics/privacy-disclosure.ts index 9cc2ed43..2ba2d915 100644 --- a/app/analytics/privacy-disclosure.ts +++ b/app/analytics/privacy-disclosure.ts @@ -1,10 +1,9 @@ -/** Conditional wording: also shown on self-built iOS apps, where TestFlight does not apply. */ -export const IOS_PRIVACY_NOTICE = [ - "If installed with TestFlight, Apple automatically collects crash logs, installs, sessions, and device/app details and shares them with Faceclaw's developers. This continues even when Faceclaw statistics are None; the app cannot turn it off.", - "Joining only through a public link hides your name and email from us, not from Apple. Email invitations can identify you. Optional feedback can disclose your email, comments, screenshots and diagnostics. Review what you send.", - "iPhone Settings > Privacy & Security > Analytics & Improvements controls ordinary iOS analytics. It does not stop TestFlight crash reports. Faceclaw cannot change Apple's analytics settings.", - "To leave the beta, open Faceclaw in TestFlight and choose Stop Testing, then stop using and uninstall the beta. This does not erase earlier reports. Details: Settings > Privacy > Privacy policy.", -].join("\n\n"); - +/** + * One-line pointer for iOS. The full TestFlight disclosure lives only in the + * PRIVACY file (shown in-app as Settings > Privacy > Privacy policy). + */ export const IOS_PRIVACY_SUMMARY = - "With TestFlight, crash/usage reports continue even with None. Open iOS / TestFlight privacy for details."; + "With TestFlight, crash/usage reports continue even with None. See Privacy policy for details."; + +export const ANDROID_PRIVACY_SUMMARY = + "Google ML Kit diagnostics for translation and QR scanning are separate from this setting. See Privacy policy for details."; diff --git a/app/app.css b/app/app.css index b59200cd..89a15377 100644 --- a/app/app.css +++ b/app/app.css @@ -1,6 +1,7 @@ @import '@nativescript/theme/css/core.css'; @import '@nativescript/theme/css/default.css'; @import './phone-ui/remote-controls.css'; +@import './phone-ui/settings-page.css'; @import './phone-ui/pairing.css'; Page { @@ -17,9 +18,8 @@ ActionItem { color: #ffffff; } -/* The main page's custom titleView: title left; the EvenHub app icon, - * connection status and the warning triangle right-aligned beside the - * overflow menu. */ +/* The main page's custom titleView: title left; connection status and the + * warning triangle right-aligned beside the overflow menu. */ .action-bar-title { color: #ffffff; font-size: 18; @@ -34,16 +34,6 @@ ActionItem { vertical-align: center; } -/* The foreground EvenHub app's icon (opens its phone UI); the padding widens - * the tap target. */ -.action-bar-app-icon { - width: 32; - height: 32; - padding: 5.5; - margin-right: 8; - vertical-align: center; -} - /* The emoji brings its own yellow; the padding widens the tap target. */ .action-bar-warning { font-size: 18; @@ -81,12 +71,6 @@ Button.-primary { font-size: 18; } -/* The logo art is black-on-transparent; tint it light in dark mode so it - * doesn't vanish into the dark page background. */ -.ns-dark .onboarding-logo { - tint-color: #e6e6e6; -} - /* License / privacy-policy links in the onboarding disclaimer footer. The * padding widens the tap target beyond the small text. */ .footer-link { diff --git a/app/app.ios.css b/app/app.ios.css index 4245407f..e0eace16 100644 --- a/app/app.ios.css +++ b/app/app.ios.css @@ -1,10 +1,12 @@ @import '@nativescript/theme/css/core.css'; @import './phone-ui/remote-controls.css'; +@import './phone-ui/settings-page.css'; @import './phone-ui/pairing.css'; .body-text { font-size: 18; } .h1 { font-size: 28; font-weight: bold; } .footer-link { color: #285c45; padding: 4 8; text-decoration: underline; } +.ns-dark .footer-link { color: #7bc47f; } Page { background-color: #f5f5f2; @@ -35,8 +37,6 @@ Page.main-page { .main-page .action-bar-title { font-size: 18; font-weight: bold; color: #ffffff; } .main-page .action-bar-status { font-size: 14; color: #ffffff; margin-right: 12; } .main-page .action-bar-warning { font-size: 18; padding: 4 6; } -/* Matches Android's 32x32 padded icon; the Image inside is 21x21. */ -.main-page .action-bar-app-icon { width: 32; height: 32; margin-right: 8; } .main-page .overflow-button { background-color: transparent; color: #ffffff; @@ -46,9 +46,6 @@ Page.main-page { margin: 0; padding: 0; } -/* Match Android's button layout boxes, including the inset around each tile. */ -.main-page Button.tab-button { height: 48; margin-top: 6; margin-bottom: 6; } -.main-page .mode-button { background-color: #e2e2e2; color: #333333; border-radius: 6; } .main-page .ble-bandwidth-indicator { color: #777777; font-size: 12; padding: 2 8; } .main-page .system-name-modal { diff --git a/app/apps/ai-chat/ai-chat-app.ts b/app/apps/ai-chat/ai-chat-app.ts index 2c897fd6..95e9ac02 100644 --- a/app/apps/ai-chat/ai-chat-app.ts +++ b/app/apps/ai-chat/ai-chat-app.ts @@ -13,6 +13,10 @@ import { createInProcessWindow, type InProcessAppOptions, type InProcessWindow } import { shell } from "../../ui/shell/shell"; import { VoiceDraft } from "./voice-draft"; +/** The transcript's scrollbar, hugging the window's right padding, and the gap the text keeps from it. */ +const SCROLLBAR_WIDTH = 2; +const SCROLLBAR_GAP = 11; + class AiChatLayer implements Layer { readonly acceptsDirectional = true; private firstLine: number | null = null; // null follows the streaming tail @@ -38,24 +42,30 @@ class AiChatLayer implements Layer { } paint(ctx: LayerContext): GrayImage { const size = ctx.stack.getBaseSize(); + const { padding } = size; const image = new GrayImage(size.width, size.height); const font = getDefaultSmallFont(); const step = font.lineHeight + 3; - const left = 12; - const width = size.width - 28; + // The title, and the footer under the transcript, stay put inside the + // padding suggested for the window's edges; the transcript scrolls + // between them. Text runs from the left padding to the gutter kept for + // the scrollbar. + const left = padding.left; + const scrollbarX = size.width - padding.right - SCROLLBAR_WIDTH; + const width = Math.max(0, scrollbarX - SCROLLBAR_GAP - left); const record = this.conversations.current(); if (this.selectedId !== record.id) { this.selectedId = record.id; this.firstLine = null; } const transcript = record.session?.transcript ?? record.history?.transcript ?? []; const title = this.conversations.title(); - image.drawText(font, left, 6, truncateText(font, title, width), 180); + image.drawText(font, left, padding.top, truncateText(font, title, width), 180); const label = assistantBackendSetting.get() === "external" ? "External agent" : `${assistantModelLabel(record.model)} · ${record.reasoning === "default" ? "default reasoning" : record.reasoning}`; const footer = wrapText(font, `${label} ${gestureHints([ [GESTURE_CLICK, "menu"], [GESTURE_DOUBLE_CLICK, "back"], [GESTURE_LONG_PRESS, "hold to talk"], ])}`, width); - const footerY = size.height - step * footer.length; + const footerY = size.height - padding.bottom - font.lineHeight - step * (footer.length - 1); const footerTop = footerY - step * 3 - 12; - const historyTop = step + 16; + const historyTop = padding.top + step + 10; const visible = Math.max(1, Math.floor((footerTop - historyTop - 8) / step)); const lines: { text: string; color: number }[] = []; for (const entry of transcript) { @@ -82,7 +92,7 @@ class AiChatLayer implements Layer { if (this.maxFirstLine > 0) { const track = visible * step; const thumb = Math.max(8, Math.floor(track * visible / lines.length)); - image.fillRect(size.width - 5, historyTop + Math.floor((track - thumb) * first / this.maxFirstLine), 2, thumb, 110); + image.fillRect(scrollbarX, historyTop + Math.floor((track - thumb) * first / this.maxFirstLine), SCROLLBAR_WIDTH, thumb, 110); } image.fillRect(left, footerTop, width, 1, 65); const state = this.draft.active ? this.draft.status : record.session?.status || this.draft.status; diff --git a/app/apps/app-definition.ts b/app/apps/app-definition.ts index e8616706..88c8a9c8 100644 --- a/app/apps/app-definition.ts +++ b/app/apps/app-definition.ts @@ -30,6 +30,13 @@ export type AppDefinition = { boot?: (ctx: AppContext) => void; /** False for apps that must not appear in the launcher grid (the launcher itself). */ showInLauncher?: boolean; + /** + * False while the paired glasses can't run the app (absent means they can). + * It then leaves the launcher grid and what mirrors it: the watch remote and + * the apps.launch tool. A window restored from before a re-pair still opens, + * so the app needs to say what's wrong rather than assume it never runs. + */ + isSupported?: () => boolean; /** Present on the app that handles text shared via the Android share intent. */ openSharedText?: (ctx: AppContext, title: string, text: string) => void; /** @@ -182,6 +189,8 @@ export async function launchWorkerAppWindow( matchExistingBy?: "appId" | "windowId"; /** Deliver watch swipes raw instead of the fallback (see WorkerWindowSpec). */ acceptsDirectional?: boolean; + /** Deliver hardware-keyboard keys as keys (see WorkerWindowSpec). */ + acceptsKeys?: boolean; }, ): Promise { const existing = shell @@ -202,6 +211,7 @@ export async function launchWorkerAppWindow( icon: options.icon, focus: true, acceptsDirectional: options.acceptsDirectional, + acceptsKeys: options.acceptsKeys, }); ctx.appendLog(`launched ${options.windowId}`); } diff --git a/app/apps/blocks/blocks-app.worker.ts b/app/apps/blocks/blocks-app.worker.ts index 7ab33372..0ada183f 100644 --- a/app/apps/blocks/blocks-app.worker.ts +++ b/app/apps/blocks/blocks-app.worker.ts @@ -25,6 +25,7 @@ import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { type MenuItem } from "../../ui/menu"; import { WindowMenu } from "../../ui/window-menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import { directionalFallback, GESTURE_CLICK, @@ -155,6 +156,13 @@ type BlocksWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there. The window menu's layers + * lay out by it; the game's own layout is fixed art that keeps its place + * (see LAYOUT_HEIGHT). + */ + viewport: Viewport; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; @@ -207,6 +215,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -295,13 +304,15 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); + window.viewport = message.viewport; + window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; if (window.foreground) renderAndSubmit(window, 0); break; } case "navigation-sensors": case "text-input": + case "key": case "tool-call": break; } @@ -357,7 +368,7 @@ function windowMenu(window: BlocksWindow): WindowMenu { title: () => window.title, items: () => (window.phase === "playing" ? [] : windowMenuItems(window)), claimsLongPress: () => window.phase === "playing", - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: window.viewport, paintBase: () => paintContent(window), isFocused: () => window.focused, }); diff --git a/app/apps/calculator/calculator-graph.ts b/app/apps/calculator/calculator-graph.ts index 62c73362..f0a14e6d 100644 --- a/app/apps/calculator/calculator-graph.ts +++ b/app/apps/calculator/calculator-graph.ts @@ -35,25 +35,27 @@ export function drawGraph( const clampX = (x: number): number => Math.max(rect.x, Math.min(rect.x + rect.width - 1, x)); const clampY = (y: number): number => Math.max(rect.y, Math.min(rect.y + rect.height - 1, y)); - // Tick grid first so the curve and axes draw over it. + // Tick grid first so the curve and axes draw over it. A tick or axis at + // the viewport's far limit lands on the frame's last column or row, not + // past it: the caller may have run the rect to the window's edge. for (const tick of graph.xAxis.ticks) { if (tick < viewport.xMin || tick > viewport.xMax) continue; - const x = Math.round(px(tick)); + const x = Math.round(clampX(px(tick))); image.drawLine(x, rect.y, x, rect.y + rect.height - 1, GRID_VALUE); } for (const tick of graph.yAxis.ticks) { if (tick < viewport.yMin || tick > viewport.yMax) continue; - const y = Math.round(py(tick)); + const y = Math.round(clampY(py(tick))); image.drawLine(rect.x, y, rect.x + rect.width - 1, y, GRID_VALUE); } // Axes. if (viewport.yMin <= 0 && viewport.yMax >= 0) { - const y = Math.round(py(0)); + const y = Math.round(clampY(py(0))); image.drawLine(rect.x, y, rect.x + rect.width - 1, y, AXIS_VALUE); } if (viewport.xMin <= 0 && viewport.xMax >= 0) { - const x = Math.round(px(0)); + const x = Math.round(clampX(px(0))); image.drawLine(x, rect.y, x, rect.y + rect.height - 1, AXIS_VALUE); } diff --git a/app/apps/calculator/calculator.ts b/app/apps/calculator/calculator.ts index 6c7b3263..b6da988a 100644 --- a/app/apps/calculator/calculator.ts +++ b/app/apps/calculator/calculator.ts @@ -62,6 +62,24 @@ export const calculatorDegreesSetting = new ConfigSettingBoolean({ const CONTINUOUS_CLIENT = "calculator"; const DICTATION_HOLDER = "calculator-dictation"; +// --------------------------------------------------------------------------- +// Layout + +/** + * The column the view is laid out in: the window's width inside the padding + * suggested for its side edges (viewport.ts). Tabs, text, the plot and the + * footer all start at its left; centred text is centred in it. + */ +type Column = { x: number; width: number }; + +/** Below the tabs' text top: their underline, and where the body starts. */ +const TAB_UNDERLINE_OFFSET = 20; +const BODY_TOP_OFFSET = 31; +/** Indent, on both sides, of wrapped body text (a failure's reason, a step's detail, an answer). */ +const BODY_INDENT = 8; +/** The same for the prompt of an empty view, which keeps well clear of the sides. */ +const PROMPT_INDENT = 24; + // --------------------------------------------------------------------------- // Layer @@ -380,14 +398,17 @@ export class CalculatorLayer implements Layer { // Paint paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const small = getDefaultSmallFont(); + const column: Column = { x: padding.left, width: Math.max(0, width - padding.left - padding.right) }; - this.paintTabs(image, small, width); + // The tabs sit at the top edge's padding and the footer at the bottom's; + // the body is what lies between. + this.paintTabs(image, small, column, padding.top); - const footerY = height - small.lineHeight - 6; - const bodyTop = 46; + const footerY = height - padding.bottom - small.lineHeight; + const bodyTop = padding.top + BODY_TOP_OFFSET; let bodyBottom = footerY - 4; // A standing offer or a running deep pass takes the rows just above the @@ -395,35 +416,36 @@ export class CalculatorLayer implements Layer { const offer = this.coordinator.pendingLongRun; const progress = this.coordinator.longRunProgress; if (offer || progress) { - bodyBottom = this.paintLongRunPanel(image, small, width, bodyBottom, offer, progress); + bodyBottom = this.paintLongRunPanel(image, small, column, bodyBottom, offer, progress); } if (this.working) { - this.drawCentered(image, small, Math.round((bodyTop + bodyBottom) / 2) - 8, "Working…", 180); + this.drawCentered(image, small, column, Math.round((bodyTop + bodyBottom) / 2) - 8, "Working…", 180); } else if (this.lastFailure !== null) { - this.paintFailure(image, small, width, bodyTop, bodyBottom); + this.paintFailure(image, small, column, bodyTop, bodyBottom); } else if (this.mode === "explain" && this.coordinator.stepPosition !== null) { - this.paintExplain(image, width, bodyTop, bodyBottom); + this.paintExplain(image, column, bodyTop, bodyBottom); } else if (this.mode === "graph" && this.coordinator.lastGraph) { - this.paintGraph(image, small, width, bodyTop, bodyBottom); + this.paintGraph(image, small, column, bodyTop, bodyBottom); } else if (this.lastAnswer) { - this.paintAnswer(image, width, bodyTop, bodyBottom); + this.paintAnswer(image, column, bodyTop, bodyBottom); } else { - this.paintEmpty(image, small, width, bodyTop, bodyBottom); + this.paintEmpty(image, small, column, bodyTop, bodyBottom); } - image.drawText(small, 24, footerY, this.footerHints(), 110); + image.drawText(small, column.x, footerY, this.footerHints(), 110); return image; } - /** The three modes as tabs, plus the deg/listening status chips. */ - private paintTabs(image: GrayImage, font: UiFont, width: number): void { - let x = 24; + /** The three modes as tabs from `y` down, plus the deg/listening status chips. */ + private paintTabs(image: GrayImage, font: UiFont, column: Column, y: number): void { + let x = column.x; + const underlineY = y + TAB_UNDERLINE_OFFSET; for (const mode of CALCULATOR_MODES) { const label = modeLabel(mode); const active = mode === this.mode; - image.drawText(font, x, 15, label, active ? 245 : 105); - image.drawLine(x, 35, x + font.measureText(label), 35, active ? 200 : 30); + image.drawText(font, x, y, label, active ? 245 : 105); + image.drawLine(x, underlineY, x + font.measureText(label), underlineY, active ? 200 : 30); x += font.measureText(label) + 18; } @@ -433,28 +455,28 @@ export class CalculatorLayer implements Layer { else if (this.continuousActive && this.foreground) chips.push("mic on"); if (chips.length > 0) { const text = chips.join(" · "); - image.drawText(font, width - 24 - font.measureText(text), 15, text, this.dictating ? 220 : 110); + image.drawText(font, column.x + column.width - font.measureText(text), y, text, this.dictating ? 220 : 110); } } private paintFailure( image: GrayImage, font: UiFont, - width: number, + column: Column, bodyTop: number, bodyBottom: number, ): void { - this.paintHeardLine(image, font, width, bodyTop); + this.paintHeardLine(image, font, column, bodyTop); const top = this.lastInput ? bodyTop + lineStep(font) + 6 : bodyTop + 8; - const lines = wrapText(font, this.lastFailure ?? "", width - 64); + const lines = wrapText(font, this.lastFailure ?? "", column.width - 2 * BODY_INDENT); const step = lineStep(font); const maxLines = Math.max(1, Math.floor((bodyBottom - top) / step)); for (let index = 0; index < Math.min(lines.length, maxLines); index++) { - image.drawText(font, 32, top + index * step, lines[index]!, 200); + image.drawText(font, column.x + BODY_INDENT, top + index * step, lines[index]!, 200); } } - private paintExplain(image: GrayImage, width: number, bodyTop: number, bodyBottom: number): void { + private paintExplain(image: GrayImage, column: Column, bodyTop: number, bodyBottom: number): void { const small = getDefaultSmallFont(); const medium = getDefaultMediumFont(); const position = this.coordinator.stepPosition; @@ -463,63 +485,65 @@ export class CalculatorLayer implements Layer { if (!position || !step) return; let y = bodyTop + 2; - image.drawText(small, 24, y, `Step ${position.index + 1} of ${position.total}`, 130); + image.drawText(small, column.x, y, `Step ${position.index + 1} of ${position.total}`, 130); y += lineStep(small) + 2; - image.drawText(medium, 24, y, truncateText(medium, step.title, width - 48), 245); + image.drawText(medium, column.x, y, truncateText(medium, step.title, column.width), 245); y += lineStep(medium) + 2; - image.drawText(medium, 24, y, truncateText(medium, plain(step.expression), width - 48), 220); + image.drawText(medium, column.x, y, truncateText(medium, plain(step.expression), column.width), 220); y += lineStep(medium) + 6; - const detailLines = wrapText(small, step.detail, width - 64); + const detailLines = wrapText(small, step.detail, column.width - 2 * BODY_INDENT); const stepPitch = lineStep(small); const maxLines = Math.max(0, Math.floor((bodyBottom - y) / stepPitch)); for (let index = 0; index < Math.min(detailLines.length, maxLines); index++) { - image.drawText(small, 32, y + index * stepPitch, detailLines[index]!, 150); + image.drawText(small, column.x + BODY_INDENT, y + index * stepPitch, detailLines[index]!, 150); } } private paintGraph( image: GrayImage, font: UiFont, - width: number, + column: Column, bodyTop: number, bodyBottom: number, ): void { const graph = this.coordinator.lastGraph; if (!graph) return; const headline = this.lastAnswer.split("\n")[0] ?? ""; - image.drawText(font, 24, bodyTop, truncateText(font, headline, width - 48), 200); + image.drawText(font, column.x, bodyTop, truncateText(font, headline, column.width), 200); + // The plot's frame spans the column, so it meets the side padding itself. const plotTop = bodyTop + lineStep(font) + 4; drawGraph(image, graph, { - x: 18, + x: column.x, y: plotTop, - width: width - 36, + width: column.width, height: Math.max(2, bodyBottom - plotTop), }); } - private paintAnswer(image: GrayImage, width: number, bodyTop: number, bodyBottom: number): void { + private paintAnswer(image: GrayImage, column: Column, bodyTop: number, bodyBottom: number): void { const small = getDefaultSmallFont(); - this.paintHeardLine(image, small, width, bodyTop); + this.paintHeardLine(image, small, column, bodyTop); const top = this.lastInput ? bodyTop + lineStep(small) + 4 : bodyTop; // A short single-line answer earns the large font; anything longer drops // to the medium font and wraps. const lines = this.lastAnswer.split("\n"); const large = getDefaultLargeFont(); - if (lines.length === 1 && large.measureText(lines[0]!) <= width - 64) { + const maxWidth = column.width - 2 * BODY_INDENT; + if (lines.length === 1 && large.measureText(lines[0]!) <= maxWidth) { const y = Math.round((top + bodyBottom - large.lineHeight) / 2); - this.drawCentered(image, large, y, lines[0]!, 245); + this.drawCentered(image, large, column, y, lines[0]!, 245); return; } const medium = getDefaultMediumFont(); - const wrapped = lines.flatMap((line) => wrapText(medium, line, width - 64)); + const wrapped = lines.flatMap((line) => wrapText(medium, line, maxWidth)); const step = lineStep(medium); const maxLines = Math.max(1, Math.floor((bodyBottom - top) / step)); const shown = wrapped.slice(0, maxLines); let y = Math.max(top, Math.round((top + bodyBottom - shown.length * step) / 2)); for (const line of shown) { - this.drawCentered(image, medium, y, line, 235); + this.drawCentered(image, medium, column, y, line, 235); y += step; } } @@ -527,7 +551,7 @@ export class CalculatorLayer implements Layer { private paintEmpty( image: GrayImage, font: UiFont, - width: number, + column: Column, bodyTop: number, bodyBottom: number, ): void { @@ -536,31 +560,32 @@ export class CalculatorLayer implements Layer { : this.listening === "continuous" ? `Say a problem, then "${modeLabel(this.mode).toLowerCase()} it"` : "Tap to say a problem — or use Voice input to type one"; - const lines = wrapText(font, prompt, width - 96); + const lines = wrapText(font, prompt, column.width - 2 * PROMPT_INDENT); const step = lineStep(font); let y = Math.round((bodyTop + bodyBottom - lines.length * step) / 2); for (const line of lines) { - this.drawCentered(image, font, y, line, 150); + this.drawCentered(image, font, column, y, line, 150); y += step; } } - private paintHeardLine(image: GrayImage, font: UiFont, width: number, y: number): void { + private paintHeardLine(image: GrayImage, font: UiFont, column: Column, y: number): void { if (!this.lastInput) return; const label = this.textInput ? "Entered" : "Heard"; - image.drawText(font, 24, y, label, 110); - const x = 24 + font.measureText(label) + 10; - image.drawText(font, x, y, truncateText(font, this.lastInput, width - x - 24), 160); + image.drawText(font, column.x, y, label, 110); + const x = column.x + font.measureText(label) + 10; + image.drawText(font, x, y, truncateText(font, this.lastInput, column.x + column.width - x), 160); } /** * The standing offer, or the live progress of an accepted run, in the two - * rows above the footer. Returns the new body bottom. + * rows above the footer, under a rule across the column. Returns the new + * body bottom. */ private paintLongRunPanel( image: GrayImage, font: UiFont, - width: number, + column: Column, bodyBottom: number, offer: LongRunOffer | null, progress: LongRunProgress | null, @@ -572,9 +597,9 @@ export class CalculatorLayer implements Layer { ? offerGlassesPrompt(offer).split("\n") : []; const panelTop = bodyBottom - lines.length * step - 6; - image.drawLine(16, panelTop, width - 16, panelTop, 40); + if (column.width > 0) image.drawLine(column.x, panelTop, column.x + column.width - 1, panelTop, 40); for (let index = 0; index < lines.length; index++) { - image.drawText(font, 24, panelTop + 4 + index * step, truncateText(font, lines[index]!, width - 48), 190); + image.drawText(font, column.x, panelTop + 4 + index * step, truncateText(font, lines[index]!, column.width), 190); } return panelTop - 2; } @@ -604,8 +629,8 @@ export class CalculatorLayer implements Layer { ]); } - private drawCentered(image: GrayImage, font: UiFont, y: number, text: string, value: number): void { - const x = Math.max(0, Math.round((image.width - font.measureText(text)) / 2)); + private drawCentered(image: GrayImage, font: UiFont, column: Column, y: number, text: string, value: number): void { + const x = column.x + Math.max(0, Math.round((column.width - font.measureText(text)) / 2)); image.drawText(font, x, y, text, value); } } diff --git a/app/apps/calendar/calendar.ts b/app/apps/calendar/calendar.ts index 4272cd97..5d112ab4 100644 --- a/app/apps/calendar/calendar.ts +++ b/app/apps/calendar/calendar.ts @@ -8,14 +8,25 @@ import { GESTURE_CLICK, type InputEvent } from "../../ui/gestures"; import { hasCalendarPermission } from "../../native/calendar-permissions"; import { type Layer, type LayerContext } from "../../ui/layers"; import { lineStep } from "../../ui/metrics"; +import type { Viewport } from "../../ui/viewport"; -// Title position, shared with the other list apps (terminal, notifications). -const TITLE_X = 18; -const TITLE_Y = 10; -const LIST_TOP = 38; -const ROW_X = 16; +/** How far a row's text sits inside its selection box; the title lines up with it. */ +const ROW_TEXT_INSET = 10; +/** + * The title's drop below the window's top padding (the position shared with + * the other list apps: terminal, notifications), and the distance from its + * top to the first row. + */ +const TITLE_OFFSET_Y = 2; +const TITLE_BAND = 28; const ROW_GAP = 4; const MAX_EVENTS = 50; +/** + * The message shown in place of the list (no permission, nothing to show): + * its indent from the title, and its drop below the window's top padding. + */ +const MESSAGE_INDENT = 6; +const MESSAGE_OFFSET_Y = 64; /** Height of the day header band above a row that starts a new day. */ function dayHeaderHeight(font: UiFont): number { @@ -46,20 +57,25 @@ export class CalendarLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const viewport = ctx.stack.getBaseSize(); + const { width, height, padding } = viewport; const image = new GrayImage(width, height, 0); + // Rows' selection boxes sit at the padding suggested for the window's + // side edges; the title lines up with their text. + const titleX = padding.left + ROW_TEXT_INSET; + const titleY = padding.top + TITLE_OFFSET_Y; if (!hasCalendarPermission()) { - image.drawText(font, TITLE_X, TITLE_Y, "Calendar", 220); - this.paintPermissionPrompt(image, font, width, height); + image.drawText(font, titleX, titleY, "Calendar", 220); + this.paintPermissionPrompt(image, font, viewport); return image; } const events = readUpcomingEvents(MAX_EVENTS); if (!events.length) { - image.drawText(font, TITLE_X, TITLE_Y, "Calendar", 220); + image.drawText(font, titleX, titleY, "Calendar", 220); const state = getCalendarReadState(); - image.drawText(font, 24, 72, state === "loading" ? "Loading calendar..." + image.drawText(font, titleX + MESSAGE_INDENT, padding.top + MESSAGE_OFFSET_Y, state === "loading" ? "Loading calendar..." : state === "error" ? "Calendar unavailable. Try again shortly." : "No upcoming events.", 190); return image; } @@ -67,22 +83,26 @@ export class CalendarLayer implements Layer { const rows = buildEventRows(font, events); this.selectedIndex = clamp(this.selectedIndex, 0, rows.length - 1); - const listBottom = height; - const scrollY = scrollForSelected(rows, this.selectedIndex, listBottom - LIST_TOP); + // The agenda scrolls, so it runs to the window's top and bottom edges + // and rows scrolled past an end are cut off right at the edge. The + // padding suggested for those edges is inside the scrolled content + // instead: above the title and below the last row. + const listTop = titleY + TITLE_BAND; + const scrollY = scrollForSelected(rows, this.selectedIndex, height - listTop, padding.bottom); // The title scrolls away with the list; row text is deferred glyphs // (composited above raster fills), so a fixed title would show through // rows scrolled over it. - if (TITLE_Y - scrollY + font.lineHeight > 0) { - image.drawText(font, TITLE_X, TITLE_Y - scrollY, "Calendar", 220); + if (titleY - scrollY + font.lineHeight > 0) { + image.drawText(font, titleX, titleY - scrollY, "Calendar", 220); } - let cursorY = LIST_TOP - scrollY; - for (let index = 0; index < rows.length; index++) { + const rowWidth = width - padding.left - padding.right; + let cursorY = listTop - scrollY; + for (let index = 0; index < rows.length && cursorY < height; index++) { const row = rows[index]!; - if (cursorY + row.height >= LIST_TOP && cursorY <= listBottom) { - drawEventRow(image, font, row, ROW_X, cursorY, width, index === this.selectedIndex); + if (cursorY + row.height > 0) { + drawEventRow(image, font, row, padding.left, cursorY, rowWidth, index === this.selectedIndex); } cursorY += row.height + ROW_GAP; - if (cursorY > listBottom + 80) break; } return image; } @@ -102,13 +122,21 @@ export class CalendarLayer implements Layer { } } - private paintPermissionPrompt(image: GrayImage, font: UiFont, width: number, height: number): void { + private paintPermissionPrompt(image: GrayImage, font: UiFont, viewport: Viewport): void { + const { width, height, padding } = viewport; const message = "Grant calendar permission on your phone to see your events on the glasses."; - const lines = wrapText(font, message, width - 48); - for (let index = 0; index < lines.length; index++) { - image.drawText(font, 24, 72 + index * lineStep(font), lines[index]!, 190); + // Indented under the title, and as far short of the right padding. + const indent = ROW_TEXT_INSET + MESSAGE_INDENT; + const x = padding.left + indent; + const lines = wrapText(font, message, width - padding.left - padding.right - 2 * indent); + // The hint rests on the bottom padding; the message keeps to the lines that fit above it. + const hintY = height - padding.bottom - font.lineHeight; + const top = padding.top + MESSAGE_OFFSET_Y; + const maxLines = Math.max(1, Math.floor((hintY - top) / lineStep(font))); + for (let index = 0; index < Math.min(lines.length, maxLines); index++) { + image.drawText(font, x, top + index * lineStep(font), lines[index]!, 190); } - image.drawText(font, 24, height - 36, `${GESTURE_CLICK} request`, 110); + image.drawText(font, x, hintY, `${GESTURE_CLICK} request`, 110); } } @@ -137,6 +165,7 @@ function buildEventRows(font: UiFont, events: CalendarEvent[]): EventRow[] { return rows; } +/** Draw a row whose selection box spans `width` from `x`; its day header and text sit ROW_TEXT_INSET inside that. */ function drawEventRow( image: GrayImage, font: UiFont, @@ -146,30 +175,38 @@ function drawEventRow( width: number, selected: boolean, ): void { + const textX = x + ROW_TEXT_INSET; let cursorY = y; if (row.dayHeader) { - image.drawText(font, x, cursorY + 2, row.dayHeader, 150); + image.drawText(font, textX, cursorY + 2, row.dayHeader, 150); cursorY += dayHeaderHeight(font); } const bodyHeight = row.lines.length * lineStep(font) + 4; if (selected) { - image.fillRoundedRect(x - 6, cursorY, width - 2 * (x - 6), bodyHeight, 15, 6); - image.drawRoundedRect(x - 6, cursorY, width - 2 * (x - 6), bodyHeight, 90, 6); + image.fillRoundedRect(x, cursorY, width, bodyHeight, 15, 6); + image.drawRoundedRect(x, cursorY, width, bodyHeight, 90, 6); } - const maxTextWidth = width - 2 * x; + const maxTextWidth = width - 2 * ROW_TEXT_INSET; for (let index = 0; index < row.lines.length; index++) { const value = index === 0 ? (selected ? 235 : 205) : 160; - image.drawText(font, x, cursorY + 3 + index * lineStep(font), truncateText(font, row.lines[index]!, maxTextWidth), value); + image.drawText(font, textX, cursorY + 3 + index * lineStep(font), truncateText(font, row.lines[index]!, maxTextWidth), value); } } -function scrollForSelected(rows: EventRow[], selectedIndex: number, viewportHeight: number): number { +/** + * The scroll offset that centers the selected row in `viewportHeight`, the + * room below the title's resting place, within the ends of what scrolls + * there: the rows, then `padBottom` after the last of them. So the first + * row rests with the title and the padding above it in view, and the last + * with the padding below it. + */ +function scrollForSelected(rows: EventRow[], selectedIndex: number, viewportHeight: number, padBottom: number): number { let selectedTop = 0; for (let index = 0; index < selectedIndex; index++) { selectedTop += rows[index]!.height + ROW_GAP; } const selectedBottom = selectedTop + rows[selectedIndex]!.height; - const contentHeight = rows.reduce((sum, row) => sum + row.height + ROW_GAP, 0); + const contentHeight = rows.reduce((sum, row) => sum + row.height + ROW_GAP, -ROW_GAP) + padBottom; const maxScroll = Math.max(0, contentHeight - viewportHeight); const centered = selectedTop - Math.max(0, (viewportHeight - (selectedBottom - selectedTop)) / 2); return clamp(centered | 0, 0, maxScroll); diff --git a/app/apps/compass/calibration-layer.ts b/app/apps/compass/calibration-layer.ts index 772fccef..f9af9b36 100644 --- a/app/apps/compass/calibration-layer.ts +++ b/app/apps/compass/calibration-layer.ts @@ -25,10 +25,6 @@ const INSTRUCTIONS_BY_FRAME: Record = { magnetic: "magnetic compass heading (as read by another compass), then adjust the calibration offset below", }; -/** Margins around the instruction paragraph. */ -const TEXT_PADDING_X = 16; -const TEXT_PADDING_TOP = 10; - export class CompassCalibrationLayer implements Layer { constructor( /** Current uncorrected magnetometer heading, or null before the first reading. */ @@ -36,7 +32,7 @@ export class CompassCalibrationLayer implements Layer { ) {} paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const small = getDefaultSmallFont(); const medium = getDefaultMediumFont(); @@ -47,14 +43,17 @@ export class CompassCalibrationLayer implements Layer { // Before the first reading there is no frame to name yet; the true-mode // wording is the default and the readout will correct it once data arrives. const frame = resolved?.frame ?? "true"; - const lines = wrapText(small, INSTRUCTIONS_PREAMBLE + INSTRUCTIONS_BY_FRAME[frame], width - TEXT_PADDING_X * 2); + // The instructions fill the width inside the padding suggested for the + // window's edges, from the top's down. + const lines = wrapText(small, INSTRUCTIONS_PREAMBLE + INSTRUCTIONS_BY_FRAME[frame], Math.max(0, width - padding.left - padding.right)); for (let i = 0; i < lines.length; i++) { - image.drawText(small, TEXT_PADDING_X, TEXT_PADDING_TOP + i * smallStep, lines[i]!, 190); + image.drawText(small, padding.left, padding.top + i * smallStep, lines[i]!, 190); } - const textBottom = TEXT_PADDING_TOP + lines.length * smallStep; + const textBottom = padding.top + lines.length * smallStep; - // Readouts along the bottom: dim label over a bright value, in thirds. - const valueTop = height - medium.lineHeight; + // Readouts along the bottom, above its padding: dim label over a bright + // value, in equal columns. + const valueTop = height - padding.bottom - medium.lineHeight; const labelTop = valueTop - small.lineHeight; const columns: Array<[string, string]> = [ ["Raw", raw === null ? "--°" : `${Math.round(raw)}°`], diff --git a/app/apps/compass/compass-app.ts b/app/apps/compass/compass-app.ts index 27cb1303..714515ce 100644 --- a/app/apps/compass/compass-app.ts +++ b/app/apps/compass/compass-app.ts @@ -10,6 +10,7 @@ import { type CompassDiagnostics, } from "../../native/compass"; import { wrapText } from "../../graphics/textwrap"; +import { glassesHaveCompass } from "../../ui/dashboard-settings"; import { type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { lineStep } from "../../ui/metrics"; @@ -40,18 +41,9 @@ export const COMPASS_SURFACE_ID = "window:compass"; const RECONCILE_INTERVAL_MS = 400; /** Vertical breathing room between the readout, the status line and the rose. */ const STACK_GAP = 8; -/** Padding above the readout and below the rose's near edge. */ -const TOP_PAD = 2; -const BOTTOM_PAD = 4; -/** Clearance between the rose's widest point and the viewport edge. */ -const EDGE_PAD = 8; -/** Inset of the top-right magnetometer calibration readout from the window edges. */ -const ACCURACY_TOP_PAD = TOP_PAD + 4; -const ACCURACY_RIGHT_PAD = EDGE_PAD + 4; /** Cap on the rose's radius, so a tall window doesn't get a comical one. */ const MAX_ROSE_RADIUS = 98; - class CompassLayer implements Layer { private rawHeading: number | null = null; private diagnostics: CompassDiagnostics | null = null; @@ -151,6 +143,7 @@ class CompassLayer implements Layer { } private statusText(): string { + if (!glassesHaveCompass()) return "These glasses have no compass sensor"; if (this.firmwareStatus !== null) return this.firmwareStatus; if (!this.enabled) return "Compass paused"; if (this.rawHeading === null) return "Waiting for compass data…"; @@ -159,35 +152,41 @@ class CompassLayer implements Layer { } paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const small = getDefaultSmallFont(); const large = getDefaultLargeFont(); const heading = this.rawHeading === null ? null : resolveHeading(this.rawHeading).displayDegrees; const headingText = heading === null ? "--°" : `${Math.round(heading)}° ${cardinalDirection(heading)}`; - const statusLines = wrapText(small, this.statusText(), width - STACK_GAP * 2); + // Text and the rose keep inside the padding suggested for the window's edges. + const textWidth = Math.max(0, width - padding.left - padding.right); + const statusLines = wrapText(small, this.statusText(), textWidth); const smallStep = lineStep(small); - const headingFont = large.measureText(headingText) <= width - EDGE_PAD * 2 ? large : small; + const headingFont = large.measureText(headingText) <= textWidth ? large : small; const readoutWidth = headingFont.measureText(headingText); const readoutHeight = headingFont.lineHeight; // One column centred on the display's true centre, so the rose sits where // the wearer is looking rather than 32px beside it (with a side strip). const cx = screenCenterInViewportX(); + // A line of that column: centred there, short of leaving the padded width. + const lineX = (lineWidth: number) => + Math.round(Math.max(padding.left, Math.min(width - padding.right - lineWidth, cx - lineWidth / 2))); // The rose is sized and placed first — it hangs off the bottom edge — and - // the readout then floats in whatever room is left above it. + // the readout then floats in whatever room is left above it. Its far + // edges land on the last row and column inside the padding. const textHeight = readoutHeight + 4 + statusLines.length * smallStep; const { cy, radius, ringTop } = layoutCompassRose({ width, height, cx, - topClearance: TOP_PAD + textHeight + STACK_GAP, - bottomPad: BOTTOM_PAD, - edgePad: EDGE_PAD, + topClearance: padding.top + textHeight + STACK_GAP, + bottomPad: padding.bottom + 1, + edgePad: { left: padding.left, right: padding.right + 1 }, maxRadius: MAX_ROSE_RADIUS, }); - let y = Math.max(TOP_PAD, Math.round((ringTop - TICK_HEIGHT - textHeight) / 2)); + let y = Math.max(padding.top, Math.round((ringTop - TICK_HEIGHT - textHeight) / 2)); const fade = heading === null ? 0.45 : 1; const clipY = y + textHeight + 6; const backgroundKey = [width, height, cx, cy, radius, clipY, fade].join(","); @@ -199,15 +198,17 @@ class CompassLayer implements Layer { } const image = this.background.image.clone(); drawCompassRose(image, cx, cy, radius, heading); - const readoutX = Math.round(Math.max(EDGE_PAD, Math.min(width - EDGE_PAD - readoutWidth, cx - readoutWidth / 2))); - image.drawText(headingFont, readoutX, y, headingText, heading === null ? 150 : 255); + image.drawText(headingFont, lineX(readoutWidth), y, headingText, heading === null ? 150 : 255); y += readoutHeight + 4; for (const line of statusLines) { - image.drawText(small, Math.round(cx - small.measureText(line) / 2), y, line, 125); + image.drawText(small, lineX(small.measureText(line)), y, line, 125); y += smallStep; } - const accuracyText = magneticAccuracyText(this.diagnostics); - image.drawText(small, width - ACCURACY_RIGHT_PAD - small.measureText(accuracyText), ACCURACY_TOP_PAD, accuracyText, 175); + if (glassesHaveCompass()) { + // The magnetometer calibration readout sits in the window's top-right corner. + const accuracyText = magneticAccuracyText(this.diagnostics); + image.drawText(small, width - padding.right - small.measureText(accuracyText), padding.top, accuracyText, 175); + } return image; } @@ -216,7 +217,7 @@ class CompassLayer implements Layer { // "Uncalibrated" prompt advertises, and re-calibrating is a normal thing to // want once the glasses have been taken off and put back on. handleInput(event: InputEvent, ctx: LayerContext): void { - if (event.type === "click") this.openCalibration(ctx); + if (event.type === "click" && glassesHaveCompass()) this.openCalibration(ctx); } } @@ -231,7 +232,7 @@ export function createCompassAppWindow(options: InProcessAppOptions): InProcessW icon: "compass", closeable: true, actions: options.actions, - menuItems: () => [ + menuItems: () => !glassesHaveCompass() ? [] : [ { label: "Calibrate", onSelect: (ctx) => { diff --git a/app/apps/compass/compass-rose.ts b/app/apps/compass/compass-rose.ts index f32be49f..0e266530 100644 --- a/app/apps/compass/compass-rose.ts +++ b/app/apps/compass/compass-rose.ts @@ -78,17 +78,19 @@ export function layoutCompassRose(options: { /** Lowest y already used above the rose (readout text, its gap). */ topClearance: number; bottomPad: number; - edgePad: number; + /** Clearance between the rose's widest point and the box's sides: one figure for both, or each side's. */ + edgePad: number | { left: number; right: number }; maxRadius: number; minRadius?: number; }): { cx: number; cy: number; radius: number; ringTop: number } { const { width, height, cx } = options; + const sidePad = typeof options.edgePad === "number" ? { left: options.edgePad, right: options.edgePad } : options.edgePad; const radius = Math.max( options.minRadius ?? 24, Math.min( options.maxRadius, Math.floor((height - options.bottomPad - options.topClearance - TICK_HEIGHT) / (RING_HEIGHT_PER_RADIUS + DISC_DEPTH)), - Math.floor((Math.min(cx, width - cx) - options.edgePad) / RING_HALF_WIDTH_PER_RADIUS), + Math.floor(Math.min(cx - sidePad.left, width - cx - sidePad.right) / RING_HALF_WIDTH_PER_RADIUS), ), ); // The wall hangs below the rim, so the near rim sits a wall's depth up diff --git a/app/apps/compass/index.ts b/app/apps/compass/index.ts index 4b8442a8..6741a735 100644 --- a/app/apps/compass/index.ts +++ b/app/apps/compass/index.ts @@ -1,3 +1,4 @@ +import { glassesHaveCompass } from "../../ui/dashboard-settings"; import { type AppDefinition } from "../app-definition"; import { COMPASS_SURFACE_ID, COMPASS_WINDOW_ID, createCompassAppWindow } from "./compass-app"; @@ -5,6 +6,7 @@ const compassApp: AppDefinition = { appId: "compass", title: "Compass", icon: "compass", + isSupported: glassesHaveCompass, launch: (ctx) => ctx.launchInProcessApp(COMPASS_WINDOW_ID, COMPASS_SURFACE_ID, createCompassAppWindow), }; diff --git a/app/apps/developer/accelerometer-demo.ts b/app/apps/developer/accelerometer-demo.ts index bdc88c0a..2e39c14d 100644 --- a/app/apps/developer/accelerometer-demo.ts +++ b/app/apps/developer/accelerometer-demo.ts @@ -13,6 +13,12 @@ import { shell } from "../../ui/shell/shell"; const IMU_REPORT_PACE = 200; // How often to reconcile the IMU on/off state with window visibility. const RECONCILE_INTERVAL_MS = 400; +/** The readout under the title sits this far in from the title's left edge. */ +const BODY_INDENT = 2; +/** An axis row, from the readout's left edge: its value, then its bar, which stops this short of the right edge's padding. */ +const VALUE_OFFSET_X = 22; +const BAR_OFFSET_X = 96; +const BAR_RIGHT_INSET = 4; /** * Accelerometer demo: turns the IMU stream on while this page is visible (the @@ -77,12 +83,17 @@ export class AccelerometerDemoLayer implements Layer { paint(ctx: LayerContext): GrayImage { const small = getDefaultSmallFont(); const medium = getDefaultMediumFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + // The title line sits at the padding suggested for the top, left and + // right edges; everything under it is placed from there. + const top = padding.top; + const right = width - padding.right; + const bodyX = padding.left + BODY_INDENT; - image.drawText(small, 20, 8, "Accelerometer", 220); + image.drawText(small, padding.left, top, "Accelerometer", 220); const status = this.enabled ? "IMU on" : "IMU off"; - image.drawText(small, width - 20 - small.measureText(status), 8, status, 150); + image.drawText(small, right - small.measureText(status), top, status, 150); if (this.reading) { const axes: Array<[string, number]> = [ @@ -90,19 +101,19 @@ export class AccelerometerDemoLayer implements Layer { ["Y", this.reading.y], ["Z", this.reading.z], ]; - const barX = 118; - const barW = width - barX - 24; + const barX = bodyX + BAR_OFFSET_X; + const barW = Math.max(0, right - BAR_RIGHT_INSET - barX); const scale = Math.max(this.peak, 1e-6); - let y = 40; + let y = top + 32; for (const [label, value] of axes) { - image.drawText(medium, 22, y, label, 210); - image.drawText(medium, 44, y, value.toFixed(3), 235); + image.drawText(medium, bodyX, y, label, 210); + image.drawText(medium, bodyX + VALUE_OFFSET_X, y, value.toFixed(3), 235); drawCenteredBar(image, barX, y + 2, barW, 12, clamp(value / scale, -1, 1)); y += 30; } image.drawText( small, - 22, + bodyX, y + 6, `source: ${imuSourceLabel(this.reading.source)} samples: ${this.sampleCount}`, 130, @@ -111,9 +122,9 @@ export class AccelerometerDemoLayer implements Layer { const message = this.enabled ? "Waiting for IMU data…" : "Paused (page not visible)."; - image.drawText(small, 22, 44, message, 190); - image.drawText(small, 22, 66, "The firmware may not report the", 120); - image.drawText(small, 22, 82, "accelerometer at all — experimental.", 120); + image.drawText(small, bodyX, top + 36, message, 190); + image.drawText(small, bodyX, top + 58, "The firmware may not report the", 120); + image.drawText(small, bodyX, top + 74, "accelerometer at all — experimental.", 120); } return image; diff --git a/app/apps/developer/bandwidth-benchmark.ts b/app/apps/developer/bandwidth-benchmark.ts index 73310aa6..3237ab6e 100644 --- a/app/apps/developer/bandwidth-benchmark.ts +++ b/app/apps/developer/bandwidth-benchmark.ts @@ -27,9 +27,12 @@ const POLL_INTERVAL_MS = 500; // timeout drain + slack). const POLL_DEADLINE_MS = DURATION_MS + 15_000; -const HEADER_HEIGHT = 30; -const LIST_X = 20; -const VALUE_X = 150; +/** The title band: the rows and the run's text start this far below the top edge's padding. */ +const HEADER_HEIGHT = 22; +/** Horizontal inset of a row's text from its highlight box; the title and the text under the rows line up with it. */ +const ROW_TEXT_INSET = 6; +/** A row's value column, from its label's left edge. */ +const VALUE_OFFSET_X = 130; type Phase = "config" | "arming" | "running" | "done"; type ConfigRow = "size" | "window" | "link" | "start"; @@ -126,36 +129,43 @@ export class BandwidthBenchmarkLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + // The rows' highlight boxes span the window inside the padding suggested + // for its side edges, and the title sits at the top edge's; the page's + // text shares the rows' text column. + const textX = padding.left + ROW_TEXT_INSET; + const bodyTop = padding.top + HEADER_HEIGHT; - image.drawText(font, 20, 8, "BLE bandwidth", 220); + image.drawText(font, textX, padding.top, "BLE bandwidth", 220); if (this.phase === "arming" || this.phase === "running") { - image.drawText(font, LIST_X, HEADER_HEIGHT + 8, "Running: streaming no-op packets for 15 s...", 200); + image.drawText(font, textX, bodyTop + 8, "Running: streaming no-op packets for 15 s...", 200); image.drawText( font, - LIST_X, - HEADER_HEIGHT + 30, + textX, + bodyTop + 30, `${MESSAGE_SIZES[this.sizeIndex]} B, window ${WINDOW_SIZES[this.windowIndex]}` + (LINK_REQUESTS_SUPPORTED ? `, ${LINK_MODES[this.linkModeIndex]}` : ""), 150, ); - image.drawText(font, LIST_X, HEADER_HEIGHT + 52, "Display updates pause until the run finishes.", 110); + image.drawText(font, textX, bodyTop + 52, "Display updates pause until the run finishes.", 110); return image; } + // The rows all fit their box, so it is a fixed block under the title + // rather than a scroller that would run to the window's bottom edge. const rowH = tightRowHeight(font) + 4; const rowCount = this.menu.items.length; this.menu.paint( image, - { x: LIST_X - 6, y: HEADER_HEIGHT - 1, width: width - 2 * LIST_X + 12, height: rowCount * rowH }, + { x: padding.left, y: bodyTop - 1, width: Math.max(0, width - padding.left - padding.right), height: rowCount * rowH }, ctx.stack.isFocused(), ); - let y = HEADER_HEIGHT + rowCount * rowH + 10; + let y = bodyTop + rowCount * rowH + 10; if (this.error) { - image.drawText(font, LIST_X, y, this.error, 180); + image.drawText(font, textX, y, this.error, 180); } else if (this.result) { const r = this.result; const seconds = r.elapsedMs / 1000; @@ -171,7 +181,9 @@ export class BandwidthBenchmarkLayer implements Layer { lines.push(`Link request: ${LINK_MODES[r.linkMode] ?? "Current"}${phy}`); } for (const line of lines) { - image.drawText(font, LIST_X, y, line, 190); + // A window too short for every line (the RayNeo iO's) shows the first ones. + if (y + font.lineHeight > height) break; + image.drawText(font, textX, y, line, 190); y += 20; } } @@ -187,10 +199,9 @@ export class BandwidthBenchmarkLayer implements Layer { : item === "link" ? ["Link request", LINK_MODES[this.linkModeIndex]!] : [this.phase === "done" ? "Run again" : "Start", ""]; const textY = centeredTextY(font, y, height); - // Text sits 6px in from the row box (LIST_X), values at VALUE_X. - image.drawText(font, x + 6, textY, label, selected ? 255 : 200); + image.drawText(font, x + ROW_TEXT_INSET, textY, label, selected ? 255 : 200); if (value) { - image.drawText(font, x + 6 + VALUE_X - LIST_X, textY, value, selected ? 235 : 160); + image.drawText(font, x + ROW_TEXT_INSET + VALUE_OFFSET_X, textY, value, selected ? 235 : 160); } } diff --git a/app/apps/developer/buzzer-demo.ts b/app/apps/developer/buzzer-demo.ts index 258ace7c..e10ce694 100644 --- a/app/apps/developer/buzzer-demo.ts +++ b/app/apps/developer/buzzer-demo.ts @@ -13,9 +13,12 @@ import { type SoundEffect, } from "../../ui/sound-effects"; -const HEADER_HEIGHT = 30; -const LIST_X = 20; -const FOOTER_HEIGHT = 0; +/** The title band: the list starts this far below the top edge's padding. */ +const HEADER_HEIGHT = 22; +/** Horizontal inset of a row's text from its highlight box; the title lines up with it. */ +const ROW_TEXT_INSET = 6; +/** The status text ends this far short of the rows' right edge. */ +const STATUS_INSET = 10; function sleep(ms: number): Promise { return new Promise((resolve) => setTimeout(resolve, ms)); @@ -39,19 +42,26 @@ export class BuzzerDemoLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - image.drawText(font, 20, 8, "Buzzer demo", 220); + image.drawText(font, padding.left + ROW_TEXT_INSET, padding.top, "Buzzer demo", 220); const status = this.playing ? `Playing: ${this.playing}` : `${GESTURE_CLICK} play`; - image.drawText(font, width - 24 - font.measureText(status), 8, status, 140); + image.drawText(font, width - padding.right - STATUS_INSET - font.measureText(status), padding.top, status, 140); - const listHeight = height - HEADER_HEIGHT - FOOTER_HEIGHT; - this.menu.paint( - image, - { x: LIST_X - 6, y: HEADER_HEIGHT - 1, width: width - 2 * LIST_X + 12, height: listHeight }, - ctx.stack.isFocused(), - ); + // The title line stays put, so the list starts right under it with no + // padding of its own there. It scrolls, so it runs to the window's + // bottom edge with the padding suggested for that edge inside it, after + // the last row. + const listTop = padding.top + HEADER_HEIGHT - 1; + if (height > listTop) { + this.menu.paint( + image, + { x: padding.left, y: listTop, width: Math.max(0, width - padding.left - padding.right), height: height - listTop, + padTop: 0, padBottom: padding.bottom }, + ctx.stack.isFocused(), + ); + } return image; } @@ -104,6 +114,6 @@ export class BuzzerDemoLayer implements Layer { function drawEffectRow({ image, item: effect, x, y, height, selected }: MenuDrawArgs): void { const font = getDefaultSmallFont(); const textY = centeredTextY(font, y, height); - image.drawText(font, x + 6, textY, effect.name, selected ? 255 : 200); - image.drawText(font, x + 6 + 110, textY, effect.desc, selected ? 180 : 120); + image.drawText(font, x + ROW_TEXT_INSET, textY, effect.name, selected ? 255 : 200); + image.drawText(font, x + ROW_TEXT_INSET + 110, textY, effect.desc, selected ? 180 : 120); } diff --git a/app/apps/developer/developer-app.ts b/app/apps/developer/developer-app.ts index a7faf8cd..276990b3 100644 --- a/app/apps/developer/developer-app.ts +++ b/app/apps/developer/developer-app.ts @@ -12,7 +12,6 @@ import { RingStatusLayer } from "./ring-status"; import { LoadAppFromQrLayer, LoadAppFromUrlLayer } from "./load-app"; import { unicodeTestMenu } from "./unicode-test"; import { type AppContext } from "../app-definition"; -import { appViewportSize } from "../../ui/shell/geometry"; import { createInProcessWindow, YieldAtRootLayer, @@ -23,17 +22,9 @@ import { export const DEVELOPER_WINDOW_ID = "developer"; export const DEVELOPER_SURFACE_ID = "window:developer"; -const MENU_LAYOUT = { - x: 8, - y: 8, - width: 272, - showBorder: false, - minHeight: 0, - maxHeight: appViewportSize("min").height - 16, - // These menus are pages, not popups: "Debug tests" replaces the root menu - // visually instead of letting the taller root show through beneath it. - opaque: true, -}; +// These menus are pages, not popups: "Debug tests" replaces the root menu +// visually instead of letting the taller root show through beneath it. +const MENU_LAYOUT = { page: true, width: 248 } as const; type OpenPage = (ctx: Parameters[0]) => void; diff --git a/app/apps/developer/input-events.ts b/app/apps/developer/input-events.ts index a779d5a9..e3da7375 100644 --- a/app/apps/developer/input-events.ts +++ b/app/apps/developer/input-events.ts @@ -6,6 +6,14 @@ import { addInputListener, InputEventLog, inputTimestamp } from "../../ui/input- import type { Layer, LayerContext } from "../../ui/layers"; import { drawListScrollbar, type MenuItem } from "../../ui/menu"; +/** Room the log's rows keep free on the right for the scrollbar, and the bar's own width. */ +const SCROLLBAR_GUTTER = 6; +const SCROLLBAR_WIDTH = 3; +/** A row's second (raw report) line is indented this far, and stops as far short of the row's end. */ +const DETAIL_INDENT = 12; +/** Gap between the log and the hint line under it. */ +const FOOTER_GAP = 6; + /** Gestures are samples here; back/clear/pause live in the tap-then-hold menu. */ export class InputEventsLayer implements Layer { readonly acceptsDirectional = true; @@ -48,30 +56,41 @@ export class InputEventsLayer implements Layer { } paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const font = getDefaultSmallFont(); - image.drawText(font, 12, 8, "Input events", 230); + // The title and column-heading lines stay put at the top and the hint + // line at the bottom, each inside the padding suggested for its edge. + // The log scrolls between them, so it needs no padding of its own. + const left = padding.left; + const top = padding.top; + const right = width - padding.right; + const footerY = height - padding.bottom - font.lineHeight; + const listTop = top + 42; + const listBottom = footerY - FOOTER_GAP; + // The rows stop short of the scrollbar, which keeps inside the padding. + const rowsRight = right - SCROLLBAR_GUTTER; + image.drawText(font, left, top, "Input events", 230); const status = `${this.log.paused ? "Paused" : "Live"} ${this.log.count} events`; - image.drawText(font, width - 12 - font.measureText(status), 8, status, 180); - image.drawText(font, 12, 28, this.phoneTime ? "Phone receive time | gap ms | source | event" : "Time (R=ring tick) | gap | source | event", 140); + image.drawText(font, right - font.measureText(status), top, status, 180); + image.drawText(font, left, top + 20, this.phoneTime ? "Phone receive time | gap ms | source | event" : "Time (R=ring tick) | gap | source | event", 140); const lineHeight = Math.max(18, font.lineHeight + 2); const rowHeight = lineHeight * 2 + 4; - this.visibleRows = Math.max(1, Math.floor((height - 76) / rowHeight)); + this.visibleRows = Math.max(1, Math.floor((listBottom - listTop) / rowHeight)); this.scrollRow = Math.min(this.scrollRow, Math.max(0, this.log.entries.length - this.visibleRows)); - const timeX = 12; + const timeX = left; const gapX = timeX + font.measureText("00:00:00.000") + 12; const sourceX = gapX + font.measureText("+99999") + 12; const eventX = sourceX + font.measureText("right-arm") + 12; if (!this.log.entries.length) { - image.drawText(font, 12, 62, "Touch, tap, double-tap, hold, or swipe the ring.", 210); - image.drawText(font, 12, 82, "Press arrives before an interpreted gesture.", 150); + image.drawText(font, left, listTop + 12, "Touch, tap, double-tap, hold, or swipe the ring.", 210); + image.drawText(font, left, listTop + 32, "Press arrives before an interpreted gesture.", 150); } for (const [index, entry] of this.log.entries.slice(this.scrollRow, this.scrollRow + this.visibleRows).entries()) { const { event } = entry; const ringTime = !this.phoneTime && event.ringInput; const gapMs = ringTime ? entry.ringGapTicks : entry.gapMs; - const y = 50 + index * rowHeight; + const y = listTop + index * rowHeight; const gap = gapMs === null ? "-" : `${gapMs >= 0 ? "+" : ""}${gapMs}`; const source = "source" in event ? event.source ?? "-" : "-"; const label = (entry.filtered ? "*" : "") + (event.type === "unknown" @@ -80,18 +99,20 @@ export class InputEventsLayer implements Layer { image.drawText(font, timeX, y, ringTime ? `R${ringTime.tick}` : inputTimestamp(event.timestampMs), 170); image.drawText(font, gapX, y, truncateText(font, gap, sourceX - gapX - 4), 160); image.drawText(font, sourceX, y, source, 180); - image.drawText(font, eventX, y, truncateText(font, label, width - eventX - 12), event.type === "ring-press" ? 255 : 200); + image.drawText(font, eventX, y, truncateText(font, label, rowsRight - eventX), event.type === "ring-press" ? 255 : 200); if (event.ringInput) { const { type, aux, speed } = event.ringInput; // These are the original report bytes, not physical distance/speed units. const details = `Raw ring: type ${type} AUX ${aux} speed ${speed}`; - image.drawText(font, timeX + 12, y + lineHeight, - truncateText(font, details, width - timeX - 36), 170); + image.drawText(font, timeX + DETAIL_INDENT, y + lineHeight, + truncateText(font, details, rowsRight - timeX - 2 * DETAIL_INDENT), 170); } } - if (this.log.paused) drawListScrollbar(image, width - 5, 50, height - 78, - this.scrollRow, this.visibleRows, this.log.entries.length); - image.drawText(font, 12, height - 20, + if (this.log.paused && listBottom > listTop) { + drawListScrollbar(image, right - SCROLLBAR_WIDTH, listTop, listBottom - listTop, + this.scrollRow, this.visibleRows, this.log.entries.length); + } + image.drawText(font, left, footerY, this.log.paused ? "Scroll: history Tap-hold: controls" : "Unfiltered (*=dedup) Tap-hold: controls", 140); return image; } diff --git a/app/apps/developer/light-sensor-demo.ts b/app/apps/developer/light-sensor-demo.ts index 8f713f8d..9182b20c 100644 --- a/app/apps/developer/light-sensor-demo.ts +++ b/app/apps/developer/light-sensor-demo.ts @@ -22,6 +22,10 @@ const RECONCILE_INTERVAL_MS = 400; // Length of the on-screen trace. const HISTORY_MS = 30_000; const MAX_SAMPLES = Math.ceil(HISTORY_MS / 100) + 2; +/** The readout under the title sits this far in from the title's left edge. */ +const BODY_INDENT = 2; +/** Gap between the trace's box and the footer line under it. */ +const CHART_FOOTER_GAP = 18; type Sample = { atMs: number; value: number; peak: number }; @@ -102,39 +106,47 @@ export class LightSensorDemoLayer implements Layer { paint(ctx: LayerContext): GrayImage { const small = getDefaultSmallFont(); const medium = getDefaultMediumFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + // The title line, the trace's box and the footer line sit at the padding + // suggested for the edges they reach; the rest is placed from them. + const left = padding.left; + const top = padding.top; + const right = width - padding.right; + const bodyX = left + BODY_INDENT; + const footerY = height - padding.bottom - small.lineHeight; - image.drawText(small, 20, 8, "Light sensor", 220); + image.drawText(small, left, top, "Light sensor", 220); const status = this.enabled ? "polling" : "paused"; - image.drawText(small, width - 20 - small.measureText(status), 8, status, 150); + image.drawText(small, right - small.measureText(status), top, status, 150); const report = this.report; if (!report) { const message = this.enabled ? "Waiting for a report…" : "Paused (page not visible)."; - image.drawText(small, 22, 44, message, 190); - image.drawText(small, 22, 66, "Needs Faceclaw's custom firmware.", 120); - image.drawText(small, 20, height - 16, `${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(small, bodyX, top + 36, message, 190); + image.drawText(small, bodyX, top + 58, "Needs Faceclaw's custom firmware.", 120); + image.drawText(small, left, footerY, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } // Headline reading. The stock driver's unit is roughly a tenth of a lux. const lux = (report.alsValue / 10).toFixed(1); - image.drawText(medium, 22, 30, `${lux} lux`, 245); + image.drawText(medium, bodyX, top + 22, `${lux} lux`, 245); const peakText = `peak ${(report.peak / 10).toFixed(1)}`; - image.drawText(small, 22 + medium.measureText(`${lux} lux`) + 14, 36, peakText, 170); + image.drawText(small, bodyX + medium.measureText(`${lux} lux`) + 14, top + 28, peakText, 170); const flags: string[] = []; if (!report.opened) flags.push("sensor closed"); if (report.passive) flags.push("passive"); if (report.autoBrightness) flags.push("auto on"); if (report.passive && !report.readOk) flags.push("read failed"); - image.drawText(small, 22, 58, flags.join(" ") || "stock polling", 150); + image.drawText(small, bodyX, top + 50, flags.join(" ") || "stock polling", 150); + const statsY = top + 68; image.drawText( small, - 22, - 76, + bodyX, + statsY, `brightness ${report.brightness} stock target ${report.stockTarget} gear ${report.gear} scale ${(report.scaleQ10 / 1024).toFixed(2)}`, 170, ); @@ -142,16 +154,17 @@ export class LightSensorDemoLayer implements Layer { // 30 s trace of the reading (bright) and the driver's 5-sample peak (dim). // The axis label sits between the stats line and the chart, so the chart // starts a full text line lower than the stats. - const chartTop = 76 + small.lineHeight * 2 + 4; - const bounds = { x: 20, y: chartTop, width: width - 40, height: height - chartTop - 34 }; + const chartTop = statsY + small.lineHeight * 2 + 4; + const bounds = { x: left, y: chartTop, width: right - left, height: footerY - CHART_FOOTER_GAP - chartTop }; const maxValue = Math.max(...this.samples.map((sample) => Math.max(sample.value, sample.peak)), 10); const scale = roundUpScale(maxValue * 1.08); image.drawText(small, bounds.x, bounds.y - small.lineHeight - 2, `0–${(scale / 10).toFixed(0)} lux, last 30 s`, 120); - drawTrace(image, this.samples, Date.now(), bounds, scale); + // A window too short for the trace (a large font on the RayNeo iO) goes without. + if (bounds.width > 1 && bounds.height > 1) drawTrace(image, this.samples, Date.now(), bounds, scale); - image.drawText(small, 20, height - 16, `reports: ${this.reportCount}`, 110); + image.drawText(small, left, footerY, `reports: ${this.reportCount}`, 110); const back = `${GESTURE_DOUBLE_CLICK} back`; - image.drawText(small, width - 20 - small.measureText(back), height - 16, back, 110); + image.drawText(small, right - small.measureText(back), footerY, back, 110); return image; } diff --git a/app/apps/developer/load-app.ts b/app/apps/developer/load-app.ts index ba6c9555..15532e3f 100644 --- a/app/apps/developer/load-app.ts +++ b/app/apps/developer/load-app.ts @@ -9,8 +9,6 @@ import { lineStep } from "../../ui/metrics"; import { developerAppUrlSetting } from "../../ui/dashboard-settings"; import { cancelQrScan, isQrScannerAvailable, scanQrCode } from "../../native/qr-scan"; -const MARGIN = 20; - /** * "Load app from URL": the glasses side of the phone text editor. Entering the * page opens the editor on developerAppUrlSetting, the typed URL echoes here @@ -44,27 +42,30 @@ export class LoadAppFromUrlLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + // The page's text fills the window inside the padding suggested for its + // edges: the title at the top, the hint line at the bottom. + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const step = lineStep(font); - const textWidth = width - 2 * MARGIN; + const left = padding.left; + const textWidth = Math.max(0, width - padding.left - padding.right); - image.drawText(font, MARGIN, 8, "Load app from URL", 220); - let y = 8 + step + 6; - image.drawText(font, MARGIN, y, "Type the app's URL in the phone app", 150); + image.drawText(font, left, padding.top, "Load app from URL", 220); + let y = padding.top + step + 6; + image.drawText(font, left, y, "Type the app's URL in the phone app", 150); y += step; - image.drawText(font, MARGIN, y, "(or use voice input from the menu).", 150); + image.drawText(font, left, y, "(or use voice input from the menu).", 150); y += step + 8; const url = developerAppUrlSetting.get(); for (const line of wrapText(font, url || "(empty)", textWidth).slice(0, 3)) { - image.drawText(font, MARGIN, y, line, url ? 230 : 110); + image.drawText(font, left, y, line, url ? 230 : 110); y += step; } if (this.error) { y += 4; for (const line of wrapText(font, this.error, textWidth).slice(0, 2)) { - image.drawText(font, MARGIN, y, line, 150); + image.drawText(font, left, y, line, 150); y += step; } } @@ -72,7 +73,7 @@ export class LoadAppFromUrlLayer implements Layer { const footer = this.launching ? "Loading..." : `${GESTURE_CLICK} load ${GESTURE_DOUBLE_CLICK} cancel`; - image.drawText(font, MARGIN, height - font.lineHeight - 12, footer, 110); + image.drawText(font, left, height - padding.bottom - font.lineHeight, footer, 110); return image; } @@ -145,19 +146,22 @@ export class LoadAppFromQrLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + // Laid out like the URL page: text inside the padding suggested for the + // window's edges, the hint line at the bottom. + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const step = lineStep(font); + const left = padding.left; - image.drawText(font, MARGIN, 8, "Load app from QR code", 220); - let y = 8 + step + 6; - for (const line of wrapText(font, this.status, width - 2 * MARGIN).slice(0, 5)) { - image.drawText(font, MARGIN, y, line, 170); + image.drawText(font, left, padding.top, "Load app from QR code", 220); + let y = padding.top + step + 6; + for (const line of wrapText(font, this.status, Math.max(0, width - padding.left - padding.right)).slice(0, 5)) { + image.drawText(font, left, y, line, 170); y += step; } const footer = this.busy ? `${GESTURE_DOUBLE_CLICK} back` : `${GESTURE_CLICK} scan again ${GESTURE_DOUBLE_CLICK} back`; - image.drawText(font, MARGIN, height - font.lineHeight - 12, footer, 110); + image.drawText(font, left, height - padding.bottom - font.lineHeight, footer, 110); return image; } diff --git a/app/apps/developer/microphones-monitor.ts b/app/apps/developer/microphones-monitor.ts index 513bc8db..5c29d11d 100644 --- a/app/apps/developer/microphones-monitor.ts +++ b/app/apps/developer/microphones-monitor.ts @@ -37,6 +37,8 @@ const STOCK_COUNTER_OFFSET = 204; // Counter gaps at or beyond this are late/duplicate copies, not losses. const STOCK_LATE_GAP = 128; const LEVEL_FLOOR_DB = -90; +/** Gap between the two temples' columns. */ +const COLUMN_GAP = 16; // wallMs (JS receipt time) windows the rates; arrivalMs (the session core's // elapsed-realtime stamp, taken on the BLE thread) measures gaps without the @@ -229,39 +231,45 @@ export class MicrophonesMonitorLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); const line = font.lineHeight; - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const nowMs = Date.now(); + // The title line, the two columns and the footer line span the window + // inside the padding suggested for its edges. + const left = padding.left; + const titleY = padding.top; + const right = width - padding.right; + const footerY = height - padding.bottom - line; - image.drawText(font, 16, 5, "Microphones (passive)", 230); + image.drawText(font, left, titleY, "Microphones (passive)", 230); const capture = isFaceclawAudioCaptureActive() ? "Faceclaw capture: on" : "Faceclaw capture: off"; - image.drawText(font, width - 16 - font.measureText(capture), 5, capture, 170); + image.drawText(font, right - font.measureText(capture), titleY, capture, 170); if (!this.communicator) { - image.drawText(font, 16, 5 + line * 2, "Glasses not connected.", 190); - image.drawText(font, 16, height - 16, `${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(font, left, titleY + line * 2, "Glasses not connected.", 190); + image.drawText(font, left, footerY, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } - const gutter = 16; - const columnWidth = Math.floor((width - gutter * 3) / 2); + const columnWidth = Math.max(0, Math.floor((right - left - COLUMN_GAP) / 2)); + const rightColumnX = left + columnWidth + COLUMN_GAP; const stripHeight = 22; - const top = 5 + line + 6; - const bottom = height - 16 - stripHeight - 8; - this.paintArm(image, "L", "Left", gutter, top, columnWidth, bottom, nowMs); - this.paintArm(image, "R", "Right", gutter * 2 + columnWidth, top, columnWidth, bottom, nowMs); + const top = titleY + line + 6; + const bottom = footerY - stripHeight - 8; + this.paintArm(image, "L", "Left", left, top, columnWidth, bottom, nowMs); + this.paintArm(image, "R", "Right", rightColumnX, top, columnWidth, bottom, nowMs); - const stripY = height - 16 - stripHeight - 4; + const stripY = footerY - stripHeight - 4; const stripMax = Math.max(1, ...this.stats.L.buckets, ...this.stats.R.buckets); - drawStrip(image, this.stats.L.buckets, gutter, stripY, columnWidth, stripHeight, stripMax); - drawStrip(image, this.stats.R.buckets, gutter * 2 + columnWidth, stripY, columnWidth, stripHeight, stripMax); + drawStrip(image, this.stats.L.buckets, left, stripY, columnWidth, stripHeight, stripMax); + drawStrip(image, this.stats.R.buckets, rightColumnX, stripY, columnWidth, stripHeight, stripMax); const footer = this.unknownArmPackets > 0 ? `last ${HISTORY_MS / 1000} s unattributed packets ${this.unknownArmPackets}` : `packets per ${BUCKET_MS} ms, last ${HISTORY_MS / 1000} s`; - image.drawText(font, gutter, height - 16, footer, 110); + image.drawText(font, left, footerY, footer, 110); const back = `${GESTURE_DOUBLE_CLICK} back tap reset`; - image.drawText(font, width - gutter - font.measureText(back), height - 16, back, 110); + image.drawText(font, right - font.measureText(back), footerY, back, 110); return image; } diff --git a/app/apps/developer/resource-usage.ts b/app/apps/developer/resource-usage.ts index 70f0c8f8..525880ad 100644 --- a/app/apps/developer/resource-usage.ts +++ b/app/apps/developer/resource-usage.ts @@ -16,6 +16,14 @@ const HISTORY_MS = 60_000; const MAX_SAMPLES = Math.ceil(HISTORY_MS / SAMPLE_INTERVAL_MS) + 2; /** Line brightness per memory series, headline first. */ const MEMORY_SHADES = [240, 155, 80]; +/** The charts' heights where the window has room for them. */ +const MEMORY_CHART_HEIGHT = 70; +const CPU_CHART_HEIGHT = 60; +/** Between the charts: a gap, then the CPU chart's label line. */ +const CHART_GAP = 10; +const CHART_LABEL_HEIGHT = 16; +/** Least gap between the CPU chart and the footer line. */ +const CHART_FOOTER_GAP = 4; type ChartSample = ResourceSample & { cpuPercent: number }; @@ -56,20 +64,26 @@ export class ResourceUsageLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const latest = this.samples[this.samples.length - 1]; + // The title line, the charts and the footer line span the window inside + // the padding suggested for its edges; the rest is placed from the top. + const left = padding.left; + const top = padding.top; + const right = width - padding.right; + const footerY = height - padding.bottom - font.lineHeight; - image.drawText(font, 16, 5, "Resource usage — last minute", 230); + image.drawText(font, left, top, "Resource usage — last minute", 230); if (!latest) { - image.drawText(font, 16, 30, this.sampleError || "Waiting for first sample…", 170); - image.drawText(font, 16, height - 16, `${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(font, left, top + 25, this.sampleError || "Waiting for first sample…", 170); + image.drawText(font, left, footerY, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } const cpuText = `CPU ${formatPercent(latest.cpuPercent)} ${latest.threads} threads`; - image.drawText(font, width - 16 - font.measureText(cpuText), 5, cpuText, 200); - image.drawText(font, 16, 21, this.sampleError || latest.status, this.sampleError ? 170 : 140); + image.drawText(font, right - font.measureText(cpuText), top, cpuText, 200); + image.drawText(font, left, top + 16, this.sampleError || latest.status, this.sampleError ? 170 : 140); const memorySeries = MEMORY_SERIES.map((label, index) => ({ label, @@ -78,34 +92,44 @@ export class ResourceUsageLayer implements Layer { })); const memoryPeak = Math.max(...this.samples.flatMap((sample) => sample.memoryMb), 64); const memoryScale = roundUp(memoryPeak * 1.08, 64); + const legendY = top + 43; const legendLeft = drawLegend( image, font, - width, - 48, + right, + legendY, memorySeries.map((series) => [`${series.label} ${formatMb(series.value(latest))}`, series.shade] as const), ); const scaleLabel = `Memory 0–${formatMb(memoryScale)}`; const shortScaleLabel = `0–${formatMb(memoryScale)}`; image.drawText( font, - 16, - 48, - 16 + font.measureText(scaleLabel) + 8 <= legendLeft ? scaleLabel : shortScaleLabel, + left, + legendY, + left + font.measureText(scaleLabel) + 8 <= legendLeft ? scaleLabel : shortScaleLabel, 140, ); - drawChart(image, this.samples, latest.atMs, { x: 16, y: 64, width: width - 32, height: 70 }, memoryScale, memorySeries); + // The charts shrink together where the window is too short for both + // above the footer line (the RayNeo iO's). + const chartsTop = legendY + CHART_LABEL_HEIGHT; + const room = footerY - CHART_FOOTER_GAP - chartsTop - CHART_GAP - CHART_LABEL_HEIGHT; + const fit = clamp(room / (MEMORY_CHART_HEIGHT + CPU_CHART_HEIGHT), 0, 1); + const memoryHeight = Math.floor(MEMORY_CHART_HEIGHT * fit); + const chartWidth = Math.max(0, right - left); + drawChart(image, this.samples, latest.atMs, { x: left, y: chartsTop, width: chartWidth, height: memoryHeight }, memoryScale, memorySeries); const cpuPeak = Math.max(...this.samples.map((sample) => sample.cpuPercent), 100); const cpuScale = roundUp(cpuPeak * 1.08, 25); - image.drawText(font, 16, 144, `CPU 0–${Math.round(cpuScale)}% (one core)`, 140); - drawChart(image, this.samples, latest.atMs, { x: 16, y: 160, width: width - 32, height: 60 }, cpuScale, [ - { value: (sample) => sample.cpuPercent, shade: 220 }, - ]); + const cpuLabelY = chartsTop + memoryHeight + CHART_GAP; + image.drawText(font, left, cpuLabelY, `CPU 0–${Math.round(cpuScale)}% (one core)`, 140); + drawChart(image, this.samples, latest.atMs, + { x: left, y: cpuLabelY + CHART_LABEL_HEIGHT, width: chartWidth, height: Math.floor(CPU_CHART_HEIGHT * fit) }, cpuScale, [ + { value: (sample) => sample.cpuPercent, shade: 220 }, + ]); - image.drawText(font, 16, height - 16, `-60s`, 80); + image.drawText(font, left, footerY, `-60s`, 80); const nowLabel = `now`; - image.drawText(font, width - 16 - font.measureText(nowLabel), height - 16, nowLabel, 110); + image.drawText(font, right - font.measureText(nowLabel), footerY, nowLabel, 110); return image; } @@ -148,6 +172,7 @@ function drawChart( scale: number, series: readonly Series[], ): void { + if (bounds.width < 2 || bounds.height < 2) return; image.drawRect(bounds.x, bounds.y, bounds.width, bounds.height, 45); const midY = bounds.y + Math.round((bounds.height - 1) / 2); image.drawLine(bounds.x + 1, midY, bounds.x + bounds.width - 2, midY, 24); @@ -167,16 +192,16 @@ function drawChart( } } -/** Right-aligned legend of line swatches and labels; returns its left edge. */ +/** Legend of line swatches and labels, right-aligned to end at `right`; returns its left edge. */ function drawLegend( image: GrayImage, font: ReturnType, - width: number, + right: number, y: number, entries: ReadonlyArray, ): number { const totalWidth = entries.reduce((sum, [label]) => sum + font.measureText(label) + 14, 0); - const left = width - 16 - totalWidth; + const left = right - totalWidth; let x = left; for (const [label, shade] of entries) { image.drawLine(x, y + 6, x + 8, y + 6, shade); diff --git a/app/apps/developer/ring-status.ts b/app/apps/developer/ring-status.ts index 876aa506..de86f81a 100644 --- a/app/apps/developer/ring-status.ts +++ b/app/apps/developer/ring-status.ts @@ -4,7 +4,7 @@ import { type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; import { shell } from "../../ui/shell/shell"; import { MenuLayer, type MenuItem } from "../../ui/menu"; -import { ringConnectionModeSetting } from "../../ui/dashboard-settings"; +import { effectiveRingConnectionMode, ringConnectionModeSetting } from "../../ui/dashboard-settings"; import { loadDeviceAddresses } from "../../g2/device-addresses"; import { getRingSessionStatus, @@ -18,8 +18,10 @@ import { } from "../../native/ring-status"; const POLL_INTERVAL_MS = 1_000; -const LEFT_X = 16; -const VALUE_X = 130; +/** The title sits this far in from the left edge of the rows and buttons under it. */ +const TITLE_INDENT = 2; +/** A row's value column, from its label's left edge. */ +const VALUE_OFFSET_X = 114; const BUTTON_GAP = 8; type Row = { label: string; value: string; dim?: boolean }; @@ -102,26 +104,31 @@ export class RingStatusLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const lineStep = font.lineHeight + 2; const buttonHeight = font.lineHeight + 8; - const buttonTop = height - buttonHeight - 6; + // The rows and the button strip span the window inside the padding + // suggested for its side edges; the title sits at the top edge's and the + // buttons' outlines at the bottom edge's. + const left = padding.left; + const buttonTop = height - padding.bottom - buttonHeight; - image.drawText(font, 18, 10, "Ring status", 230); - let y = 10 + lineStep + 4; + image.drawText(font, left + TITLE_INDENT, padding.top, "Ring status", 230); + let y = padding.top + lineStep + 4; const rows = this.rows(); if (this.notice) rows.push({ label: "", value: this.notice }); for (const row of rows) { if (y + font.lineHeight > buttonTop - 4) break; - image.drawText(font, LEFT_X, y, row.label, row.dim ? 100 : 150); - image.drawText(font, VALUE_X, y, row.value, row.dim ? 120 : 220); + image.drawText(font, left, y, row.label, row.dim ? 100 : 150); + image.drawText(font, left + VALUE_OFFSET_X, y, row.value, row.dim ? 120 : 220); y += lineStep; } - const buttonWidth = Math.floor((width - 2 * LEFT_X - BUTTON_GAP * (BUTTONS.length - 1)) / BUTTONS.length); + const buttonWidth = Math.max(0, + Math.floor((width - padding.left - padding.right - BUTTON_GAP * (BUTTONS.length - 1)) / BUTTONS.length)); BUTTONS.forEach((button, index) => { - const x = LEFT_X + index * (buttonWidth + BUTTON_GAP); + const x = left + index * (buttonWidth + BUTTON_GAP); const selected = index === this.selected; if (selected) image.fillRoundedRect(x, buttonTop, buttonWidth, buttonHeight, 40, 4); image.drawRoundedRect(x, buttonTop, buttonWidth, buttonHeight, selected ? 200 : 70, 4); @@ -146,7 +153,7 @@ export class RingStatusLayer implements Layer { } if (!s.directEnabled) { - const pending = ringConnectionModeSetting.get() !== "glasses"; + const pending = effectiveRingConnectionMode() !== "glasses"; rows.push({ label: "Direct link", value: pending ? "on after glasses reconnect" : "off (only via glasses)", dim: true }); } else { const state = s.directNotificationsReady ? "subscribed" diff --git a/app/apps/developer/unicode-test.ts b/app/apps/developer/unicode-test.ts index 200c86d7..1330bfc1 100644 --- a/app/apps/developer/unicode-test.ts +++ b/app/apps/developer/unicode-test.ts @@ -3,7 +3,7 @@ import { fontSelectionLabel, getDefaultSmallFont, getUiFontSelection } from "../ import { GrayImage, type UiFont } from "../../graphics/image"; import { type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; -import { MenuLayer, type MenuLayout } from "../../ui/menu"; +import { MenuLayer, type MenuPageLayout } from "../../ui/menu"; /** * Unicode test: sample texts chosen to exercise text-rendering features that @@ -175,9 +175,6 @@ export const UNICODE_SAMPLES: readonly UnicodeSample[] = [ }, ]; -const MARGIN_X = 18; -const TITLE_Y = 8; -const FOOTER_MARGIN = 20; const BODY_GAP = 6; /** @@ -196,32 +193,36 @@ export class UnicodeSampleLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + // The title and note stay put at the top and the footer line at the + // bottom, inside the padding suggested for the window's edges; the text + // pages between them, so it needs no padding of its own. + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - const textWidth = width - 2 * MARGIN_X; + const left = padding.left; + const textWidth = Math.max(0, width - padding.left - padding.right); - image.drawText(font, MARGIN_X, TITLE_Y, truncateText(font, this.sample.label, textWidth), 220); - const noteY = TITLE_Y + font.lineHeight; + image.drawText(font, left, padding.top, truncateText(font, this.sample.label, textWidth), 220); + const noteY = padding.top + font.lineHeight; const noteLines = wrapText(font, this.sample.exercises, textWidth); for (let i = 0; i < noteLines.length; i++) { - image.drawText(font, MARGIN_X, noteY + i * font.lineHeight, noteLines[i]!, 120); + image.drawText(font, left, noteY + i * font.lineHeight, noteLines[i]!, 120); } const bodyY = noteY + noteLines.length * font.lineHeight + BODY_GAP; - const footerY = height - FOOTER_MARGIN; + const footerY = height - padding.bottom - font.lineHeight; this.bodyLineCount = Math.max(1, Math.floor((footerY - bodyY) / font.lineHeight)); const lines = this.getLines(font, textWidth); this.clampScroll(lines.length); const visible = lines.slice(this.firstLine, this.firstLine + this.bodyLineCount); for (let i = 0; i < visible.length; i++) { - image.drawText(font, MARGIN_X, bodyY + i * font.lineHeight, visible[i]!, 235); + image.drawText(font, left, bodyY + i * font.lineHeight, visible[i]!, 235); } const page = Math.floor(this.firstLine / this.pageStep()) + 1; - image.drawText(font, MARGIN_X, footerY, `Page ${page}/${this.pageCount(lines.length)}`, 110); + image.drawText(font, left, footerY, `Page ${page}/${this.pageCount(lines.length)}`, 110); const fontLabel = fontSelectionLabel(getUiFontSelection()); - image.drawText(font, width - MARGIN_X - font.measureText(fontLabel), footerY, fontLabel, 110); + image.drawText(font, width - padding.right - font.measureText(fontLabel), footerY, fontLabel, 110); return image; } @@ -271,7 +272,7 @@ export class UnicodeSampleLayer implements Layer { } /** The language list; selecting a row opens its sample. */ -export function unicodeTestMenu(layout: MenuLayout): MenuLayer { +export function unicodeTestMenu(layout: MenuPageLayout): MenuLayer { return new MenuLayer( "Unicode test", UNICODE_SAMPLES.map((sample) => ({ diff --git a/app/apps/evenhub/compositor.ts b/app/apps/evenhub/compositor.ts index 8518facf..7886b5b2 100644 --- a/app/apps/evenhub/compositor.ts +++ b/app/apps/evenhub/compositor.ts @@ -7,16 +7,23 @@ * match what apps expect. Extended layouts may pick other fonts per container * (fonts.ts), which wrap with Faceclaw's own text wrapping. * + * Containers stack in stock's order (paintOrder): without zOrderIndex, lists, + * then texts, then images, so an image container covers text beneath it. Text + * containers are transparent windows that clip their text and scroll it. + * * Known deviations from stock, acceptable for now: * - List rendering is a plain vertical list. A non-zero itemWidth sets the * selection outline's width and truncates long items to fit, as on stock; * whether stock also lays narrow items out side by side is unknown. * - Lists scroll with our menus' animation and bounce (see list-menu.ts). + * - Text scrolls in jumps; stock eases each 28px step over 200ms and + * rubber-bands at the ends. */ import { GrayImage } from "../../graphics/image"; import { containerFace } from "./fonts"; import { - type EvenHubContainer, + borderGrey, + paintOrder, type EvenHubImageContainer, type EvenHubListContainer, type EvenHubPage, @@ -30,35 +37,122 @@ export const EVENHUB_SCREEN_HEIGHT = 288; const TEXT_WHITE = 255; /** - * SDK 0.0.14 textColor levels 0..4 as grey values. Level 4 is the default and - * the only one apps got before 0.0.14, so it must stay exactly TEXT_WHITE. - * Level 0 is the firmware's "fully dim" step, which over the black page - * background means the text is effectively not shown. + * SDK 0.0.14 textColor levels 0..4 as the greys stock draws them (measured + * in the firmware emulator): level 0 is dim, not off. A missing or + * out-of-range level draws white, the only colour before 0.0.14. */ -const TEXT_BRIGHTNESS_GREYS = [0, 64, 128, 191, 255]; +const TEXT_BRIGHTNESS_GREYS = [51, 102, 153, 204, 255]; function textGrey(level: number | undefined): number { return level === undefined ? TEXT_WHITE : (TEXT_BRIGHTNESS_GREYS[level] ?? TEXT_WHITE); } -/** Chars the font lacks are skipped silently on stock (no tofu); EvenHubFont - * skips unknown glyphs, matching that. */ -function paintTextContainer(image: GrayImage, container: EvenHubTextContainer): void { - // Only the text dims: textColor is a text-brightness level, and stock draws - // the container's border at full brightness regardless. - paintBorder(image, container); +/** + * The scrollbar stock draws on any text container whose text overflows + * (LV_SCROLLBAR_MODE_AUTO), whether or not it captures input: 4px wide, 10px + * in from the right edge, in a track 6px in from top and bottom, with its + * corner pixels cut. Measured in the firmware emulator. + */ +const SCROLLBAR_GREY = 187; +const SCROLLBAR_WIDTH = 4; +const SCROLLBAR_RIGHT_INSET = 10; +const SCROLLBAR_TRACK_INSET = 6; + +type Rect = { x: number; y: number; width: number; height: number }; + +/** A text container's wrapped lines and the geometry its scrolling works in. */ +export type TextLayout = { + lines: string[]; + lineHeight: number; + /** Left edge and unscrolled top of the text. */ + contentX: number; + contentY: number; + /** Height of the window the text scrolls in (inside border and padding). */ + viewportHeight: number; + /** Largest scrollY: how far the text overflows that window. */ + maxScroll: number; +}; + +/** + * Stock lays text out at x + border + padding and wraps it at width - 2 * + * padding: the label is sized ignoring the border, so a line can run into + * the right border, where it is clipped. + */ +export function layoutText(container: EvenHubTextContainer): TextLayout { const inset = container.borderWidth + container.paddingLength; const face = containerFace(container.font); - const lines = face.wrap(container.content, Math.max(1, container.width - 2 * inset)); - for (let i = 0; i < lines.length; i++) { - face.drawText(image, container.x + inset, container.y + inset + i * face.lineHeight, lines[i]!, textGrey(container.textColor)); + const lines = face.wrap(container.content, Math.max(1, container.width - 2 * container.paddingLength)); + const viewportHeight = Math.max(0, container.height - 2 * inset); + return { + lines, + lineHeight: face.lineHeight, + contentX: container.x + inset, + contentY: container.y + inset, + viewportHeight, + maxScroll: Math.max(0, lines.length * face.lineHeight - viewportHeight), + }; +} + +/** + * Text is clipped at the border's inner edge (at the container's edge when it + * has no border). Lines wholly inside stay deferred firmware-text draws; a + * line the edge cuts is rasterized and blitted clipped. Chars the font lacks + * are skipped silently, as on stock (no tofu). + */ +function paintTextContainer(image: GrayImage, container: EvenHubTextContainer): void { + // Only the text dims: textColor is a text-brightness level; the border has its own color. + paintBorder(image, container); + const layout = layoutText(container); + const face = containerFace(container.font); + const grey = textGrey(container.textColor); + const border = container.borderWidth; + const clip: Rect = { + x: container.x + border, + y: container.y + border, + width: Math.max(0, container.width - 2 * border), + height: Math.max(0, container.height - 2 * border), + }; + for (let i = 0; i < layout.lines.length; i++) { + const y = layout.contentY + i * layout.lineHeight - container.scrollY; + const bottom = y + layout.lineHeight; + if (bottom <= clip.y || y >= clip.y + clip.height) continue; + const line = layout.lines[i]!; + if (y >= clip.y && bottom <= clip.y + clip.height && layout.contentX + face.measureLine(line) <= clip.x + clip.width) { + face.drawText(image, layout.contentX, y, line, grey); + continue; + } + const strip = new GrayImage(container.width, layout.lineHeight, 0); + face.drawText(strip, layout.contentX - container.x, 0, line, grey); + const visibleTop = Math.max(y, clip.y); + image.bitBlt(strip.withDrawsBaked(), clip.x, visibleTop, { + sx: clip.x - container.x, + sy: visibleTop - y, + width: clip.width, + height: Math.min(bottom, clip.y + clip.height) - visibleTop, + transparentZero: true, + }); + } + if (layout.maxScroll > 0) paintScrollbar(image, container, layout); +} + +function paintScrollbar(image: GrayImage, container: EvenHubTextContainer, layout: TextLayout): void { + const height = container.height; + const track = height - 2 * SCROLLBAR_TRACK_INSET; + const length = Math.floor((track * height) / (height + layout.maxScroll)); + if (track <= 0 || length <= 0) return; + const top = container.y + SCROLLBAR_TRACK_INSET + Math.floor(((track - length) * container.scrollY) / layout.maxScroll); + const left = container.x + container.width - SCROLLBAR_RIGHT_INSET; + for (let row = 0; row < length; row++) { + const end = row === 0 || row === length - 1; + image.fillRect(end ? left + 1 : left, top + row, end ? SCROLLBAR_WIDTH - 2 : SCROLLBAR_WIDTH, 1, SCROLLBAR_GREY); } } function paintBorder( image: GrayImage, - container: { x: number; y: number; width: number; height: number; borderWidth: number; borderRadius: number }, + container: { x: number; y: number; width: number; height: number; borderWidth: number; borderColor: number; borderRadius: number }, ): void { + const grey = borderGrey(container.borderColor); for (let i = 0; i < container.borderWidth; i++) { if (container.borderRadius > 0) { image.drawRoundedRect( @@ -66,28 +160,28 @@ function paintBorder( container.y + i, container.width - 2 * i, container.height - 2 * i, - TEXT_WHITE, + grey, Math.max(0, container.borderRadius - i), ); } else { - image.drawRect(container.x + i, container.y + i, container.width - 2 * i, container.height - 2 * i, TEXT_WHITE); + image.drawRect(container.x + i, container.y + i, container.width - 2 * i, container.height - 2 * i, grey); } } } +/** + * An opaque bitmap (black pixels cover what's beneath). Updates are converted + * to exactly the container's size (image-pipeline.ts); pixels an extended + * layout carried over from a differently sized container are clipped. + */ function paintImageContainer(image: GrayImage, container: EvenHubImageContainer): void { if (!container.pixels || container.pixelsWidth <= 0 || container.pixelsHeight <= 0) return; const source = new GrayImage(container.pixelsWidth, container.pixelsHeight, 0); source.pixels.set(container.pixels); - // Stock quirk: raw data smaller than the container tiles/repeats to fill it. - for (let ty = 0; ty < container.height; ty += container.pixelsHeight) { - for (let tx = 0; tx < container.width; tx += container.pixelsWidth) { - image.bitBlt(source, container.x + tx, container.y + ty, { - width: Math.min(container.pixelsWidth, container.width - tx), - height: Math.min(container.pixelsHeight, container.height - ty), - }); - } - } + image.bitBlt(source, container.x, container.y, { + width: Math.min(container.pixelsWidth, container.width), + height: Math.min(container.pixelsHeight, container.height), + }); } function paintListContainer(image: GrayImage, container: EvenHubListContainer, focused: boolean): void { @@ -95,36 +189,23 @@ function paintListContainer(image: GrayImage, container: EvenHubListContainer, f paintListItems(image, container, containerFace(container.font), focused); } -/** Bottom-to-top paint order for a page's containers. */ -function paintOrder(containers: EvenHubContainer[]): EvenHubContainer[] { - const anyZ = containers.some((c) => c.zOrderIndex !== undefined); - if (anyZ) { - // Explicit z-order: larger zOrderIndex renders closer to the front, i.e. - // painted later. (Stock requires all-or-nothing + unique values.) - return [...containers].sort((a, b) => (a.zOrderIndex ?? 0) - (b.zOrderIndex ?? 0)); - } - // Default (no z-order): image containers sit below lists and text. Cross-type - // order isn't defined by the wire format (separate object arrays), so this is - // our choice, matching stock. Order within each group is preserved. - const images = containers.filter((c) => c.kind === "image"); - const rest = containers.filter((c) => c.kind !== "image"); - return [...images, ...rest]; -} - /** Render a page into a fresh app-viewport image (positioned by the shell). */ export function compositePage(page: EvenHubPage | null, size: { width: number; height: number }, focused: boolean): GrayImage { const image = new GrayImage(size.width, size.height, 0); if (!page) return image; for (const container of paintOrder(page.containers)) { switch (container.kind) { - case "image": + case "image": { + if (!container.pixels) break; // Nothing is drawn before the first update. // Text painted so far is deferred draws (firmware-text runs), which - // would otherwise render above this container's raster. Stock puts a - // later image container OVER earlier text, so bake the pending draws - // first; text painted after this container stays deferred (and above). - image.bakeDeferredDrawsInPlace(); + // would otherwise render above this container's raster. The image is + // opaque and covers what's under it, so bake the draws it overlaps + // first; the others, and text painted later, stay deferred. + const box: Rect = { x: container.x, y: container.y, width: container.width, height: container.height }; + image.bakeDeferredDrawsWithin(box); paintImageContainer(image, container); break; + } case "text": paintTextContainer(image, container); break; diff --git a/app/apps/evenhub/containers.ts b/app/apps/evenhub/containers.ts index 6cb7f629..a2bb79d7 100644 --- a/app/apps/evenhub/containers.ts +++ b/app/apps/evenhub/containers.ts @@ -6,6 +6,7 @@ * reads go through loose key matching (the SDK's pickLoose behavior). */ import { mergeFontSpecs, parseFontSpec, type EvenHubFontSpec } from "./font-spec"; +import { inStockImageRange } from "./image-pipeline"; export type EvenHubTextContainer = { kind: "text"; @@ -16,6 +17,8 @@ export type EvenHubTextContainer = { width: number; height: number; borderWidth: number; + /** Firmware border color index 0..16; see borderGrey. */ + borderColor: number; borderRadius: number; paddingLength: number; isEventCapture: boolean; @@ -27,6 +30,11 @@ export type EvenHubTextContainer = { textColor: number | undefined; /** Extended-layout font (merged with the layout's default); undefined is the stock font. */ font: EvenHubFontSpec | undefined; + /** + * How far the text is scrolled up, in pixels. Host-local like a list's + * selection: stock scrolls an overflowing capture container itself. + */ + scrollY: number; }; export type EvenHubImageContainer = { @@ -54,6 +62,8 @@ export type EvenHubListContainer = { width: number; height: number; borderWidth: number; + /** Firmware border color index 0..16; see borderGrey. */ + borderColor: number; borderRadius: number; paddingLength: number; isEventCapture: boolean; @@ -80,7 +90,7 @@ export type EvenHubMenuItem = { }; export type EvenHubPage = { - /** In declaration order (lists, images, texts); z-sorted at paint time. */ + /** Lists, then texts, then images, each in declaration order (stock's container list order); z-sorted at paint time. */ containers: EvenHubContainer[]; /** * The page's contextual-menu entries (SDK 0.0.14 `menuObject`). Empty when @@ -92,6 +102,26 @@ export type EvenHubPage = { /** Stock draws at most a 5px border; wider requests are clamped. */ const MAX_BORDER_WIDTH = 5; +/** + * Stock firmware limits for list and text containers (common_text_create / + * common_list_create clamp to these), from the evenRealities-openCFW + * reconstruction. Extended layouts are exempt: they have their own canvas. + */ +const STOCK_SCREEN_WIDTH = 576; +const STOCK_SCREEN_HEIGHT = 288; +const STOCK_MAX_BORDER_COLOR = 16; +const STOCK_MAX_BORDER_RADIUS = 10; +const STOCK_MAX_PADDING = 32; +const STOCK_MAX_LIST_ITEMS = 20; + +/** + * The border color index's grey: indices 0..15 step by 0x11 (0 is black, so a + * border without a color is invisible) and 16 is white. + */ +export function borderGrey(index: number): number { + return index >= 0 && index < 16 ? index * 0x11 : 0xff; +} + /** Firmware brightness levels for text; 4 is the device default. */ const MIN_TEXT_BRIGHTNESS = 0; const MAX_TEXT_BRIGHTNESS = 4; @@ -154,6 +184,11 @@ function readBorderWidth(json: Record): number { return Math.max(0, Math.min(MAX_BORDER_WIDTH, readNumber(json, "borderWidth", 0))); } +/** A protobuf field, so an omitted borderColor is 0 (black). */ +function readBorderColor(json: Record): number { + return Math.max(0, readNumber(json, "borderColor", 0)); +} + /** A container's font: its own `font` over the layout-wide default. */ function readFont(json: Record, layoutFont: EvenHubFontSpec | undefined): EvenHubFontSpec | undefined { return mergeFontSpecs(layoutFont, parseFontSpec(pickLoose(json, "font"))); @@ -169,6 +204,7 @@ function parseTextContainer(json: Record, layoutFont: EvenHubFo width: readNumber(json, "width", 0), height: readNumber(json, "height", 0), borderWidth: readBorderWidth(json), + borderColor: readBorderColor(json), borderRadius: readNumber(json, "borderRadius", 0), paddingLength: readNumber(json, "paddingLength", 0), isEventCapture: readFlag(json, "isEventCapture"), @@ -177,6 +213,7 @@ function parseTextContainer(json: Record, layoutFont: EvenHubFo content: readString(json, "content", ""), textColor: readTextBrightness(json), font: readFont(json, layoutFont), + scrollY: 0, }; } @@ -262,6 +299,7 @@ function parseListContainer(json: Record, layoutFont: EvenHubFo width: readNumber(json, "width", 0), height: readNumber(json, "height", 0), borderWidth: readBorderWidth(json), + borderColor: readBorderColor(json), borderRadius: readNumber(json, "borderRadius", 0), paddingLength: readNumber(json, "paddingLength", 0), isEventCapture: readFlag(json, "isEventCapture"), @@ -277,9 +315,8 @@ function parseListContainer(json: Record, layoutFont: EvenHubFo /** * Parse a CreateStartUpPageContainer / RebuildPageContainer payload into a - * page. Containers keep declaration order within and across the three arrays - * (lists, then images, then texts — texts last so info panels and capture - * containers sit above image tiles when no zOrderIndex is given). + * page. Containers are kept in stock's container-list order: lists, then + * texts, then images, each in declaration order (evenhub_build_container_list). * * The whole page is replaced on rebuild, which is also what gives an omitted * menuObject its documented meaning: the previous contextual menu goes away. @@ -292,20 +329,100 @@ export function parsePage(data: Record): EvenHubPage { if (Array.isArray(lists)) { for (const item of lists) containers.push(parseListContainer(asRecord(item), layoutFont)); } - const images = pickLoose(data, "imageObject"); - if (Array.isArray(images)) { - for (const item of images) containers.push(parseImageContainer(asRecord(item))); - } const texts = pickLoose(data, "textObject"); if (Array.isArray(texts)) { for (const item of texts) containers.push(parseTextContainer(asRecord(item), layoutFont)); } + const images = pickLoose(data, "imageObject"); + if (Array.isArray(images)) { + for (const item of images) containers.push(parseImageContainer(asRecord(item))); + } return { containers, menuItems: parseMenuItems(data) }; } -/** The container that owns gesture events (exactly one per valid page). */ -export function eventCaptureContainer(page: EvenHubPage): EvenHubContainer | undefined { - return page.containers.find( - (container) => container.kind !== "image" && container.isEventCapture, - ); +/** + * Clamp a stock page's containers the way the firmware does when it creates + * them: positions and sizes to the 576x288 screen (images keep their size, + * which a separate check rejects instead), border color, radius and padding to + * their maxima, and lists to 20 items. Not for extended layouts. + */ +export function clampToStockLimits(page: EvenHubPage): void { + for (const c of page.containers) { + c.x = Math.min(c.x, STOCK_SCREEN_WIDTH); + c.y = Math.min(c.y, STOCK_SCREEN_HEIGHT); + if (c.kind === "image") continue; + c.width = Math.min(c.width, STOCK_SCREEN_WIDTH); + c.height = Math.min(c.height, STOCK_SCREEN_HEIGHT); + c.borderColor = Math.min(c.borderColor, STOCK_MAX_BORDER_COLOR); + c.borderRadius = Math.min(c.borderRadius, STOCK_MAX_BORDER_RADIUS); + c.paddingLength = Math.min(c.paddingLength, STOCK_MAX_PADDING); + if (c.kind === "list" && c.itemNames.length > STOCK_MAX_LIST_ITEMS) { + c.itemNames = c.itemNames.slice(0, STOCK_MAX_LIST_ITEMS); + } + } +} + +/** The firmware's fixed protobuf arrays: more containers than this fail to decode. */ +const STOCK_MAX_LISTS = 4; +const STOCK_MAX_TEXTS = 8; +const STOCK_MAX_IMAGES = 4; + +/** EhStartUpPageCreateResult values for a page the firmware can't build. */ +export const PAGE_CREATE_INVALID = 1; +export const PAGE_CREATE_OUT_OF_MEMORY = 3; + +/** + * Why the stock firmware would fail to build this page, with the create result + * the app gets, or null when it builds. Too many containers overflow the + * firmware's protobuf arrays, so decoding fails (it replies with the code the + * phone app maps to outOfMemory). An image container outside 20..288 x 20..144 + * fails to create (invalid container). + */ +export function stockPageFailure(page: EvenHubPage): { code: number; reason: string } | null { + const count = (kind: EvenHubContainer["kind"]) => page.containers.filter((c) => c.kind === kind).length; + const [lists, texts, images] = [count("list"), count("text"), count("image")]; + if (lists > STOCK_MAX_LISTS || texts > STOCK_MAX_TEXTS || images > STOCK_MAX_IMAGES) { + return { + code: PAGE_CREATE_OUT_OF_MEMORY, + reason: `${lists} list, ${texts} text and ${images} image containers (at most ${STOCK_MAX_LISTS}, ${STOCK_MAX_TEXTS} and ${STOCK_MAX_IMAGES})`, + }; + } + for (const c of page.containers) { + if (c.kind === "image" && !inStockImageRange(c.width, c.height)) { + return { code: PAGE_CREATE_INVALID, reason: `image container ${JSON.stringify(c.name)} is ${c.width}x${c.height}, outside 20..288 x 20..144` }; + } + } + return null; +} + +/** + * Bottom-to-top paint order, as stock stacks its containers: the container + * list order (lists, texts, images), stably sorted by zOrderIndex (larger is + * closer to the front) only when every container has one and there are at + * least two. So without z-order, images are drawn over text. + */ +export function paintOrder(containers: readonly EvenHubContainer[]): EvenHubContainer[] { + const allHaveZ = containers.every((c) => c.zOrderIndex !== undefined); + if (!allHaveZ || containers.length < 2) return [...containers]; + return [...containers].sort((a, b) => (a.zOrderIndex ?? 0) - (b.zOrderIndex ?? 0)); +} + +/** + * The container that owns gesture events. Stock binds the first list or text + * container with isEventCapture in paint order and ignores any later ones. + */ +export function eventCaptureContainer(page: EvenHubPage): EvenHubTextContainer | EvenHubListContainer | undefined { + for (const c of paintOrder(page.containers)) { + if (c.kind !== "image" && c.isEventCapture) return c; + } + return undefined; +} + +/** + * The container stock resolves an id to: the first one with that id in paint + * order, whatever its kind, so an update aimed at a later container that + * shares the id never reaches it. + */ +export function containerById(page: EvenHubPage | null, id: number): EvenHubContainer | undefined { + return page ? paintOrder(page.containers).find((c) => c.id === id) : undefined; } diff --git a/app/apps/evenhub/display-warning-dialog.ts b/app/apps/evenhub/display-warning-dialog.ts new file mode 100644 index 00000000..e99d52c0 --- /dev/null +++ b/app/apps/evenhub/display-warning-dialog.ts @@ -0,0 +1,65 @@ +import { wrapText } from "../../graphics/textwrap"; +import { type LayerContext } from "../../ui/layers"; +import { lineStep } from "../../ui/metrics"; +import { ScrollingDialogLayer, type DialogBody, type DialogRow } from "./scrolling-dialog"; + +/** Wider than the permission dialog: the RayNeo iO's window is short, so fewer, longer lines fit better. */ +const DIALOG_WIDTH = 420; + +/** + * Shown over an EvenHub app the first time it runs with a RayNeo iO paired + * (see glasses-compat.ts): the app is made for Even Realities glasses and + * won't display correctly on the iO's screen. The app starts underneath. + * Continue (or double-click) dismisses the warning; Close app closes the + * app's window. Either answer counts as having seen it; a window closed with + * the warning still up shows it again next time. + */ +export class EvenHubDisplayWarningLayer extends ScrollingDialogLayer { + constructor( + private readonly appName: string, + private readonly onAnswered: () => void, + private readonly closeApp: () => void, + ) { + super(DIALOG_WIDTH); + } + + protected bodyRows({ image, font, left, textWidth }: DialogBody): DialogRow[] { + const step = lineStep(font); + const rows: DialogRow[] = []; + for (const line of wrapText(font, "Compatibility warning", textWidth)) { + rows.push({ height: step + 2, draw: (top) => image.drawText(font, left, top, line, 235) }); + } + rows[rows.length - 1]!.height += 6; + const message = + `${this.appName} is an EvenHub app, made for Even Realities glasses. It will not display correctly ` + + "on the RayNeo iO, because the iO's screen has a different resolution."; + // One row per wrapped line, so a large font scrolls line by line. + const lines = wrapText(font, message, textWidth); + for (let index = 0; index < lines.length; index++) { + rows.push({ + height: step + (index === lines.length - 1 ? 8 : 0), + draw: (top) => image.drawText(font, left, top, lines[index]!, 190), + }); + } + return rows; + } + + protected actions(): string[] { + return ["Continue", "Close app"]; + } + + protected activate(action: string, ctx: LayerContext): void { + this.close(ctx, () => { + this.onAnswered(); + if (action === "Close app") this.closeApp(); + }); + } + + protected backedOut(): void { + this.onAnswered(); + } + + protected abandoned(): void { + // Not answered: the next launch shows it again. + } +} diff --git a/app/apps/evenhub/evenhub-window.ts b/app/apps/evenhub/evenhub-window.ts index a0937cb5..34a38e8e 100644 --- a/app/apps/evenhub/evenhub-window.ts +++ b/app/apps/evenhub/evenhub-window.ts @@ -16,6 +16,8 @@ import { shell } from "../../ui/shell/shell"; import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer"; import { EvenHubSession } from "./session"; import { renderInstalledEvenHubIcon } from "./installed-apps"; +import { markDisplayWarningShown, needsDisplayWarning } from "./glasses-compat"; +import { EvenHubDisplayWarningLayer } from "./display-warning-dialog"; class EvenHubAppLayer implements Layer { /** @@ -149,5 +151,16 @@ export function createEvenHubWindow( session.setScreenOn(on); }; + // The app's first run with a RayNeo iO paired: warn, over the app itself, + // that it won't display correctly there. + const packageId = session.manifest.packageId; + if (needsDisplayWarning(packageId)) { + created.stack.push(new EvenHubDisplayWarningLayer( + session.manifest.name, + () => markDisplayWarningShown(packageId), + () => shell.closeWindow(windowId), + )); + } + return created; } diff --git a/app/apps/evenhub/glasses-compat.ts b/app/apps/evenhub/glasses-compat.ts new file mode 100644 index 00000000..0485f663 --- /dev/null +++ b/app/apps/evenhub/glasses-compat.ts @@ -0,0 +1,38 @@ +/** + * EvenHub with glasses that aren't Even Realities': with a RayNeo iO paired, + * the store is off (it is Even's, and its apps are made for their glasses), + * while apps sideloaded through Files or the Developer app still run, after a + * warning the first time each one launches that it won't display correctly + * (EvenHub apps lay out for the G2's 576x288 display; the iO's is 540x220). + */ +import { glassesTypeSetting } from "../../ui/dashboard-settings"; +import { getStringSetting, setStringSetting } from "../../native/settings-store"; + +/** The package IDs whose RayNeo iO display warning has been answered, as a JSON array. */ +const DISPLAY_WARNED_KEY = "evenhub.rayneoDisplayWarned"; + +/** Whether the EvenHub store can be used: with Even Realities glasses paired, not a RayNeo iO. */ +export function isEvenHubStoreAvailable(): boolean { + return glassesTypeSetting.get() !== "rayneo-io"; +} + +/** Whether launching this package should warn that it won't display correctly on these glasses. */ +export function needsDisplayWarning(packageId: string): boolean { + return glassesTypeSetting.get() === "rayneo-io" && !displayWarnedPackages().includes(packageId); +} + +/** The user answered the package's display warning: don't show it again. */ +export function markDisplayWarningShown(packageId: string): void { + const warned = displayWarnedPackages(); + if (warned.includes(packageId)) return; + setStringSetting(DISPLAY_WARNED_KEY, JSON.stringify([...warned, packageId])); +} + +function displayWarnedPackages(): string[] { + try { + const parsed: unknown = JSON.parse(getStringSetting(DISPLAY_WARNED_KEY, "[]")); + return Array.isArray(parsed) ? parsed.filter((id): id is string => typeof id === "string") : []; + } catch { + return []; + } +} diff --git a/app/apps/evenhub/image-pipeline.ts b/app/apps/evenhub/image-pipeline.ts new file mode 100644 index 00000000..3f5345f8 --- /dev/null +++ b/app/apps/evenhub/image-pipeline.ts @@ -0,0 +1,247 @@ +/** + * updateImageRawData the way stock turns an app's imageData into the 4-bit + * bitmap the glasses show. The Even phone app does the conversion + * (EvenHubAppService.updateImageRawData → _prepare / _prepareLegacyRaw, read + * from its blutter decompilation); the glasses firmware then shows the result + * only if it is exactly the container's size (common_image_container_set_data). + * + * - imageData must be a JSON array of integers; a base64 string or an object + * (a typed array that skipped the SDK's toJson) fails as sendFailed. + * - PNG, JPEG, WebP, GIF and BMP are decoded, scaled to cover the container + * (aspect-fill, centre crop, nearest neighbour) and converted to grey with + * alpha ignored. + * - Anything else is raw pixels, accepted only with compressMode 2 (which the + * SDK sends since 0.0.12) and exactly the container's size: one byte per + * pixel (values up to 15 are already 4-bit levels) or 4-bit packed rows. + * + * Native-free so it runs under Node; JPEG/WebP/GIF decoding is injected. + */ +const UPNG = require("upng-js"); + +/** EhImageUpdateResult, as the SDK reads the host's integer. */ +export const IMAGE_SUCCESS = 0; +export const IMAGE_EXCEPTION = 1; +export const IMAGE_SIZE_INVALID = 2; +export const IMAGE_TO_GRAY4_FAILED = 3; +export const IMAGE_SEND_FAILED = 4; + +/** Stock image containers are 20..288 wide and 20..144 high. */ +export const STOCK_IMAGE_MIN_SIZE = 20; +export const STOCK_IMAGE_MAX_WIDTH = 288; +export const STOCK_IMAGE_MAX_HEIGHT = 144; + +/** The compressMode the SDK sends, and the phone app requires for raw pixels. */ +const RAW_COMPRESS_MODE = 2; + +export function inStockImageRange(width: number, height: number): boolean { + return width >= STOCK_IMAGE_MIN_SIZE && width <= STOCK_IMAGE_MAX_WIDTH && + height >= STOCK_IMAGE_MIN_SIZE && height <= STOCK_IMAGE_MAX_HEIGHT; +} + +export type ImageFormat = "png" | "jpeg" | "webp" | "gif" | "bmp" | "raw"; + +/** Format by magic bytes, as the phone app's EvenHubImageFormatDetector. */ +export function detectImageFormat(b: Uint8Array): ImageFormat { + const at = (i: number, ...values: number[]) => values.every((v, j) => b[i + j] === v); + if (at(0, 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a)) return "png"; + if (at(0, 0xff, 0xd8, 0xff)) return "jpeg"; + if (at(0, 0x52, 0x49, 0x46, 0x46) && at(8, 0x57, 0x45, 0x42, 0x50)) return "webp"; + if (at(0, 0x47, 0x49, 0x46, 0x38, 0x37, 0x61) || at(0, 0x47, 0x49, 0x46, 0x38, 0x39, 0x61)) return "gif"; + if (at(0, 0x42, 0x4d)) return "bmp"; + return "raw"; +} + +/** Decoded pixels, RGBA, not premultiplied. */ +export type RgbaImage = { width: number; height: number; rgba: Uint8Array }; + +export type NativeImageDecoder = (bytes: Uint8Array) => RgbaImage | null; + +/** 8-bit grey from RGB (alpha ignored), then the nearest of 16 levels. */ +export function grayLevel(r: number, g: number, b: number): number { + const g8 = Math.floor((299 * r + 587 * g + 114 * b + 500) / 1000); + return Math.min(15, Math.max(0, Math.floor((g8 * 15 + 127) / 255))); +} + +export function rgbaToLevels(image: RgbaImage): Uint8Array { + const levels = new Uint8Array(image.width * image.height); + for (let i = 0; i < levels.length; i++) { + const o = i * 4; + levels[i] = grayLevel(image.rgba[o]!, image.rgba[o + 1]!, image.rgba[o + 2]!); + } + return levels; +} + +/** + * Scale to exactly width x height covering it (aspect-fill), cropping the + * overflow equally on both sides, sampling the nearest source pixel centre. + */ +export function resizeRgbaCover(image: RgbaImage, width: number, height: number): RgbaImage { + const scale = Math.max(width / image.width, height / image.height); + const offX = (image.width - width / scale) / 2; + const offY = (image.height - height / scale) / 2; + const rgba = new Uint8Array(width * height * 4); + for (let y = 0; y < height; y++) { + const sy = Math.min(image.height - 1, Math.max(0, Math.floor(offY + (y + 0.5) / scale))); + for (let x = 0; x < width; x++) { + const sx = Math.min(image.width - 1, Math.max(0, Math.floor(offX + (x + 0.5) / scale))); + const from = (sy * image.width + sx) * 4; + rgba.set(image.rgba.subarray(from, from + 4), (y * width + x) * 4); + } + } + return { width, height, rgba }; +} + +function decodePng(bytes: Uint8Array): RgbaImage | null { + try { + const decoded = UPNG.decode(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)); + const frames = UPNG.toRGBA8(decoded) as ArrayBuffer[]; + if (!frames.length) return null; + return { width: decoded.width, height: decoded.height, rgba: new Uint8Array(frames[0]!) }; + } catch { + return null; + } +} + +/** + * Uncompressed Windows BMP ('BM', BI_RGB): 1/4/8-bit paletted and 24/32-bit, + * top-down or bottom-up. Null for other variants (the native decoder may still + * read them). EvenChess sends 1-bit BMPs for full-board refreshes. + */ +export function decodeBmp(bytes: Uint8Array): RgbaImage | null { + if (bytes.length < 54 || bytes[0] !== 0x42 || bytes[1] !== 0x4d) return null; + const u16 = (o: number) => bytes[o]! | (bytes[o + 1]! << 8); + const u32 = (o: number) => (bytes[o]! | (bytes[o + 1]! << 8) | (bytes[o + 2]! << 16) | (bytes[o + 3]! << 24)) >>> 0; + const i32 = (o: number) => bytes[o]! | (bytes[o + 1]! << 8) | (bytes[o + 2]! << 16) | (bytes[o + 3]! << 24); + const pixelOffset = u32(10); + const dibSize = u32(14); + const width = i32(18); + const heightRaw = i32(22); + const bitCount = u16(28); + if (u32(30) !== 0) return null; // only BI_RGB + if (width <= 0 || width > 4096) return null; + const topDown = heightRaw < 0; + const height = Math.abs(heightRaw); + if (height === 0 || height > 4096) return null; + if (![1, 4, 8, 24, 32].includes(bitCount)) return null; + + // Palette entries are 4 bytes, BGRx. + let palette: Uint8Array | null = null; + if (bitCount <= 8) { + let count = u32(46); + if (count === 0 || count > 1 << bitCount) count = 1 << bitCount; + palette = new Uint8Array(count * 3); + for (let i = 0; i < count; i++) { + const o = 14 + dibSize + i * 4; + if (o + 2 >= bytes.length) break; + palette.set([bytes[o + 2]!, bytes[o + 1]!, bytes[o]!], i * 3); + } + } + const stride = ((width * bitCount + 31) >> 5) << 2; + const rgba = new Uint8Array(width * height * 4); + for (let y = 0; y < height; y++) { + const row = pixelOffset + (topDown ? y : height - 1 - y) * stride; + if (row >= bytes.length) break; + for (let x = 0; x < width; x++) { + let r: number, g: number, b: number; + if (palette) { + let index: number; + if (bitCount === 1) index = ((bytes[row + (x >> 3)] ?? 0) >> (7 - (x & 7))) & 1; + else if (bitCount === 4) index = (x & 1) === 0 ? (bytes[row + (x >> 1)] ?? 0) >> 4 : (bytes[row + (x >> 1)] ?? 0) & 0x0f; + else index = bytes[row + x] ?? 0; + if (index * 3 >= palette.length) index = 0; + [r, g, b] = [palette[index * 3]!, palette[index * 3 + 1]!, palette[index * 3 + 2]!]; + } else { + const o = row + x * (bitCount / 8); + [r, g, b] = [bytes[o + 2] ?? 0, bytes[o + 1] ?? 0, bytes[o] ?? 0]; + } + rgba.set([r, g, b, 255], (y * width + x) * 4); + } + } + return { width, height, rgba }; +} + +/** imageData as bytes: a JSON array of integers only (Uint8List.fromList keeps the low 8 bits). */ +function imageDataBytes(raw: unknown): Uint8Array | null { + if (raw === undefined || raw === null) return new Uint8Array(0); + if (!Array.isArray(raw)) return null; + const out = new Uint8Array(raw.length); + for (let i = 0; i < raw.length; i++) { + const value: unknown = raw[i]; + if (typeof value !== "number" || !Number.isInteger(value)) return null; + out[i] = value & 0xff; + } + return out; +} + +export type PreparedImage = { + result: number; + /** 4-bit levels (0..15), row-major, when result is success. */ + levels: Uint8Array | null; + width: number; + height: number; + format: ImageFormat | null; + /** Why it failed, for the debug log. */ + reason: string; +}; + +export type ImageRequest = { + imageData: unknown; + compressMode: number; + /** width/height sent with the update; when both are positive they replace the container's. */ + requestWidth: number; + requestHeight: number; + /** The image container's size, looked up by id or name; null when none matched. */ + geometry: { width: number; height: number } | null; + decodeNative: NativeImageDecoder; + /** Stock pages limit image sizes; Faceclaw's extended layouts don't. */ + stockLimits: boolean; +}; + +/** Convert an update's imageData to 4-bit levels the way the phone app does. */ +export function prepareImageUpdate(request: ImageRequest): PreparedImage { + const fail = (result: number, reason: string, format: ImageFormat | null = null): PreparedImage => + ({ result, levels: null, width: 0, height: 0, format, reason }); + const bytes = imageDataBytes(request.imageData); + if (!bytes) return fail(IMAGE_SEND_FAILED, "imageData is not an array of integers"); + const inRange = (w: number, h: number) => (request.stockLimits ? inStockImageRange(w, h) : w > 0 && h > 0); + const [width, height] = request.requestWidth > 0 && request.requestHeight > 0 + ? [request.requestWidth, request.requestHeight] + : [request.geometry?.width ?? 0, request.geometry?.height ?? 0]; + + const format = detectImageFormat(bytes); + if (format === "raw") { + if (request.stockLimits && request.compressMode !== RAW_COMPRESS_MODE) { + return fail(IMAGE_EXCEPTION, `raw pixels need compressMode ${RAW_COMPRESS_MODE}`, format); + } + if (!inRange(width, height)) return fail(IMAGE_SIZE_INVALID, `raw size ${width}x${height} out of range`, format); + const levels = new Uint8Array(width * height); + const packedStride = Math.ceil(width / 2); + if (bytes.length === width * height) { + for (let i = 0; i < levels.length; i++) { + const v = bytes[i]!; + levels[i] = v <= 15 ? v : Math.floor((v * 15 + 127) / 255); + } + } else if (bytes.length === packedStride * height) { + for (let y = 0; y < height; y++) { + for (let x = 0; x < width; x++) { + const byte = bytes[y * packedStride + (x >> 1)]!; + levels[y * width + x] = (x & 1) === 0 ? byte >> 4 : byte & 0x0f; + } + } + } else { + return fail(IMAGE_EXCEPTION, `raw length ${bytes.length} fits neither ${width}x${height} 8-bit nor 4-bit`, format); + } + return { result: IMAGE_SUCCESS, levels, width, height, format, reason: "" }; + } + + let decoded = format === "png" ? decodePng(bytes) : format === "bmp" ? decodeBmp(bytes) : null; + decoded ??= request.decodeNative(bytes); + if (!decoded || decoded.width <= 0 || decoded.height <= 0) return fail(IMAGE_EXCEPTION, `${format} decode failed`, format); + if (inRange(width, height) && (decoded.width !== width || decoded.height !== height)) { + decoded = resizeRgbaCover(decoded, width, height); + } + if (!inRange(decoded.width, decoded.height)) { + return fail(IMAGE_SIZE_INVALID, `${decoded.width}x${decoded.height} out of range`, format); + } + return { result: IMAGE_SUCCESS, levels: rgbaToLevels(decoded), width: decoded.width, height: decoded.height, format, reason: "" }; +} diff --git a/app/apps/evenhub/index.ts b/app/apps/evenhub/index.ts index f7968676..75a02c70 100644 --- a/app/apps/evenhub/index.ts +++ b/app/apps/evenhub/index.ts @@ -5,6 +5,9 @@ * a phone WebView (its runtime + phone UI) and a 576x288 glasses window * composited by Faceclaw instead of the stock firmware. * + * With a RayNeo iO paired the store is unavailable and sideloaded apps warn + * on first run that they won't display correctly; see glasses-compat.ts. + * * Design notes: notes/evenhub_compatibility.txt. */ import { type AppContext, type AppDefinition } from "../app-definition"; @@ -15,6 +18,7 @@ import { createInProcessWindow, type InProcessWindow } from "../../ui/shell/in-p import { renderEvenRealitiesLogo } from "../../graphics/even-realities-logo"; import { makeImageWindowIcon, windowIcon } from "../../ui/shell/chrome-layer"; import { type InstalledEvenHubApp } from "./installed-apps"; +import { isEvenHubStoreAvailable } from "./glasses-compat"; const EVENHUB_STORE_WINDOW_ID = "evenhub:store"; const EVENHUB_STORE_SURFACE_ID = "window:evenhub:store"; @@ -104,8 +108,17 @@ const evenhubApp: AppDefinition = { title: "EvenHub", icon: "package", renderIcon: renderEvenRealitiesLogo, + // Off the launcher with a RayNeo iO paired. A store window that opens + // anyway (restored from before a re-pair, or the launcher's route for an + // installed app whose package is missing) says why instead of loading. + isSupported: isEvenHubStoreAvailable, launch: async (ctx) => { - await ensureStoreWindow(ctx); + const { window } = await ensureStoreWindow(ctx); + if (!isEvenHubStoreAvailable()) { + // Store pages opened while Even glasses were paired would cover the notice. + window.stack.clearToBase(); + window.requestRender(); + } }, }; diff --git a/app/apps/evenhub/layout-debug.ts b/app/apps/evenhub/layout-debug.ts new file mode 100644 index 00000000..2653b394 --- /dev/null +++ b/app/apps/evenhub/layout-debug.ts @@ -0,0 +1,181 @@ +/** + * Debug-log descriptions of EvenHub page layouts and container updates. + * session.ts sends them to logcat at debug level (tag FaceclawEvenHubLayout). + * + * "note:" lines point out page quirks that change what stock (and so we) do + * with it: shared ids, missing or extra capture containers, a wrong + * containerTotalNum. + */ +import { + paintOrder, + readOptionalNumber, + type EvenHubContainer, + type EvenHubListContainer, + type EvenHubPage, + type EvenHubTextContainer, +} from "./containers"; +import type { PreparedImage } from "./image-pipeline"; + +const CONTENT_PREVIEW_CHARS = 40; +const RAW_STRING_CHARS = 120; +const RAW_ARRAY_ITEMS = 32; + +function label(c: EvenHubContainer): string { + return `${c.kind}#${c.id} ${JSON.stringify(c.name)}`; +} + +function preview(text: string): string { + return JSON.stringify(text.length > CONTENT_PREVIEW_CHARS ? `${text.slice(0, CONTENT_PREVIEW_CHARS)}…` : text); +} + +function decoration(c: EvenHubTextContainer | EvenHubListContainer): string { + let out = ""; + if (c.borderWidth > 0) out += ` border=${c.borderWidth}c${c.borderColor}${c.borderRadius > 0 ? `r${c.borderRadius}` : ""}`; + if (c.paddingLength > 0) out += ` pad=${c.paddingLength}`; + if (c.isEventCapture) out += " capture"; + if (c.font) out += " font"; + return out; +} + +function describeContainer(c: EvenHubContainer): string { + const z = c.zOrderIndex === undefined ? "" : ` z=${c.zOrderIndex}`; + const head = `${label(c)} @${c.x},${c.y} ${c.width}x${c.height}${z}`; + switch (c.kind) { + case "image": + return `${head} ${c.pixels ? `pixels=${c.pixelsWidth}x${c.pixelsHeight}` : "no pixels yet"}`; + case "text": { + const color = c.textColor === undefined ? "" : ` color=${c.textColor}`; + return `${head}${decoration(c)}${color} len=${c.content.length} ${preview(c.content)}`; + } + case "list": + return `${head}${decoration(c)} items=${c.itemNames.length} itemWidth=${c.itemWidth}${c.selectBorder ? " selectBorder" : ""} selected=${c.selectedIndex}`; + } +} + +/** Quirks of a page that change how stock treats it. */ +export function pageNotes(page: EvenHubPage, declaredTotal?: number): string[] { + const notes: string[] = []; + const ordered = paintOrder(page.containers); + const byId = new Map(); + for (const c of ordered) byId.set(c.id, [...(byId.get(c.id) ?? []), c]); + byId.forEach((shared, id) => { + if (shared.length > 1) { + notes.push(`id ${id} is shared by ${shared.map(label).join(", ")}; updates and events resolve to ${label(shared[0]!)} only`); + } + }); + const captures = ordered.filter((c) => c.kind !== "image" && c.isEventCapture); + if (captures.length === 0) notes.push("no event-capture container, so the app gets no input"); + else if (captures.length > 1) notes.push(`${captures.length} event-capture containers; only the first, ${label(captures[0]!)}, gets input`); + if (declaredTotal !== undefined && declaredTotal !== page.containers.length) { + notes.push(`containerTotalNum is ${declaredTotal} but ${page.containers.length} containers were sent (nothing checks it)`); + } + return notes; +} + +/** The payload, as compact JSON with long strings and arrays cut short. */ +function rawJson(data: Record): string { + try { + return JSON.stringify(data, (_key, value: unknown) => { + if (typeof value === "string" && value.length > RAW_STRING_CHARS) { + return `${value.slice(0, RAW_STRING_CHARS)}…(${value.length} chars)`; + } + if (Array.isArray(value) && value.length > RAW_ARRAY_ITEMS) { + return [...value.slice(0, RAW_ARRAY_ITEMS), `…(${value.length} items)`]; + } + return value; + }); + } catch (error) { + return `(unserializable: ${String(error)})`; + } +} + +/** A create/rebuild/extension layout: one line per container in paint order, then notes, then the raw payload. */ +export function describePage(method: string, page: EvenHubPage, data: Record): string[] { + const containers = page.containers; + const count = (kind: EvenHubContainer["kind"]) => containers.filter((c) => c.kind === kind).length; + const declaredTotal = readOptionalNumber(data, "containerTotalNum"); + const total = declaredTotal === undefined ? "" : `, containerTotalNum=${declaredTotal}`; + const menu = page.menuItems.length > 0 ? `, ${page.menuItems.length} menu items` : ""; + const lines = [ + `${method}: ${containers.length} containers (${count("list")} list, ${count("text")} text, ${count("image")} image)` + + `${total}${menu}; painted bottom to top:`, + ]; + paintOrder(containers).forEach((c, i) => lines.push(` ${i}: ${describeContainer(c)}`)); + for (const note of pageNotes(page, declaredTotal)) lines.push(` note: ${note}`); + lines.push(` raw: ${rawJson(data)}`); + return lines; +} + +function payloadKind(raw: unknown): string { + if (raw === undefined || raw === null) return "missing"; + if (Array.isArray(raw)) return `number[${raw.length}]`; + if (typeof raw === "string") return `string(${raw.length} chars)`; + if (typeof raw === "object") return `object(${Object.keys(raw).length} keys)`; + return typeof raw; +} + +/** Lit-pixel count and bounding box of 4-bit levels, so a blank "hide this" image is recognizable. */ +function litSummary(levels: Uint8Array, width: number): string { + let lit = 0; + let max = 0; + let x0 = width; + let y0 = Infinity; + let x1 = -1; + let y1 = -1; + for (let i = 0; i < levels.length; i++) { + const level = levels[i]!; + if (level === 0) continue; + lit++; + if (level > max) max = level; + const x = i % width; + const y = Math.floor(i / width); + if (x < x0) x0 = x; + if (x > x1) x1 = x; + if (y < y0) y0 = y; + if (y > y1) y1 = y; + } + return lit === 0 ? "blank" : `lit=${lit}px max=${max}/15 bbox=${x0},${y0}-${x1},${y1}`; +} + +export type ImageUpdateDebug = { + sentId: number; + sentName: string; + raw: unknown; + /** The container the id resolves to. */ + target: EvenHubContainer | undefined; + prepared: PreparedImage; + /** Whether the container now shows the update. */ + shown: boolean; + /** EhImageUpdateResult returned to the app. */ + result: number; +}; + +export function describeImageUpdate(u: ImageUpdateDebug): string[] { + const parts = [`updateImageRawData id=${u.sentId} ${JSON.stringify(u.sentName)}`]; + parts.push(`-> ${u.target ? label(u.target) : "no container"}`); + parts.push(`payload=${payloadKind(u.raw)}`); + if (u.prepared.format) parts.push(`format=${u.prepared.format}`); + if (u.prepared.levels) parts.push(`${u.prepared.width}x${u.prepared.height} ${litSummary(u.prepared.levels, u.prepared.width)}`); + parts.push(`result=${u.result}`, u.shown ? "shown" : "not shown"); + const lines = [parts.join(" ")]; + if (u.prepared.reason) lines.push(` ${u.prepared.reason}`); + if (u.prepared.result === 0 && u.target?.kind !== "image") { + lines.push(` the id ${u.target ? `resolves to ${label(u.target)}` : "matches no container"}, so the glasses refuse the transfer`); + } else if (u.prepared.result === 0 && !u.shown && u.target) { + lines.push(` ${u.prepared.width}x${u.prepared.height} isn't the container's ${u.target.width}x${u.target.height}, so the glasses drop it`); + } + return lines; +} + +export function describeTextUpgrade( + sentId: number, + sentName: string, + container: EvenHubTextContainer | null, + offset: number | undefined, + sentLength: number, +): string { + if (!container) return `textContainerUpgrade id=${sentId} ${JSON.stringify(sentName)}: no container with that id`; + const at = offset === undefined ? "" : ` offset=${offset}`; + const color = container.textColor === undefined ? "" : ` color=${container.textColor}`; + return `textContainerUpgrade ${label(container)}${at} sent=${sentLength} chars -> len=${container.content.length}${color} ${preview(container.content)}`; +} diff --git a/app/apps/evenhub/manager.ts b/app/apps/evenhub/manager.ts index 14b9382f..8b2acb7c 100644 --- a/app/apps/evenhub/manager.ts +++ b/app/apps/evenhub/manager.ts @@ -6,8 +6,8 @@ * * Glasses-first: launching does NOT take over the phone screen. The phone * stays on the Faceclaw dashboard; an app's phone UI is shown on demand - * (window menu -> "Show phone UI", or the app-icon button in the phone's - * action bar while the app is foreground on the glasses), overlaying the + * (window menu -> "Show phone UI", or the app-icon button in the bar under the + * phone's mirror while the app is foreground on the glasses), overlaying the * dashboard, and the Back button or the overlay's close button returns to it. * Apps are kept alive until explicitly closed (no memory eviction yet). */ @@ -40,14 +40,14 @@ type RunningApp = { packageId: string; session: EvenHubSession; webView: EvenHubWebView; - /** The app's icon for the phone action bar, rendered on first use. */ + /** The app's icon for the phone's button bar, rendered on first use. */ phoneIcon?: ImageSource | null; }; -/** The phone action bar's button for opening the foreground app's phone UI. */ +/** The button under the phone's mirror that opens the foreground app's phone UI. */ export type PhoneUiButton = { windowId: string; title: string; icon: ImageSource | null }; -/** Pixel size the action-bar icon is rendered at (~21dp at xxhdpi). */ +/** Pixel size the button's icon is rendered at (~21dp at xxhdpi; shown at 20dp). */ const PHONE_ICON_SIZE = 63; const running = new Map(); @@ -244,7 +244,7 @@ export function hidePhone(): void { /** * The foreground glasses window, when it is an EvenHub app whose phone UI - * isn't showing: the phone action bar then offers a button to show it. + * isn't showing: the bar under the phone's mirror then offers a button to show it. */ export function phoneUiButton(): PhoneUiButton | null { const window = shell.foregroundWindow(); @@ -252,7 +252,7 @@ export function phoneUiButton(): PhoneUiButton | null { if (!window || !app || phoneShownWindowId === app.windowId) return null; if (app.phoneIcon === undefined) { // The same artwork as the glasses sidebar (installed icon, else the - // generic package icon), drawn white. + // generic package icon), drawn white; the button's stylesheet tints it. const image = new GrayImage(PHONE_ICON_SIZE, PHONE_ICON_SIZE, 0); window.drawIcon(image, 0, 0, PHONE_ICON_SIZE); app.phoneIcon = grayImageToWhiteIconSource(image); diff --git a/app/apps/evenhub/payload-validation.ts b/app/apps/evenhub/payload-validation.ts new file mode 100644 index 00000000..4d001b91 --- /dev/null +++ b/app/apps/evenhub/payload-validation.ts @@ -0,0 +1,141 @@ +/** + * The checks the Even phone app applies to createStartUpPageContainer, + * rebuildPageContainer and textContainerUpgrade payloads before it sends + * anything to the glasses (read from its blutter decompilation: + * EvenHubProtoJsonMapper.validateTextBrightness, mapProtoJsonKeys and + * protobuf.dart's tag-keyed JSON parsing): + * + * - every key must be one the message defines (a numeric key passes as a raw + * protobuf tag, which we then ignore); + * - numeric fields take an integer or a numeric string — not a boolean, a + * fraction or null; string fields take a string; repeated fields an array; + * - any key named textColor, anywhere, must be an integer from 0 to 4. + * + * A failure means the call fails without reaching the glasses: create + * returns invalid (1), rebuild and textContainerUpgrade return false. + * Faceclaw's extended layouts are not checked; they carry their own keys. + */ + +type FieldType = "uint" | "string" | "any" | { list: FieldType } | { message: Schema }; +type Schema = Readonly>; + +const BOX: Schema = { + xPosition: "uint", + yPosition: "uint", + width: "uint", + height: "uint", + containerID: "uint", + containerName: "string", + zOrderIndex: "uint", +}; + +const DECORATED: Schema = { + ...BOX, + borderWidth: "uint", + borderColor: "uint", + borderRadius: "uint", + paddingLength: "uint", + isEventCapture: "uint", +}; + +const TEXT: Schema = { ...DECORATED, content: "string", textColor: "uint" }; + +const ITEM_CONTAINER: Schema = { + itemCount: "uint", + itemWidth: "uint", + isItemSelectBorderEn: "uint", + itemName: { list: "string" }, +}; + +const LIST: Schema = { ...DECORATED, itemContainer: { message: ITEM_CONTAINER } }; + +// The app knows position, subItems and checkedIndex (second-level menus, not +// yet in the SDK); their value types are unconfirmed, so they aren't checked. +const MENU_ITEM: Schema = { itemName: "string", itemID: "uint", position: "any", subItems: "any", checkedIndex: "any" }; + +const MENU: Schema = { menuItems: { list: { message: MENU_ITEM } } }; + +const REBUILD: Schema = { + containerTotalNum: "uint", + listObject: { list: { message: LIST } }, + textObject: { list: { message: TEXT } }, + imageObject: { list: { message: BOX } }, + menuObject: { message: MENU }, +}; + +const CREATE: Schema = { ...REBUILD, widgetId: "uint" }; + +const TEXT_UPGRADE: Schema = { + containerID: "uint", + containerName: "string", + contentOffset: "uint", + contentLength: "uint", + content: "string", + textColor: "uint", +}; + +const SCHEMAS = { create: CREATE, rebuild: REBUILD, textUpgrade: TEXT_UPGRADE } as const; + +/** What Dart's int.parse accepts. */ +const INT_STRING = /^\s*[+-]?(?:\d+|0[xX][0-9a-fA-F]+)\s*$/; + +function isRecord(value: unknown): value is Record { + return !!value && typeof value === "object" && !Array.isArray(value); +} + +function checkValue(type: FieldType, value: unknown, path: string): string | null { + if (type === "any") return null; + if (value === null || value === undefined) return `${path} is null`; + if (type === "uint") { + if (typeof value === "number" ? Number.isInteger(value) : typeof value === "string" && INT_STRING.test(value)) return null; + return `${path} must be an integer, not ${JSON.stringify(value)}`; + } + if (type === "string") return typeof value === "string" ? null : `${path} must be a string, not ${JSON.stringify(value)}`; + if ("list" in type) { + if (!Array.isArray(value)) return `${path} must be an array`; + for (let i = 0; i < value.length; i++) { + const error = checkValue(type.list, value[i], `${path}[${i}]`); + if (error) return error; + } + return null; + } + return isRecord(value) ? checkMessage(type.message, value, path) : `${path} must be an object`; +} + +function checkMessage(schema: Schema, message: Record, path: string): string | null { + for (const [key, value] of Object.entries(message)) { + const field = schema[key]; + if (!field) { + if (INT_STRING.test(key)) continue; + return `unknown key ${path ? `${path}.` : ""}${key}`; + } + const error = checkValue(field, value, path ? `${path}.${key}` : key); + if (error) return error; + } + return null; +} + +/** validateTextBrightness: every textColor key, at any depth, holds an integer 0..4. */ +function checkTextColors(value: unknown, path: string): string | null { + if (Array.isArray(value)) { + for (let i = 0; i < value.length; i++) { + const error = checkTextColors(value[i], `${path}[${i}]`); + if (error) return error; + } + } else if (isRecord(value)) { + for (const [key, child] of Object.entries(value)) { + const at = path ? `${path}.${key}` : key; + if (key === "textColor" && !(typeof child === "number" && Number.isInteger(child) && child >= 0 && child <= 4)) { + return `${at} must be an integer from 0 to 4, not ${JSON.stringify(child)}`; + } + const error = checkTextColors(child, at); + if (error) return error; + } + } + return null; +} + +/** Why the Even app would refuse this payload without sending it, or null if it would send it. */ +export function stockPayloadError(kind: keyof typeof SCHEMAS, data: Record): string | null { + return checkTextColors(data, "") ?? checkMessage(SCHEMAS[kind], data, ""); +} diff --git a/app/apps/evenhub/permission-dialog.ts b/app/apps/evenhub/permission-dialog.ts index 3f0560ff..8c0ae2a6 100644 --- a/app/apps/evenhub/permission-dialog.ts +++ b/app/apps/evenhub/permission-dialog.ts @@ -1,17 +1,11 @@ -import { getDefaultSmallFont } from "../../graphics/ui-fonts"; -import { GrayImage } from "../../graphics/image"; import { truncateText, wrapText } from "../../graphics/textwrap"; -import { type InputEvent } from "../../ui/gestures"; -import { Layer, type LayerContext, type PaintBelow } from "../../ui/layers"; -import { drawListScrollbar, drawSelectionHighlight } from "../../ui/menu"; +import { type LayerContext } from "../../ui/layers"; import { permissionDetail, permissionLabel, type EvenHubPermission } from "./permissions"; import { openPrivacyPolicyOnPhone } from "./privacy-policy"; -import { lineStep, listRowHeight } from "../../ui/metrics"; +import { lineStep } from "../../ui/metrics"; +import { ScrollingDialogLayer, type DialogBody, type DialogRow } from "./scrolling-dialog"; -/** Minimum gap between the dialog and the edges of the window it's centered in. */ -const DIALOG_MARGIN = 8; const DIALOG_WIDTH = 320; -const PADDING = 10; const PERM_GAP = 4; /** @@ -20,56 +14,26 @@ const PERM_GAP = 4; * Cancel (or double-click) backs out. A privacy-policy-only app still reaches * this dialog so the user can review the policy before allowing first run. * - * When the list overflows the viewport the dialog scrolls: scroll events move - * through the content row by row, and only once the bottom is fully visible do - * further scrolls move the action selection. The actions are inert until then - * (a click just scrolls), so the user can't Allow without having had the whole - * list on screen. + * A long list scrolls a page at a time, and Allow stays inert until the + * bottom has been reached (see ScrollingDialogLayer), so the user can't + * Allow without having had the whole list on screen. */ -export class EvenHubPermissionDialogLayer implements Layer { - /** Floats in front of the window content, like the context menus. */ - readonly depth = 2; - /** Starts on Allow; the optional privacy-policy action is inserted after it. */ - private selectedIndex = 0; - /** First content row drawn; rows above it are scrolled off. */ - private firstRow = 0; - /** Scroll position at which the last row is fully visible; set by paint. */ - private maxFirstRow = 0; - private resolved = false; - +export class EvenHubPermissionDialogLayer extends ScrollingDialogLayer { constructor( private readonly appName: string, private readonly permissions: EvenHubPermission[], private readonly privacyPolicyUrl: string, private readonly onConfirm: () => void, private readonly onCancel: () => void, - ) {} - - /** Whether the dialog is scrolled to the bottom, making the actions live. */ - private atBottom(): boolean { - return this.firstRow >= this.maxFirstRow; + ) { + super(DIALOG_WIDTH); } - paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage { - const font = getDefaultSmallFont(); - const { width: viewportWidth, height: viewportHeight } = ctx.stack.getBaseSize(); - const image = paintBelow(); - const dialogWidth = Math.min(DIALOG_WIDTH, viewportWidth - 2 * DIALOG_MARGIN); - const dialogX = ((viewportWidth - dialogWidth) / 2) | 0; - const textWidth = dialogWidth - 2 * PADDING - 4; - const left = dialogX + PADDING + 2; - + protected bodyRows({ image, font, left, textWidth }: DialogBody): DialogRow[] { const headerStep = lineStep(font) + 2; const permLabelStep = lineStep(font) + 1; const permDetailStep = lineStep(font) - 1; - const actionRowH = listRowHeight(font); - const actions = this.actions(); - const focused = ctx.stack.isFocused(); - - // The dialog body as scrollable rows; each row's height includes the gap - // below it, so scrolling and visibility checks work on whole rows. - type Row = { height: number; draw: (top: number) => void }; - const rows: Row[] = []; + const rows: DialogRow[] = []; const heading = this.permissions.length ? `${this.appName} needs:` : `${this.appName} is ready to run`; rows.push({ height: headerStep + 6, @@ -98,113 +62,28 @@ export class EvenHubPermissionDialogLayer implements Layer { }); } } - for (let index = 0; index < actions.length; index++) { - rows.push({ - height: actionRowH, - draw: (top) => { - const selected = this.atBottom() && index === this.selectedIndex; - if (selected) { - drawSelectionHighlight(image, dialogX + 12, top, dialogWidth - 24, actionRowH - 1, focused, 8); - } - image.drawText(font, dialogX + 22, top + 3, actions[index]!, selected ? 255 : 200); - }, - }); - } - - const contentHeight = rows.reduce((sum, row) => sum + row.height, 0); - const height = Math.min(contentHeight + 2 * PADDING, viewportHeight - 2 * DIALOG_MARGIN); - const dialogY = ((viewportHeight - height) / 2) | 0; - const visibleHeight = height - 2 * PADDING; - - // The bottommost scroll position: the largest suffix of rows that fits. - let maxFirstRow = rows.length; - for (let suffixHeight = 0; maxFirstRow > 0; maxFirstRow--) { - const rowHeight = rows[maxFirstRow - 1]!.height; - if (suffixHeight + rowHeight > visibleHeight) break; - suffixHeight += rowHeight; - } - this.maxFirstRow = maxFirstRow; - this.firstRow = Math.max(0, Math.min(this.firstRow, maxFirstRow)); - - // Fill 1 (transparent color key is 0), outline for the dialog edge. - image.fillRoundedRect(dialogX, dialogY, dialogWidth, height, 1); - image.drawRoundedRect(dialogX, dialogY, dialogWidth, height, 72); - - let y = dialogY + PADDING; - for (let index = this.firstRow; index < rows.length; index++) { - const row = rows[index]!; - if (y + row.height > dialogY + PADDING + visibleHeight) break; - row.draw(y); - y += row.height; - } - - if (maxFirstRow > 0) { - drawListScrollbar( - image, - dialogX + dialogWidth - 7, - dialogY + PADDING, - visibleHeight, - this.firstRow, - rows.length - maxFirstRow, - rows.length, - ); - } - return image; + return rows; } - handleInput(event: InputEvent, ctx: LayerContext): void { - const actions = this.actions(); - switch (event.type) { - case "scroll-up": - if (this.atBottom() && this.selectedIndex > 0) { - this.selectedIndex -= 1; - } else if (this.firstRow > 0) { - this.firstRow -= 1; - } - return; - case "scroll-down": - if (!this.atBottom()) { - this.firstRow += 1; - } else { - this.selectedIndex = Math.min(actions.length - 1, this.selectedIndex + 1); - } - return; - case "click": - if (!this.atBottom()) { - this.firstRow += 1; - return; - } - if (actions[this.selectedIndex] === "Privacy policy") { - openPrivacyPolicyOnPhone(this.privacyPolicyUrl, this.appName); - } else { - this.resolve(ctx, actions[this.selectedIndex] === "Allow"); - } - return; - case "double-click": - this.resolve(ctx, false); - return; - default: - return; - } - } - - onRemoved(): void { - // Dismissed some other way (window closed, back button): treat as cancel. - if (!this.resolved) { - this.resolved = true; - this.onCancel(); - } - } - - private resolve(ctx: LayerContext, confirmed: boolean): void { - if (this.resolved) return; - this.resolved = true; - ctx.stack.pop(); - if (confirmed) this.onConfirm(); - else this.onCancel(); - } - - private actions(): string[] { + protected actions(): string[] { return this.privacyPolicyUrl ? ["Allow", "Privacy policy", "Cancel"] : ["Allow", "Cancel"]; } + + protected activate(action: string, ctx: LayerContext): void { + if (action === "Privacy policy") { + openPrivacyPolicyOnPhone(this.privacyPolicyUrl, this.appName); + } else if (action === "Allow") { + this.close(ctx, () => this.onConfirm()); + } else { + this.close(ctx, () => this.onCancel()); + } + } + + protected backedOut(): void { + this.onCancel(); + } + + protected abandoned(): void { + this.onCancel(); + } } diff --git a/app/apps/evenhub/scrolling-dialog.ts b/app/apps/evenhub/scrolling-dialog.ts new file mode 100644 index 00000000..1c9862d6 --- /dev/null +++ b/app/apps/evenhub/scrolling-dialog.ts @@ -0,0 +1,201 @@ +import { getDefaultSmallFont } from "../../graphics/ui-fonts"; +import { type GrayImage, type UiFont } from "../../graphics/image"; +import { type InputEvent } from "../../ui/gestures"; +import { type Layer, type LayerContext, type PaintBelow } from "../../ui/layers"; +import { drawListScrollbar, drawSelectionHighlight } from "../../ui/menu"; +import { listRowHeight } from "../../ui/metrics"; + +/** Minimum gap between the dialog and the edges of the window it's centered in. */ +const DIALOG_MARGIN = 8; +const PADDING = 10; + +/** One row of a dialog's content. Its height includes the gap below it, so scrolling works on whole rows. */ +export type DialogRow = { height: number; draw: (top: number) => void }; + +/** What a dialog's body rows draw with: the canvas, the font, and the text column. */ +export type DialogBody = { image: GrayImage; font: UiFont; left: number; textWidth: number }; + +/** + * A dialog box centered over the window it opens in: body rows, then a + * column of actions, starting on the first. EvenHub's confirmations and + * warnings (permissions, the RayNeo iO display warning) are built on it. + * + * When the content overflows the viewport the dialog scrolls a page at a + * time, keeping one line of overlap (the last line of one page is the first + * of the next), and only once the bottom is fully visible do further scrolls + * move the action selection. The actions are inert until then (a click just + * pages down), so nothing can be chosen without the whole dialog having been + * on screen. Double-click backs out. + */ +export abstract class ScrollingDialogLayer implements Layer { + /** Floats in front of the window content, like the context menus. */ + readonly depth = 2; + private selectedIndex = 0; + /** First content row drawn; rows above it are scrolled off. */ + private firstRow = 0; + /** Scroll position at which the last row is fully visible; set by paint. */ + private maxFirstRow = 0; + /** Heights of the content rows and of the viewport they scroll in, as last painted (for paging). */ + private rowHeights: number[] = []; + private visibleHeight = 0; + private resolved = false; + + constructor(private readonly maxWidth: number) {} + + /** The rows above the actions. */ + protected abstract bodyRows(body: DialogBody): DialogRow[]; + /** The action labels, top to bottom. */ + protected abstract actions(): string[]; + /** A click on an action once the actions are live; close() dismisses the dialog with it. */ + protected abstract activate(action: string, ctx: LayerContext): void; + /** Double-click: the user backed out of the dialog. */ + protected abstract backedOut(): void; + /** The dialog left the stack unanswered (its window closed). */ + protected abstract abandoned(): void; + + /** Whether the dialog is scrolled to the bottom, making the actions live. */ + private atBottom(): boolean { + return this.firstRow >= this.maxFirstRow; + } + + paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage { + const font = getDefaultSmallFont(); + const { width: viewportWidth, height: viewportHeight } = ctx.stack.getBaseSize(); + const image = paintBelow(); + const dialogWidth = Math.min(this.maxWidth, viewportWidth - 2 * DIALOG_MARGIN); + const dialogX = ((viewportWidth - dialogWidth) / 2) | 0; + const textWidth = dialogWidth - 2 * PADDING - 4; + const left = dialogX + PADDING + 2; + + const actionRowH = listRowHeight(font); + const actions = this.actions(); + const focused = ctx.stack.isFocused(); + + const rows = this.bodyRows({ image, font, left, textWidth }); + for (let index = 0; index < actions.length; index++) { + rows.push({ + height: actionRowH, + draw: (top) => { + const selected = this.atBottom() && index === this.selectedIndex; + if (selected) { + drawSelectionHighlight(image, dialogX + 12, top, dialogWidth - 24, actionRowH - 1, focused, 8); + } + image.drawText(font, dialogX + 22, top + 3, actions[index]!, selected ? 255 : 200); + }, + }); + } + + const contentHeight = rows.reduce((sum, row) => sum + row.height, 0); + const height = Math.min(contentHeight + 2 * PADDING, viewportHeight - 2 * DIALOG_MARGIN); + const dialogY = ((viewportHeight - height) / 2) | 0; + const visibleHeight = height - 2 * PADDING; + + // The bottommost scroll position: the largest suffix of rows that fits. + let maxFirstRow = rows.length; + for (let suffixHeight = 0; maxFirstRow > 0; maxFirstRow--) { + const rowHeight = rows[maxFirstRow - 1]!.height; + if (suffixHeight + rowHeight > visibleHeight) break; + suffixHeight += rowHeight; + } + this.maxFirstRow = maxFirstRow; + this.firstRow = Math.max(0, Math.min(this.firstRow, maxFirstRow)); + this.rowHeights = rows.map((row) => row.height); + this.visibleHeight = visibleHeight; + + // Fill 1 (transparent color key is 0), outline for the dialog edge. + image.fillRoundedRect(dialogX, dialogY, dialogWidth, height, 1); + image.drawRoundedRect(dialogX, dialogY, dialogWidth, height, 72); + + let y = dialogY + PADDING; + for (let index = this.firstRow; index < rows.length; index++) { + const row = rows[index]!; + if (y + row.height > dialogY + PADDING + visibleHeight) break; + row.draw(y); + y += row.height; + } + + if (maxFirstRow > 0) { + drawListScrollbar( + image, + dialogX + dialogWidth - 7, + dialogY + PADDING, + visibleHeight, + this.firstRow, + rows.length - maxFirstRow, + rows.length, + ); + } + return image; + } + + handleInput(event: InputEvent, ctx: LayerContext): void { + const actions = this.actions(); + switch (event.type) { + case "scroll-up": + if (this.atBottom() && this.selectedIndex > 0) { + this.selectedIndex -= 1; + } else if (this.firstRow > 0) { + this.pageUp(); + } + return; + case "scroll-down": + if (!this.atBottom()) { + this.pageDown(); + } else { + this.selectedIndex = Math.min(actions.length - 1, this.selectedIndex + 1); + } + return; + case "click": + if (!this.atBottom()) { + this.pageDown(); + return; + } + this.activate(actions[this.selectedIndex]!, ctx); + return; + case "double-click": + this.close(ctx, () => this.backedOut()); + return; + default: + return; + } + } + + /** Scroll so the last fully visible row becomes the first (one row of overlap). */ + private pageDown(): void { + let y = 0; + let lastVisible = this.firstRow; + for (let index = this.firstRow; index < this.rowHeights.length; index++) { + y += this.rowHeights[index]!; + if (y > this.visibleHeight) break; + lastVisible = index; + } + this.firstRow = Math.min(this.maxFirstRow, Math.max(this.firstRow + 1, lastVisible)); + } + + /** Scroll so the current first row becomes the last fully visible one (one row of overlap). */ + private pageUp(): void { + let first = this.firstRow; + let y = this.rowHeights[first] ?? 0; + while (first > 0 && y + this.rowHeights[first - 1]! <= this.visibleHeight) { + first -= 1; + y += this.rowHeights[first]!; + } + this.firstRow = Math.max(0, Math.min(this.firstRow - 1, first)); + } + + onRemoved(): void { + // Dismissed some other way (window closed, back button). + if (!this.resolved) { + this.resolved = true; + this.abandoned(); + } + } + + /** Take the dialog down, then run the answer's effect (once, however it was answered). */ + protected close(ctx: LayerContext, then: () => void): void { + if (this.resolved) return; + this.resolved = true; + ctx.stack.pop(); + then(); + } +} diff --git a/app/apps/evenhub/session.ts b/app/apps/evenhub/session.ts index bdbdd92d..18ba982e 100644 --- a/app/apps/evenhub/session.ts +++ b/app/apps/evenhub/session.ts @@ -38,7 +38,11 @@ import { import { EvenHubApiKeyDialogLayer } from "./api-key-dialog"; import { asRecord, + clampToStockLimits, + containerById, declaredMenuItems, + PAGE_CREATE_INVALID, + stockPageFailure, eventCaptureContainer, parsePage, readNumber, @@ -50,8 +54,13 @@ import { type EvenHubContainer, type EvenHubMenuItem, type EvenHubPage, + type EvenHubTextContainer, } from "./containers"; -import { compositePage } from "./compositor"; +import { compositePage, layoutText } from "./compositor"; +import { describeImageUpdate, describePage, describeTextUpgrade } from "./layout-debug"; +import { IMAGE_SEND_FAILED, IMAGE_SUCCESS, prepareImageUpdate } from "./image-pipeline"; +import { stockPayloadError } from "./payload-validation"; +import { decodeImageRgba } from "../../native/image-rgba"; import { stepListSelection } from "./list-menu"; import { type EvenHubManifest } from "./ehpk"; import { permissionsIncludeMicrophone, permissionsInclude } from "./permissions"; @@ -74,7 +83,15 @@ import { parseWindowIcon, WindowIconRenderer } from "./window-icon"; import { availableFontFamilies, containerFace, measureContainerText } from "./fonts"; import { parseFontSpec } from "./font-spec"; -const UPNG = require("upng-js"); + +/** + * Page layouts and container updates go to logcat at debug level (see + * layout-debug.ts): `adb logcat -s FaceclawEvenHubLayout:D`. Android only. + */ +const LAYOUT_LOG_TAG = "FaceclawEvenHubLayout"; +const LAYOUT_LOG_ENABLED = !!global.isAndroid; +/** Logcat truncates entries around 4 KB; split longer lines below that. */ +const LOGCAT_CHUNK_CHARS = 3000; /** OsEventTypeList values (PB ordinals). */ const CLICK_EVENT = 0; @@ -83,12 +100,20 @@ const SCROLL_BOTTOM_EVENT = 2; const DOUBLE_CLICK_EVENT = 3; const FOREGROUND_ENTER_EVENT = 4; const FOREGROUND_EXIT_EVENT = 5; +const ABNORMAL_EXIT_EVENT = 6; const SYSTEM_EXIT_EVENT = 7; const IMU_DATA_REPORT_EVENT = 8; /** SDK 0.0.14: the press gesture, delivered like any other list/text/sys event. */ const LONG_PRESS_EVENT = 9; const LONG_PRESS_RELEASE_EVENT = 10; +/** After a failed rebuild, how long the app gets to hear ABNORMAL_EXIT before it is closed. */ +const ABNORMAL_EXIT_CLOSE_DELAY_MS = 200; + +/** Stock text scrolling: one step per swipe, and "at an end" within this tolerance. */ +const TEXT_SCROLL_STEP_PX = 28; +const TEXT_SCROLL_EDGE_PX = 3; + /** * Injected into every served HTML document at document start (before any app * JS): (1) the promise-returning flutter_inappwebview.callHandler the EvenHub @@ -416,6 +441,8 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH private page: EvenHubPage | null = null; private pageCreated = false; + /** The page came from Faceclaw's extended layout API, which isn't held to stock limits. */ + private extendedLayout = false; private webViewHandle: EvenHubWebViewHandle | null = null; private windowHooks: EvenHubWindowHooks | null = null; private closed = false; @@ -596,6 +623,8 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH const eventType = event.type === "scroll-up" ? SCROLL_TOP_EVENT : SCROLL_BOTTOM_EVENT; if (capture?.kind === "list") { this.scrollList(capture, eventType, inputSource); + } else if (capture?.kind === "text") { + this.scrollText(capture, eventType, inputSource); } else { this.emitSysEvent(eventType, 0, inputSource); } @@ -620,6 +649,25 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH this.pushMessage("evenHubEvent", { type: "menuItemClickEvent", jsonData: { itemID } }); } + /** + * Stock scrolls a capture text container that overflows by itself, a 28px + * step per swipe, and tells the app only at the ends (a textEvent naming the + * container). Text that fits reports every swipe as reaching an end. + */ + private scrollText(text: EvenHubTextContainer, eventType: number, inputSource?: ExtensionInputSource): void { + const { maxScroll } = layoutText(text); + const forward = eventType === SCROLL_BOTTOM_EVENT; + const atEnd = forward ? maxScroll - text.scrollY < TEXT_SCROLL_EDGE_PX : text.scrollY < TEXT_SCROLL_EDGE_PX; + if (maxScroll === 0 || atEnd) { + this.emitTextEvent(text, eventType, inputSource); + return; + } + text.scrollY = forward + ? Math.min(maxScroll, text.scrollY + TEXT_SCROLL_STEP_PX) + : Math.max(0, text.scrollY - TEXT_SCROLL_STEP_PX); + this.windowHooks?.requestRender(); + } + private scrollList(list: EvenHubListContainer, eventType: number, inputSource?: ExtensionInputSource): void { // Swipe up selects the previous item, swipe down the next (stock direction). const delta = eventType === SCROLL_TOP_EVENT ? -1 : 1; @@ -808,7 +856,8 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH deliverImu(reading: ImuReading): void { this.pushEvenHubEvent("sysEvent", { eventType: IMU_DATA_REPORT_EVENT, - imuData: { x: reading.x, y: reading.y, z: reading.z }, + // The Even app's field name (protobuf IMU_Data); the SDK reads it as imuData. + iMUData: { x: reading.x, y: reading.y, z: reading.z }, }); } @@ -858,7 +907,8 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH const first = args[0]; const message = asRecord(typeof first === "string" ? JSON.parse(first) : first); const method = readString(message, "method", ""); - const data = asRecord(message.data); + // As the Even app: `data`, else `payload`. + const data = asRecord(message.data ?? message.payload); result = await this.dispatch(method, data); } catch (error) { this.log(`evenhub bridge call failed: ${error}`); @@ -916,13 +966,29 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH private async createStartUpPage(data: Record): Promise { if (this.pageCreated) { // One-shot per session on stock: a second call blocks ~2s, then fails. + this.layoutLog(() => ["createStartUpPageContainer: repeated call, rejected as stock does"]); await delay(DUPLICATE_CREATE_DELAY_MS); return 1; } + // The Even app refuses some payloads without sending them; then the + // firmware may fail to build the page. + const payloadError = stockPayloadError("create", data); + if (payloadError) { + this.layoutLog(() => [`createStartUpPageContainer refused, as the Even app would: ${payloadError}`]); + return PAGE_CREATE_INVALID; + } const page = parsePage(data); - this.warnOnInvalidPage(page, data); + const failure = stockPageFailure(page); + if (failure) { + this.layoutLog(() => [`createStartUpPageContainer failed, as the firmware would: ${failure.reason}`]); + return failure.code; + } + clampToStockLimits(page); + this.warnOnDroppedMenuItems(page, data); + this.layoutLog(() => describePage("createStartUpPageContainer", page, data)); this.page = page; this.pageCreated = true; + this.extendedLayout = false; // The launch focus arrived before the page existed; deliver the ENTER now. if (this.foreground && !this.launchEnterSent) { this.launchEnterSent = true; @@ -933,16 +999,39 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH } private rebuildPage(data: Record): boolean { - // Also serves as create for apps that fall back to rebuild-on-error. + // Only createStartUpPageContainer starts an EvenHub page on the glasses. + if (!this.pageCreated) { + this.layoutLog(() => ["rebuildPageContainer before createStartUpPageContainer: no page to rebuild"]); + return false; + } + const payloadError = stockPayloadError("rebuild", data); + if (payloadError) { + this.layoutLog(() => [`rebuildPageContainer refused, as the Even app would: ${payloadError}`]); + return false; + } const page = parsePage(data); - this.warnOnInvalidPage(page, data); + const failure = stockPageFailure(page); + if (failure) { + // The firmware has already torn the old page down; it reports an + // abnormal exit and the Even app closes the app. + this.layoutLog(() => [`rebuildPageContainer failed, as the firmware would: ${failure.reason}; closing the app`]); + this.page = { containers: [], menuItems: [] }; + this.windowHooks?.requestRender(); + this.emitSysEvent(ABNORMAL_EXIT_EVENT, 0); + this.systemExitSent = true; + setTimeout(() => this.close(), ABNORMAL_EXIT_CLOSE_DELAY_MS); + return false; + } + clampToStockLimits(page); + this.warnOnDroppedMenuItems(page, data); + this.layoutLog(() => describePage("rebuildPageContainer", page, data)); this.page = page; - this.pageCreated = true; + this.extendedLayout = false; this.windowHooks?.requestRender(); return true; } - private warnOnInvalidPage(page: EvenHubPage, data: Record): void { + private warnOnDroppedMenuItems(page: EvenHubPage, data: Record): void { const declaredMenuCount = declaredMenuItems(data).length; if (declaredMenuCount > page.menuItems.length) { this.log( @@ -950,64 +1039,106 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH "items (max 10, itemID must be non-zero and unique, itemName at most 32 UTF-8 bytes)", ); } - // Stock rejects these outright; we accept-and-log until rejection is - // proven necessary for compatibility. - const captures = page.containers.filter((c) => c.kind !== "image" && c.isEventCapture).length; - if (captures !== 1) this.log(`evenhub: page has ${captures} event-capture containers (stock requires exactly 1)`); - const texts = page.containers.filter((c) => c.kind === "text").length; - const images = page.containers.filter((c) => c.kind === "image").length; - if (texts > 8 || images > 4) this.log(`evenhub: page exceeds stock limits (${texts} text, ${images} image)`); } private textUpgrade(data: Record): boolean { - const id = readNumber(data, "containerID", -1); - // containerID is the identity; containerName is optional in the wild (e.g. - // level-even-g2 omits it). Match by id, enforcing the name only when the app - // actually supplies a non-empty one. (updateImage already matches by id.) + const id = readNumber(data, "containerID", 0); const name = readString(data, "containerName", ""); - const container = this.page?.containers.find( - (c) => c.kind === "text" && c.id === id && (name === "" || c.name === name), - ); - if (!container || container.kind !== "text") return false; const content = readString(data, "content", ""); const offset = readOptionalNumber(data, "contentOffset"); - // (contentLength is intentionally ignored — see below.) - // Stock semantics are "write `content` at contentOffset and truncate the - // rest" (a null-terminating strcpy(buf+offset, content)), NOT a splice that - // keeps the old tail after offset+contentLength. Keeping the tail left stray - // trailing text when an app (e.g. g2oom) shrank a string with an - // under-sized contentLength; dropping it matches stock and still supports - // suffix rewrites (offset>0) and full replaces (offset 0 / omitted). - if (offset !== undefined && offset > 0) { - container.content = container.content.slice(0, offset) + content; - } else { - container.content = content; + const payloadError = stockPayloadError("textUpgrade", data); + if (payloadError) { + this.layoutLog(() => [`textContainerUpgrade refused, as the Even app would: ${payloadError}`]); + return false; + } + // The firmware finds the container by id alone (its first container with + // that id, of any kind); the name isn't checked anywhere. + const target = containerById(this.page, id); + if (!target) { + this.layoutLog(() => [describeTextUpgrade(id, name, null, offset, content.length)]); + return false; + } + // Aimed at a list or image, the firmware writes into it as if it were + // text and reports success; nothing we could show. + if (target.kind !== "text") return true; + // The content replaces the whole text: stock ignores contentOffset and + // contentLength (firmware 2.2.9.22 in the emulator showed "XY" alone for + // every offset/length tried). The firmware re-sets the label, scrolled + // back to the top, only for non-empty text, so emptying a container + // leaves its old text showing (apps send " " to clear one). + if (content !== "") { + target.content = content; + target.scrollY = 0; } // SDK 0.0.14: textColor on an incremental update sets the container's // brightness; omitting it keeps whatever level the container has. const brightness = readTextBrightness(data); - if (brightness !== undefined) container.textColor = brightness; + if (brightness !== undefined) target.textColor = brightness; + this.layoutLog(() => [describeTextUpgrade(id, name, target, offset, content.length)]); this.windowHooks?.requestRender(); return true; } - /** BleEhSendImageResult: 0 success, 1 imageException, 2 sizeInvalid, 3 sendFailed. */ + /** EhImageUpdateResult: 0 success, 1 imageException, 2 sizeInvalid, 3 toGray4Failed, 4 sendFailed. */ private updateImage(data: Record): number { - const id = readNumber(data, "containerID", -1); - const container = this.page?.containers.find((c) => c.kind === "image" && c.id === id); - if (!container || container.kind !== "image") return 3; - const bytes = imagePayloadBytes(data.imageData ?? data.rawData ?? asRecord(data).mapRawData); - if (!bytes || bytes.length === 0) return 1; - const decoded = decodeImageBytes(bytes, container); - if (!decoded) return 1; - container.pixels = decoded.pixels; - container.pixelsWidth = decoded.width; - container.pixelsHeight = decoded.height; - this.windowHooks?.requestRender(); - return 0; + const id = readNumber(data, "containerID", 0); + const name = readString(data, "containerName", ""); + const raw = data.imageData; + // Before the page exists (and after shutdown) the Even app fails it outright. + if (!this.pageCreated || !this.page) { + this.layoutLog(() => [`updateImageRawData id=${id}: no page yet, sendFailed`]); + return IMAGE_SEND_FAILED; + } + // The Even app sizes the bitmap from the image container it finds by id, + // then by trimmed name. + const images = this.page.containers.filter((c): c is EvenHubImageContainer => c.kind === "image"); + const geometry = (id > 0 ? images.find((c) => c.id === id) : undefined) ?? + (name.trim() ? images.find((c) => c.name.trim() === name.trim()) : undefined); + const prepared = prepareImageUpdate({ + imageData: raw, + compressMode: readNumber(data, "compressMode", 0), + requestWidth: readNumber(data, "width", 0), + requestHeight: readNumber(data, "height", 0), + geometry: geometry ?? null, + decodeNative: decodeImageRgba, + stockLimits: !this.extendedLayout, + }); + // The firmware takes the transfer only for an id whose first container is + // an image, and then shows the bitmap only if it's exactly that size. + const target = containerById(this.page, id); + let result = prepared.result; + let shown = false; + if (result === IMAGE_SUCCESS && target?.kind !== "image") { + result = IMAGE_SEND_FAILED; + } else if (result === IMAGE_SUCCESS && target?.kind === "image" && prepared.levels && + prepared.width === target.width && prepared.height === target.height) { + target.pixels = prepared.levels.map((level) => level * 17); + target.pixelsWidth = prepared.width; + target.pixelsHeight = prepared.height; + shown = true; + this.windowHooks?.requestRender(); + } + this.layoutLog(() => describeImageUpdate({ sentId: id, sentName: name, raw, target, prepared, shown, result })); + return result; + } + + /** Debug-level logcat for layouts and updates; `describe` runs only when logging is on. */ + private layoutLog(describe: () => string[]): void { + if (!LAYOUT_LOG_ENABLED) return; + try { + const prefix = `[${this.manifest.packageId}] `; + for (const line of describe()) { + for (let i = 0; i < line.length; i += LOGCAT_CHUNK_CHARS) { + android.util.Log.d(LAYOUT_LOG_TAG, prefix + line.slice(i, i + LOGCAT_CHUNK_CHARS)); + } + } + } catch (error) { + console.warn(`evenhub: layout log failed: ${error}`); + } } private shutDown(exitMode: number): boolean { + this.layoutLog(() => [`shutDownPageContainer exitMode=${exitMode}`]); if (exitMode === 1) { // The app asked to quit (stock would pop an on-glasses confirm). We // decline and hand focus to the app switcher instead, leaving the app @@ -1075,6 +1206,15 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH this.pushEvenHubEvent("sysEvent", { eventType, eventSource, [INPUT_SOURCE_FIELD]: inputSource }); } + private emitTextEvent(text: EvenHubTextContainer, eventType: number, inputSource?: ExtensionInputSource): void { + this.pushEvenHubEvent("textEvent", { + containerID: text.id, + containerName: text.name, + eventType, + [INPUT_SOURCE_FIELD]: inputSource, + }); + } + private emitListEvent(list: EvenHubListContainer, eventType: number, inputSource?: ExtensionInputSource): void { this.pushEvenHubEvent("listEvent", { containerID: list.id, @@ -1252,8 +1392,10 @@ export class EvenHubSession implements EvenHubMicClient, EvenHubImuClient, EvenH for (const container of page.containers) { if (container.preserve) preserveContent(container, previous); } + this.layoutLog(() => describePage("extension layout", page, data)); this.page = page; this.pageCreated = true; + this.extendedLayout = true; // The extended layout uses the taller app area. this.windowHooks?.setTallCanvas(true); if (this.foreground && !this.launchEnterSent) { @@ -1559,82 +1701,6 @@ function normalizeBuzzerSteps(raw: unknown[]): Step[] { return out; } -/** - * Decode an uncompressed Windows BMP ('BM', BI_RGB) to 8bpp grayscale. Handles - * 1/4/8-bit paletted and 24/32-bit BGR(A), top-down or bottom-up. Returns null - * for compressed or unsupported variants. Apps like EvenChess send 1-bit BMPs - * (black/white palette) for full-board refreshes. - */ -function decodeBmp(bytes: Uint8Array): { pixels: Uint8Array; width: number; height: number } | null { - if (bytes.length < 54 || bytes[0] !== 0x42 || bytes[1] !== 0x4d) return null; - const u16 = (o: number) => bytes[o]! | (bytes[o + 1]! << 8); - const u32 = (o: number) => (bytes[o]! | (bytes[o + 1]! << 8) | (bytes[o + 2]! << 16) | (bytes[o + 3]! << 24)) >>> 0; - const i32 = (o: number) => bytes[o]! | (bytes[o + 1]! << 8) | (bytes[o + 2]! << 16) | (bytes[o + 3]! << 24); - - const pixelOffset = u32(10); - const dibSize = u32(14); - const width = i32(18); - const heightRaw = i32(22); - const bitCount = u16(28); - const compression = u32(30); - if (compression !== 0) return null; // only BI_RGB (uncompressed) - if (width <= 0 || width > 4096) return null; - const topDown = heightRaw < 0; - const height = Math.abs(heightRaw); - if (height === 0 || height > 4096) return null; - - // Palette (grayscale per index) for <=8bpp; each entry is 4 bytes BGRA. - let palette: Uint8Array | null = null; - if (bitCount <= 8) { - let numColors = u32(46); - if (numColors === 0 || numColors > (1 << bitCount)) numColors = 1 << bitCount; - const palOffset = 14 + dibSize; - palette = new Uint8Array(numColors); - for (let i = 0; i < numColors; i++) { - const o = palOffset + i * 4; - if (o + 2 >= bytes.length) break; - palette[i] = luminance(bytes[o + 2]!, bytes[o + 1]!, bytes[o]!); - } - } - - const stride = (((width * bitCount + 31) >> 5) << 2); // rows are 4-byte aligned - const pixels = new Uint8Array(width * height); - for (let y = 0; y < height; y++) { - const srcY = topDown ? y : height - 1 - y; - const rowStart = pixelOffset + srcY * stride; - if (rowStart >= bytes.length) break; - const dstRow = y * width; - for (let x = 0; x < width; x++) { - let gray: number; - if (bitCount === 1) { - const bit = ((bytes[rowStart + (x >> 3)] ?? 0) >> (7 - (x & 7))) & 1; - gray = palette?.[bit] ?? (bit ? 255 : 0); - } else if (bitCount === 4) { - const byte = bytes[rowStart + (x >> 1)] ?? 0; - const nib = (x & 1) === 0 ? byte >> 4 : byte & 0x0f; - gray = palette?.[nib] ?? nib * 17; - } else if (bitCount === 8) { - const idx = bytes[rowStart + x] ?? 0; - gray = palette?.[idx] ?? idx; - } else if (bitCount === 24) { - const o = rowStart + x * 3; - gray = luminance(bytes[o + 2] ?? 0, bytes[o + 1] ?? 0, bytes[o] ?? 0); - } else if (bitCount === 32) { - const o = rowStart + x * 4; - gray = luminance(bytes[o + 2] ?? 0, bytes[o + 1] ?? 0, bytes[o] ?? 0); - } else { - return null; - } - pixels[dstRow + x] = gray; - } - } - return { pixels, width, height }; -} - -function luminance(r: number, g: number, b: number): number { - return Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b); -} - /** * Input-device names in the extension API: the touchDown event's source, and * the `faceclawInputSource` field added to stock gesture events. @@ -1686,97 +1752,3 @@ function elideZeroFields(obj: Record): Record return out; } -/** Accept the payload forms seen on the wire: number[], JSON-ified typed - * array ({"0": 1, ...}), or base64 string. */ -function imagePayloadBytes(raw: unknown): Uint8Array | null { - if (Array.isArray(raw)) { - const out = new Uint8Array(raw.length); - for (let i = 0; i < raw.length; i++) out[i] = Number(raw[i]) & 0xff; - return out; - } - if (typeof raw === "string") return base64Decode(raw); - if (raw && typeof raw === "object") { - const record = raw as Record; - const keys = Object.keys(record); - const out = new Uint8Array(keys.length); - for (let i = 0; i < keys.length; i++) { - const value = record[String(i)]; - if (typeof value !== "number") return null; - out[i] = value & 0xff; - } - return out; - } - return null; -} - -const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -function base64Decode(text: string): Uint8Array | null { - const clean = text.replace(/[\s=]+$/g, "").replace(/\s+/g, ""); - const out = new Uint8Array(Math.floor((clean.length * 3) / 4)); - let bits = 0; - let bitCount = 0; - let outIndex = 0; - for (const char of clean) { - const value = BASE64_ALPHABET.indexOf(char); - if (value < 0) return null; - bits = (bits << 6) | value; - bitCount += 6; - if (bitCount >= 8) { - bitCount -= 8; - out[outIndex++] = (bits >> bitCount) & 0xff; - } - } - return out.subarray(0, outIndex); -} - -/** - * Decode an image payload: PNG or BMP (both are sent by real apps — EvenChess - * force-refreshes as 1-bit BMP but streams live moves as PNG, so a host that - * only did PNG dropped the initial board), or raw grayscale sized to the - * container (8bpp, or 4bpp packed two pixels per byte, high nibble first). - */ -function decodeImageBytes( - bytes: Uint8Array, - container: EvenHubImageContainer, -): { pixels: Uint8Array; width: number; height: number } | null { - if (bytes.length > 2 && bytes[0] === 0x42 && bytes[1] === 0x4d) { - const bmp = decodeBmp(bytes); - if (bmp) return bmp; - } - if (bytes.length > 4 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) { - try { - const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength); - const decoded = UPNG.decode(buffer); - const frames = UPNG.toRGBA8(decoded) as ArrayBuffer[]; - if (!frames.length) return null; - const rgba = new Uint8Array(frames[0]!); - const pixels = new Uint8Array(decoded.width * decoded.height); - for (let i = 0; i < pixels.length; i++) { - const offset = i * 4; - const alpha = (rgba[offset + 3] ?? 0) / 255; - pixels[i] = Math.round( - (0.2126 * (rgba[offset] ?? 0) + 0.7152 * (rgba[offset + 1] ?? 0) + 0.0722 * (rgba[offset + 2] ?? 0)) * alpha, - ); - } - return { pixels, width: decoded.width, height: decoded.height }; - } catch (error) { - console.warn(`evenhub: PNG decode failed: ${error}`); - return null; - } - } - const area = container.width * container.height; - if (bytes.length === area) { - return { pixels: Uint8Array.from(bytes), width: container.width, height: container.height }; - } - if (bytes.length === Math.ceil(area / 2)) { - const pixels = new Uint8Array(area); - for (let i = 0; i < area; i++) { - const byte = bytes[i >> 1]!; - const nibble = i % 2 === 0 ? byte >> 4 : byte & 0x0f; - pixels[i] = nibble * 17; - } - return { pixels, width: container.width, height: container.height }; - } - return null; -} diff --git a/app/apps/evenhub/store-detail-layer.ts b/app/apps/evenhub/store-detail-layer.ts index ba179d86..34b86704 100644 --- a/app/apps/evenhub/store-detail-layer.ts +++ b/app/apps/evenhub/store-detail-layer.ts @@ -16,7 +16,11 @@ import { cleanError, installStoreApp } from "./store-install"; import { describeUpdate } from "./updates"; import { lineStep, listRowHeight } from "../../ui/metrics"; -const X = 18; +/** How far an action row's highlight box overhangs the column of text it belongs to, on each side. */ +const ACTION_BOX_OVERHANG = 5; +/** The side-by-side layout: the action menu's label column, and the gap between the details and its box. */ +const SIDE_MENU_WIDTH = 150; +const SIDE_MENU_GAP = 9; type DetailAction = "about" | "whats-new" | "primary"; const ACTIONS: readonly DetailAction[] = ["about", "whats-new", "primary"]; @@ -60,10 +64,15 @@ export class EvenHubStoreDetailLayer implements Layer { paint(ctx: LayerContext): GrayImage { if (!this.detailPromise) void this.ensureDetail(ctx); const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const step = lineStep(font); const actionRowH = listRowHeight(font) + 4; + // The action rows' highlight boxes are the outermost thing drawn toward + // the edges they reach, so they sit at the padding suggested for those + // edges; the details keep to the text column inside the boxes' overhang. + const textX = padding.left + ACTION_BOX_OVERHANG; + const fullTextWidth = Math.max(0, width - padding.left - padding.right - 2 * ACTION_BOX_OVERHANG); const installed = getInstalledEvenHubApp(this.app.packageId); this.primaryLabel = this.working ? "Installing..." : this.primaryActionLabel(installed); @@ -109,26 +118,22 @@ export class EvenHubStoreDetailLayer implements Layer { // Stacked layout (details full-width, actions at the bottom) when it // fits; otherwise the actions become a narrow top-right menu and the // details flow down a left column beside it. - const stackedActionTop = height - 6 - ACTIONS.length * actionRowH; - const stacked = 8 + linesHeight(buildLines(width - X * 2)) + 6 <= stackedActionTop; - const menuW = 150; - const menuX = width - menuW - 12; - const textWidth = stacked ? width - X * 2 : menuX - X - 14; + const stackedActionTop = height - padding.bottom - ACTIONS.length * actionRowH; + const stacked = padding.top + linesHeight(buildLines(fullTextWidth)) + 6 <= stackedActionTop; + const sideBoxWidth = SIDE_MENU_WIDTH + 2 * ACTION_BOX_OVERHANG; + const sideBoxX = width - padding.right - sideBoxWidth; + const textWidth = stacked ? fullTextWidth : Math.max(0, sideBoxX - SIDE_MENU_GAP - textX); - let y = 8; + let y = padding.top; for (const line of buildLines(textWidth)) { - image.drawText(font, X, y, line.text, line.value); + image.drawText(font, textX, y, line.text, line.value); y += step + line.gapAfter; } - const actionX = stacked ? X : menuX; - const actionW = stacked ? textWidth : menuW; - const actionTop = stacked ? stackedActionTop : 8; - this.actions.paint( - image, - { x: actionX - 5, y: actionTop, width: actionW + 10, height: ACTIONS.length * actionRowH - 1 }, - ctx.stack.isFocused(), - ); + const actionBox = stacked + ? { x: padding.left, y: stackedActionTop, width: fullTextWidth + 2 * ACTION_BOX_OVERHANG } + : { x: sideBoxX, y: padding.top, width: sideBoxWidth }; + this.actions.paint(image, { ...actionBox, height: ACTIONS.length * actionRowH - 1 }, ctx.stack.isFocused()); return image; } diff --git a/app/apps/evenhub/store-layer.ts b/app/apps/evenhub/store-layer.ts index bd974dc8..994f7979 100644 --- a/app/apps/evenhub/store-layer.ts +++ b/app/apps/evenhub/store-layer.ts @@ -1,7 +1,7 @@ import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { GrayImage, type UiFont } from "../../graphics/image"; import { truncateText, wrapText } from "../../graphics/textwrap"; -import { GESTURE_CLICK, type InputEvent } from "../../ui/gestures"; +import { directionalFallback, GESTURE_CLICK, isDirectionalInput, type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerActions, type LayerContext, type LayerStack } from "../../ui/layers"; import { drawSelectionHighlight, type MenuItem } from "../../ui/menu"; import { Menu } from "../../ui/menu-core"; @@ -14,14 +14,37 @@ import { EvenHubStoreDetailLayer, type EvenHubStoreDetailOptions } from "./store import { cleanError, installStoreApp } from "./store-install"; import { checkForEvenHubUpdates, describeUpdate, type EvenHubAppUpdate } from "./updates"; import { lineStep } from "../../ui/metrics"; +import type { Viewport } from "../../ui/viewport"; +import { isEvenHubStoreAvailable } from "./glasses-compat"; -const LIST_X = 18; +/** Horizontal inset of a row's text from its highlight box; the header's text lines up with it. */ +const ROW_TEXT_INSET = 6; /** Horizontal gap between tab labels. */ const TAB_GAP = 18; +/** How far a focused tab's highlight box reaches past its label, sideways and above/below. */ +const TAB_HIGHLIGHT_PAD_X = 6; +const TAB_HIGHLIGHT_PAD_Y = 3; +/** Room kept right of the rows for the scrollbar, and the bar's own width. */ +const SCROLLBAR_GUTTER = 6; +const SCROLLBAR_WIDTH = 3; -/** Header: title + tabs line, then the status/subtitle line, then a small gap. */ -function headerHeight(font: UiFont): number { - return 8 + lineStep(font) + font.lineHeight + 6; +/** + * Where the header sits in a viewport. Its text shares a column with the + * rows' text, whose highlight boxes start at the left edge's padding. The + * outermost thing it draws toward the top is a focused tab's highlight box, + * so that box sits at the top edge's padding and the title line follows + * from it. `bottom` is where the header ends: title + tabs line, then the + * status/subtitle line, then a small gap. + */ +function headerLayout(viewport: Viewport, font: UiFont): { textX: number; textWidth: number; titleY: number; bottom: number } { + const { width, padding } = viewport; + const titleY = padding.top + TAB_HIGHLIGHT_PAD_Y; + return { + textX: padding.left + ROW_TEXT_INSET, + textWidth: Math.max(0, width - padding.left - padding.right - 2 * ROW_TEXT_INSET), + titleY, + bottom: titleY + lineStep(font) + font.lineHeight + 6, + }; } /** Row pitch of the two-line app list (title + detail), including the 2px gap between highlights. */ @@ -55,7 +78,32 @@ type StoreRow = /** The Search tab's first row: shows the query and opens the phone editor. */ | { kind: "search-query" } /** A registry entry whose package is gone and which the store no longer lists. */ - | { kind: "orphan"; update: EvenHubAppUpdate }; + | { kind: "orphan"; update: EvenHubAppUpdate } + /** The Updates tab's first row while any update is installable; `busy` while Update All runs. */ + | { kind: "update-all"; count: number; busy: boolean }; + +type AppRow = Extract; + +/** An Updates row that installing the store's version would satisfy. */ +function isUpdatableRow(row: StoreRow): row is AppRow { + return row.kind === "app" && row.update !== undefined; +} + +/** An Updates row for one installed app (not the Update All row). */ +function isInstalledAppRow(row: StoreRow): boolean { + return row.kind === "app" || row.kind === "orphan"; +} + +function rowPackageId(row: StoreRow): string | undefined { + switch (row.kind) { + case "app": + return row.app.packageId; + case "orphan": + return row.update.installed.packageId; + default: + return undefined; + } +} type TabState = { rows: StoreRow[]; @@ -93,8 +141,8 @@ function emptyTab(): TabState { draw: ({ image, item, x, y, width }) => { const font = getDefaultSmallFont(); const { title, detail, titleValue } = rowText(item); - const textX = x + 6; - const textW = width - 12; + const textX = x + ROW_TEXT_INSET; + const textW = width - 2 * ROW_TEXT_INSET; image.drawText(font, textX, y + 2, truncateText(font, title, textW), titleValue); image.drawText(font, textX, y + 2 + lineStep(font), truncateText(font, detail, textW), 115); }, @@ -118,10 +166,18 @@ export type EvenHubStoreLayerOptions = { * The EvenHub storefront: Top (leaderboard), New (by first publication), * Search, and Updates (installed apps that are stale or whose package is * missing). The tab row is its own focus level above the list: double-click - * in the list focuses the tabs, scrolling there switches tabs, and a click - * returns to the list. + * in the list focuses the tabs, scrolling (or a watch swipe in any direction) + * there switches tabs, and a click returns to the list. + * + * With glasses that can't use the store (a RayNeo iO; see glasses-compat.ts) + * it shows only a notice saying so, and loads nothing. That is checked on + * every paint and input, so a window open across a re-pair follows the + * glasses either way. */ export class EvenHubStoreLayer implements Layer { + /** Swipes left/right switch tabs on the tab strip; elsewhere they get the usual fallback. */ + readonly acceptsDirectional = true; + private readonly tabs: Record = { top: emptyTab(), new: emptyTab(), @@ -140,12 +196,15 @@ export class EvenHubStoreLayer implements Layer { private updatingAll = false; /** An app page requested while the login form was up; opened once signed in. */ private pendingPackage: InstalledEvenHubApp | null = null; + /** An app page requested while the store was unavailable, named on its notice. */ + private unavailablePackageName: string | null = null; constructor(private readonly options: EvenHubStoreLayerOptions) { if (this.showingLogin) resetEvenHubLoginForm(); } paint(ctx: LayerContext): GrayImage { + if (!isEvenHubStoreAvailable()) return this.paintUnavailable(ctx); if (!this.started) { this.started = true; // Do NOT open the phone credential editor here. This runs on the first @@ -161,66 +220,93 @@ export class EvenHubStoreLayer implements Layer { } const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const viewport = ctx.stack.getBaseSize(); + const { width, height, padding } = viewport; const image = new GrayImage(width, height, 0); - const headerH = headerHeight(font); - image.drawText(font, LIST_X, 8, "EvenHub", 220); + const { textX, textWidth, titleY, bottom: headerBottom } = headerLayout(viewport, font); + image.drawText(font, textX, titleY, "EvenHub", 220); if (this.showingLogin) { - image.drawText(font, LIST_X, 8 + lineStep(font), truncateText(font, this.loginStatus, width - LIST_X * 2), 125); + image.drawText(font, textX, titleY + lineStep(font), truncateText(font, this.loginStatus, textWidth), 125); const message = this.loginBusy ? "Signing in..." : "Enter your Even account email and password in the phone app."; - for (const [index, line] of wrapText(font, message, width - LIST_X * 2).entries()) { - image.drawText(font, LIST_X, headerH + 16 + index * lineStep(font), line, 190); + for (const [index, line] of wrapText(font, message, textWidth).entries()) { + image.drawText(font, textX, headerBottom + 16 + index * lineStep(font), line, 190); } - image.drawText(font, LIST_X, height - font.lineHeight - 4, `${GESTURE_CLICK} log in`, 105); + image.drawText(font, textX, height - padding.bottom - font.lineHeight, `${GESTURE_CLICK} log in`, 105); return image; } - this.paintTabs(image, font, ctx); + this.paintTabs(image, font, ctx, textX, titleY); const tab = this.tabs[this.activeTab]; const subtitle = tab.status || this.subtitle(this.activeTab, tab); - image.drawText(font, LIST_X, 8 + lineStep(font), truncateText(font, subtitle, width - LIST_X * 2), 125); + image.drawText(font, textX, titleY + lineStep(font), truncateText(font, subtitle, textWidth), 125); if (tab.rows.length === 0) { const message = tab.loading ? "Loading..." : this.emptyMessage(this.activeTab, tab); - for (const [index, line] of wrapText(font, message, width - LIST_X * 2).slice(0, 3).entries()) { - image.drawText(font, LIST_X, headerH + 22 + index * lineStep(font), line, 190); + for (const [index, line] of wrapText(font, message, textWidth).slice(0, 3).entries()) { + image.drawText(font, textX, headerBottom + 22 + index * lineStep(font), line, 190); } return image; } + if (height <= headerBottom) return image; - const rowH = storeRowHeight(font); - const visibleRows = Math.max(1, Math.floor((height - headerH - 4) / rowH)); + // The header stays put, so the list starts right under it with no + // padding of its own there. It scrolls, so it runs to the window's + // bottom edge, the padding suggested for that edge inside it: the last + // row keeps clear of a border there, and a row cut off for scrolling + // meets the edge rather than a blank strip. The scrollbar keeps inside + // the padding, in a gutter the rows leave free. const listFocused = ctx.stack.isFocused() && this.focus === "list"; const menu = tabMenu(tab); + const rowsWidth = Math.max(0, width - padding.left - padding.right - SCROLLBAR_GUTTER); menu.paint( image, - { x: LIST_X - 6, y: headerH, width: width - LIST_X * 2 + 12, height: visibleRows * rowH - 2 }, + { x: padding.left, y: headerBottom, width: rowsWidth, height: height - headerBottom, padTop: 0, padBottom: padding.bottom }, listFocused, ); - menu.drawScrollbar(image, width - 5, headerH, visibleRows * rowH - 3); + menu.drawScrollbar(image, width - padding.right - SCROLLBAR_WIDTH, headerBottom, + Math.max(0, height - padding.bottom - headerBottom)); return image; } - /** Tab labels to the right of the title; the active one is bright and underlined. */ - private paintTabs(image: GrayImage, font: UiFont, ctx: LayerContext): void { + /** The notice that replaces the store when the paired glasses can't use it. */ + private paintUnavailable(ctx: LayerContext): GrayImage { + const font = getDefaultSmallFont(); + const viewport = ctx.stack.getBaseSize(); + const image = new GrayImage(viewport.width, viewport.height, 0); + const { textX, textWidth, titleY, bottom: headerBottom } = headerLayout(viewport, font); + image.drawText(font, textX, titleY, "EvenHub", 220); + if (this.unavailablePackageName) { + const status = `${this.unavailablePackageName}'s package is missing.`; + image.drawText(font, textX, titleY + lineStep(font), truncateText(font, status, textWidth), 125); + } + const message = "Using the Even Realities app store requires Even Realities glasses."; + for (const [index, line] of wrapText(font, message, textWidth).entries()) { + image.drawText(font, textX, headerBottom + 16 + index * lineStep(font), line, 190); + } + return image; + } + + /** Tab labels to the right of the title (at titleX, titleY); the active one is bright and underlined. */ + private paintTabs(image: GrayImage, font: UiFont, ctx: LayerContext, titleX: number, titleY: number): void { const tabsFocused = ctx.stack.isFocused() && this.focus === "tabs"; - let x = LIST_X + font.measureText("EvenHub") + 28; + let x = titleX + font.measureText("EvenHub") + 28; for (const tab of TABS) { const label = this.tabLabel(tab.id); const w = font.measureText(label); const active = tab.id === this.activeTab; if (active) { if (tabsFocused) { - drawSelectionHighlight(image, x - 6, 5, w + 12, font.lineHeight + 6, true, 4); + drawSelectionHighlight(image, x - TAB_HIGHLIGHT_PAD_X, titleY - TAB_HIGHLIGHT_PAD_Y, + w + 2 * TAB_HIGHLIGHT_PAD_X, font.lineHeight + 2 * TAB_HIGHLIGHT_PAD_Y, true, 4); } else { - image.fillRect(x, 8 + font.lineHeight + 1, w, 1, 150); + image.fillRect(x, titleY + font.lineHeight + 1, w, 1, 150); } } - image.drawText(font, x, 8, label, active ? 235 : 120); + image.drawText(font, x, titleY, label, active ? 235 : 120); x += w + TAB_GAP; } } @@ -229,7 +315,7 @@ export class EvenHubStoreLayer implements Layer { const label = TABS.find((entry) => entry.id === tab)!.label; if (tab !== "updates") return label; const updates = this.tabs.updates; - const count = updates.rows.filter((row) => row.kind !== "search-query").length; + const count = updates.rows.filter(isInstalledAppRow).length; return updates.loaded && count > 0 ? `${label} (${count})` : label; } @@ -245,9 +331,11 @@ export class EvenHubStoreLayer implements Layer { if (!state.query) return "Search public apps"; return results === 1 ? `1 result for "${state.query}"` : `${results} results for "${state.query}"`; } - case "updates": + case "updates": { if (!state.loaded) return "Installed apps with newer versions"; - return count === 0 ? "All installed apps are up to date" : count === 1 ? "1 app needs attention" : `${count} apps need attention`; + const apps = state.rows.filter(isInstalledAppRow).length; + return apps === 0 ? "All installed apps are up to date" : apps === 1 ? "1 app needs attention" : `${apps} apps need attention`; + } } } @@ -263,7 +351,14 @@ export class EvenHubStoreLayer implements Layer { } } - async handleInput(event: InputEvent, ctx: LayerContext): Promise { + async handleInput(rawEvent: InputEvent, ctx: LayerContext): Promise { + if (!isEvenHubStoreAvailable()) { + if (directionalFallback(rawEvent).type === "double-click") shell.yieldFocusToSidebar(); + return; + } + const tabSwipe = !this.showingLogin && this.focus === "tabs" + && (rawEvent.type === "swipe-left" || rawEvent.type === "swipe-right"); + const event = isDirectionalInput(rawEvent) && !tabSwipe ? directionalFallback(rawEvent) : rawEvent; if (this.showingLogin) { if (event.type === "click" && !this.loginBusy) { this.openCredentialEditor(ctx); @@ -301,9 +396,11 @@ export class EvenHubStoreLayer implements Layer { const index = TABS.findIndex((tab) => tab.id === this.activeTab); switch (event.type) { case "scroll-up": + case "swipe-left": this.switchTab(ctx, TABS[Math.max(0, index - 1)]!.id); return; case "scroll-down": + case "swipe-right": this.switchTab(ctx, TABS[Math.min(TABS.length - 1, index + 1)]!.id); return; case "click": @@ -333,6 +430,9 @@ export class EvenHubStoreLayer implements Layer { case "search-query": this.openSearchEditor(ctx); return; + case "update-all": + void this.updateAll(ctx); + return; case "orphan": { // Nothing can be reinstalled; the only useful action is to drop the // dead registry entry so the launcher stops offering it. @@ -358,6 +458,12 @@ export class EvenHubStoreLayer implements Layer { * placeholder built from the registry entry stands in. */ showInstalledPackage(stack: LayerStack, installed: InstalledEvenHubApp): void { + if (!isEvenHubStoreAvailable()) { + this.unavailablePackageName = installed.name; + stack.clearToBase(); + return; + } + this.unavailablePackageName = null; if (this.showingLogin) { this.pendingPackage = installed; return; @@ -369,7 +475,7 @@ export class EvenHubStoreLayer implements Layer { /** Dictated text becomes a search (the shell's "Type Into App" / voice input). */ receiveTextInput(text: string, ctx: LayerContext): void { - if (this.showingLogin) return; + if (this.showingLogin || !isEvenHubStoreAvailable()) return; const query = evenHubSearchQuerySetting.set(text); if (!query) return; this.closePhoneEditor(ctx.actions, "search"); @@ -379,7 +485,7 @@ export class EvenHubStoreLayer implements Layer { } buildMenuItems(): MenuItem[] { - if (this.showingLogin) return []; + if (this.showingLogin || !isEvenHubStoreAvailable()) return []; const items: MenuItem[] = []; if (this.activeTab === "search") { items.push({ @@ -532,8 +638,7 @@ export class EvenHubStoreLayer implements Layer { const rows: StoreRow[] = updates.map((update) => update.latest ? { kind: "app", app: update.latest, update } : { kind: "orphan", update }, ); - state.rows = rows; - state.menu.setItems(rows, 0); + this.setUpdateRows(state, rows, 0); state.menu.scrollTop = 0; state.status = ""; state.exhausted = true; @@ -548,10 +653,20 @@ export class EvenHubStoreLayer implements Layer { } } - private updatableRows(): Extract[] { - return this.tabs.updates.rows.filter( - (row): row is Extract => row.kind === "app" && row.update !== undefined, - ); + private updatableRows(): AppRow[] { + return this.tabs.updates.rows.filter(isUpdatableRow); + } + + /** + * Replace the Updates rows, putting an Update All row on top while any of + * them can be installed (and dropping it once none can). + */ + private setUpdateRows(state: TabState, entries: readonly StoreRow[], selectedIndex?: number): void { + const rows = entries.filter(isInstalledAppRow); + const count = rows.filter(isUpdatableRow).length; + if (count > 0) rows.unshift({ kind: "update-all", count, busy: this.updatingAll }); + state.rows = rows; + state.menu.setItems(rows, selectedIndex); } /** Install every pending update in turn; a declined permission dialog skips that app. */ @@ -559,6 +674,7 @@ export class EvenHubStoreLayer implements Layer { if (this.updatingAll) return; this.updatingAll = true; const state = this.tabs.updates; + this.setUpdateRows(state, state.rows); const pending = this.updatableRows(); let installed = 0; const failures: string[] = []; @@ -593,6 +709,7 @@ export class EvenHubStoreLayer implements Layer { : installed === 1 ? "Updated 1 app." : `Updated ${installed} apps.`; } finally { this.updatingAll = false; + this.setUpdateRows(this.tabs.updates, this.tabs.updates.rows); if (!this.closed) ctx.actions.requestRender(); } } @@ -609,10 +726,7 @@ export class EvenHubStoreLayer implements Layer { private removeUpdateRow(packageId: string): void { const state = this.tabs.updates; - state.rows = state.rows.filter((row) => - row.kind === "search-query" ? true : row.kind === "app" ? row.app.packageId !== packageId : row.update.installed.packageId !== packageId, - ); - state.menu.setItems(state.rows); + this.setUpdateRows(state, state.rows.filter((row) => rowPackageId(row) !== packageId)); } // ---- login and phone editors -------------------------------------------- @@ -751,6 +865,14 @@ function rowText(row: StoreRow): { title: string; detail: string; titleValue: nu titleValue: 200, }; } + case "update-all": + return { + title: row.busy ? "Updating..." : "Update All", + detail: row.busy + ? "Installing updates; progress is shown above." + : row.count === 1 ? "Install the 1 available update" : `Install all ${row.count} available updates`, + titleValue: row.busy ? 150 : 230, + }; case "orphan": return { title: row.update.installed.name, diff --git a/app/apps/files/file-browser.ts b/app/apps/files/file-browser.ts index a9470f4d..4657d06c 100644 --- a/app/apps/files/file-browser.ts +++ b/app/apps/files/file-browser.ts @@ -19,13 +19,21 @@ import { import { directionalFallback, type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; -const LIST_X = 20; /** List view: the selection box extends this far left and right of the row text. */ const LIST_HIGHLIGHT_PAD = 6; +/** Header text: how far in from the rows' sides, which lines it up with list-row text. */ +const HEADER_INSET_X = LIST_HIGHLIGHT_PAD; +/** Between the header's title and the path after it. */ +const HEADER_PATH_GAP = 14; +/** Under the header's line, before the rows. */ +const HEADER_GAP = 2; -/** Header: one line holding both the title and the current path. */ -function headerHeight(font: UiFont): number { - return 10 + font.lineHeight; +/** + * Bottom of the header: one line holding both the title and the current + * path, below the padding suggested for the window's top edge. + */ +function headerBottom(font: UiFont, paddingTop: number): number { + return paddingTop + font.lineHeight + HEADER_GAP; } export type FilesViewMode = "icons" | "list"; @@ -147,35 +155,37 @@ export class FileBrowserLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + // The rows (grid bands, list selection boxes) span the window inside the + // padding suggested for its sides. + const rowsX = padding.left; + const rowsWidth = Math.max(0, width - padding.left - padding.right); - image.drawText(font, 20, 8, "Files", 220); + const titleX = rowsX + HEADER_INSET_X; + image.drawText(font, titleX, padding.top, "Files", 220); const pathLabel = this.location === null ? "Places" : this.location; - const pathX = 20 + font.measureText("Files") + 14; - image.drawText(font, pathX, 8, truncateLeft(font, pathLabel, width - pathX - 20), 130); + const pathX = titleX + font.measureText("Files") + HEADER_PATH_GAP; + image.drawText(font, pathX, padding.top, truncateLeft(font, pathLabel, rowsX + rowsWidth - HEADER_INSET_X - pathX), 130); - if (filesViewModeSetting.get() === "list") { - this.paintList(image, font, ctx); + // The header stays put and the rows scroll under it, as far as the + // window's bottom edge: the padding suggested for that edge goes inside + // the scrolled content, so the last row keeps clear of a border there + // and a row cut off for scrolling meets it rather than a blank strip. + const listView = filesViewModeSetting.get() === "list"; + const headerEnd = headerBottom(font, padding.top); + // List row boxes start one pixel above the header's bottom edge. + const top = listView ? headerEnd - 1 : headerEnd; + const box = { x: rowsX, y: top, width: rowsWidth, height: Math.max(0, height - top), padTop: 0, padBottom: padding.bottom }; + if (listView) { + this.listMenu.setItems(this.flatRows()); + this.listMenu.paint(image, box, ctx.stack.isFocused()); } else { - const headerH = headerHeight(font); - this.grid.paint(image, { x: 0, y: headerH, width, height: height - headerH - 6 }, ctx.stack.isFocused()); + this.grid.paint(image, box, ctx.stack.isFocused()); } return image; } - private paintList(image: GrayImage, font: UiFont, ctx: LayerContext): void { - const { width, height } = ctx.stack.getBaseSize(); - const headerH = headerHeight(font); - this.listMenu.setItems(this.flatRows()); - // Row boxes start one pixel above the header's bottom edge. - this.listMenu.paint( - image, - { x: LIST_X - LIST_HIGHLIGHT_PAD, y: headerH - 1, width: width - 2 * LIST_X + 2 * LIST_HIGHLIGHT_PAD, height: height - headerH - 4 }, - ctx.stack.isFocused(), - ); - } - private drawListRow({ image, item, x, y, width, height, selected }: MenuDrawArgs): void { const font = getDefaultSmallFont(); const label = truncateText(font, item.label, width - 2 * LIST_HIGHLIGHT_PAD); diff --git a/app/apps/files/files-app.ts b/app/apps/files/files-app.ts index d8872e58..83abb779 100644 --- a/app/apps/files/files-app.ts +++ b/app/apps/files/files-app.ts @@ -2,6 +2,7 @@ import { readTextFile, type DirectoryEntry } from "../../native/file-access"; import { isFontFile } from "../../native/font-files"; import { installFontFile, isFontInstalled } from "../../graphics/installed-fonts"; import { isDecodableImageFile } from "../../native/image-files"; +import { isMicRecordingFile } from "../../native/mic-recording"; import { isPlayableVideoFile } from "../../native/video-player"; import { readEvenHubPackageManifest } from "../evenhub/installed-apps"; import { EvenHubPermissionDialogLayer } from "../evenhub/permission-dialog"; @@ -38,6 +39,8 @@ export type FilesAppOptions = InProcessAppOptions & { openFontWindow: (title: string, path: string) => void; /** Open a video file's player (settings panel first) as its own shell window. */ openVideoWindow: (title: string, path: string) => void; + /** Replay a recording (.mka) through Transcribe, in a window of its own. */ + openRecordingInTranscribe: (title: string, path: string) => void; }; /** @@ -50,7 +53,7 @@ export function createFilesAppWindow(options: FilesAppOptions): InProcessWindow const browser = new FileBrowserLayer({ isSupportedFile: (name) => TEXT_FILE.test(name) || isFontFile(name) || EHPK_FILE.test(name) || - (!global.isIOS && (isDecodableImageFile(name) || isPlayableVideoFile(name))), + (!global.isIOS && (isDecodableImageFile(name) || isPlayableVideoFile(name) || isMicRecordingFile(name))), // The browser handles double-click itself (up a level), so it is not // wrapped in YieldAtRootLayer; it yields explicitly from the top level. onLeave: () => shell.yieldFocusToSidebar(), @@ -235,6 +238,17 @@ function fileOpenActions(entry: DirectoryEntry, options: FilesAppOptions): FileI }, ]; } + if (isMicRecordingFile(entry.name)) { + return [ + { + label: "Open in Transcribe", + onSelect: (ctx) => { + ctx.stack.pop(); + options.openRecordingInTranscribe(entry.name, entry.path); + }, + }, + ]; + } if (isPlayableVideoFile(entry.name)) { return [ { diff --git a/app/apps/files/font-previewer.ts b/app/apps/files/font-previewer.ts index a486497a..6af93ee9 100644 --- a/app/apps/files/font-previewer.ts +++ b/app/apps/files/font-previewer.ts @@ -5,10 +5,8 @@ import { canLoadFontFile, fontFileDisplayName, fontFileMetrics, renderFontFileTe import { GESTURE_CLICK, GESTURE_DOUBLE_CLICK, GESTURE_SCROLL, gestureHints, type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; -const MARGIN_X = 18; -const TITLE_Y = 8; -const BODY_TOP = 26; -const FOOTER_MARGIN = 20; +/** From the title's top to the first sample's. */ +const TITLE_BAND = 18; const SAMPLE_GAP = 4; const SIZES = [8,9,10,11, 12, 13, 14, 16, 18, 20, 24, 28, 32, 40, 48] as const; @@ -48,36 +46,41 @@ export class FontPreviewerLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const out = new GrayImage(width, height, 0); const size = SIZES[this.sizeIndex]!; const gamma = GAMMAS[this.gammaIndex]!; + // Everything keeps inside the padding suggested for the window's edges: + // the title line at the top, the samples across the width, the hint + // line at the bottom. + const left = padding.left; + const bodyWidth = Math.max(0, width - padding.left - padding.right); + const bodyTop = padding.top + TITLE_BAND; const status = `${size}px γ ${gamma.toFixed(1)}`; const statusWidth = font.measureText(status); - const title = truncateText(font, this.getDisplayName(), width - 2 * MARGIN_X - statusWidth - 12); - out.drawText(font, MARGIN_X, TITLE_Y, title, 220); - out.drawText(font, width - MARGIN_X - statusWidth, TITLE_Y, status, 150); + const title = truncateText(font, this.getDisplayName(), bodyWidth - statusWidth - 12); + out.drawText(font, left, padding.top, title, 220); + out.drawText(font, left + bodyWidth - statusWidth, padding.top, status, 150); if (this.loadable === null) { this.loadable = canLoadFontFile(this.path); } - const footerY = height - FOOTER_MARGIN; + const footerY = height - padding.bottom - font.lineHeight; if (!this.loadable) { - out.drawText(font, MARGIN_X, BODY_TOP + 16, "(could not load font)", 160); - out.drawText(font, MARGIN_X, footerY, gestureHints([[GESTURE_DOUBLE_CLICK, "back"]]), 110); + out.drawText(font, left, bodyTop + 16, "(could not load font)", 160); + out.drawText(font, left, footerY, gestureHints([[GESTURE_DOUBLE_CLICK, "back"]]), 110); return out; } - const bodyWidth = width - 2 * MARGIN_X; - let y = BODY_TOP; + let y = bodyTop; for (const [id, text] of [ ["pangram", PANGRAM], ["charset", CHARSET], ] as const) { const line = this.getCached(id, () => renderFontFileText(this.path, text, size, gamma)); if (!line) continue; - out.bitBlt(line, MARGIN_X, y, { width: bodyWidth }); + out.bitBlt(line, left, y, { width: bodyWidth }); y += line.height + SAMPLE_GAP; } @@ -97,13 +100,13 @@ export class FontPreviewerLayer implements Layer { }), ); if (paragraph) { - out.bitBlt(paragraph, MARGIN_X, y + SAMPLE_GAP); + out.bitBlt(paragraph, left, y + SAMPLE_GAP); } } out.drawText( font, - MARGIN_X, + left, footerY, gestureHints([ [GESTURE_SCROLL, "size"], diff --git a/app/apps/files/image-viewer.ts b/app/apps/files/image-viewer.ts index a6bf3456..f500026f 100644 --- a/app/apps/files/image-viewer.ts +++ b/app/apps/files/image-viewer.ts @@ -5,9 +5,9 @@ import { loadImageFileAsGray, PHOTO_TONE } from "../../native/image-files"; import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; -const MARGIN_X = 18; -const TITLE_Y = 8; -const BODY_TOP = 24; +/** From the title's top to the image area's. */ +const TITLE_BAND = 16; +/** How far the image area keeps from the window's sides and bottom. */ const BODY_MARGIN = 2; /** @@ -19,7 +19,8 @@ const BODY_MARGIN = 2; */ export class ImageViewerLayer implements Layer { private image: GrayImage | null = null; - private loadAttempted = false; + /** The image area ("WxH") the file was last decoded to fit; null before the first load. */ + private fittedTo: string | null = null; constructor( private readonly path: string, @@ -28,24 +29,31 @@ export class ImageViewerLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const out = new GrayImage(width, height, 0); - out.drawText(font, MARGIN_X, TITLE_Y, truncateText(font, this.title, width - 2 * MARGIN_X), 220); + // The title line keeps inside the padding suggested for the window's + // edges; the image fills the rest of the window whatever its edges touch. + out.drawText(font, padding.left, padding.top, truncateText(font, this.title, width - padding.left - padding.right), 220); - const bodyHeight = height - BODY_TOP - BODY_MARGIN; - if (!this.loadAttempted) { - this.loadAttempted = true; - this.image = loadImageFileAsGray(this.path, width - 2 * BODY_MARGIN, bodyHeight, PHOTO_TONE); + const bodyTop = padding.top + TITLE_BAND; + const bodyWidth = width - 2 * BODY_MARGIN; + const bodyHeight = height - bodyTop - BODY_MARGIN; + // The area moves with the window's size and its top padding, so the + // file is decoded again whenever it changes rather than once. + const fit = `${bodyWidth}x${bodyHeight}`; + if (this.fittedTo !== fit) { + this.fittedTo = fit; + this.image = loadImageFileAsGray(this.path, bodyWidth, bodyHeight, PHOTO_TONE); } if (!this.image) { - out.drawText(font, MARGIN_X, BODY_TOP + 16, "(could not load image)", 160); - out.drawText(font, MARGIN_X, height - 16, `${GESTURE_DOUBLE_CLICK} back`, 110); + out.drawText(font, padding.left, bodyTop + 16, "(could not load image)", 160); + out.drawText(font, padding.left, height - padding.bottom - font.lineHeight, `${GESTURE_DOUBLE_CLICK} back`, 110); return out; } out.bitBlt( this.image, Math.round((width - this.image.width) / 2), - BODY_TOP + Math.round((bodyHeight - this.image.height) / 2), + bodyTop + Math.round((bodyHeight - this.image.height) / 2), ); return out; } diff --git a/app/apps/files/index.ts b/app/apps/files/index.ts index 65f9430f..984b51cc 100644 --- a/app/apps/files/index.ts +++ b/app/apps/files/index.ts @@ -14,6 +14,7 @@ import { FILES_WINDOW_ID, } from "./files-app"; import { createVideoPlayerWindow } from "./video-window"; +import { openRecordingInTranscribe } from "../transcribe"; // Document windows are closeable and non-singleton; the serial keeps their // windowIds unique. @@ -91,6 +92,9 @@ const filesApp: AppDefinition = { }, openFontWindow: (title, path) => openFontDocumentWindow(ctx, title, path), openVideoWindow: (title, path) => openVideoWindow(ctx, title, path), + openRecordingInTranscribe: (title, path) => { + openRecordingInTranscribe(ctx, path, title); + }, }), ), // A document arriving via Android's Share intent opens as its own window. diff --git a/app/apps/files/text-viewer.ts b/app/apps/files/text-viewer.ts index 323cd138..906a87d9 100644 --- a/app/apps/files/text-viewer.ts +++ b/app/apps/files/text-viewer.ts @@ -5,11 +5,9 @@ import { GrayImage, type UiFont } from "../../graphics/image"; import { type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; -const MARGIN_X = 18; -const TITLE_Y = 16; -const BODY_X = 18; -const BODY_Y = 44; -const FOOTER_MARGIN = 36; +/** The title: how far right of the body's column, and from its top to the first body line's. */ +const TITLE_INSET_X = 4; +const TITLE_BAND = 28; /** Line step for a bitmap face (the 12px font plus leading, as before). */ const BDF_LINE_STEP = 14; @@ -24,8 +22,11 @@ function lineStepOf(font: UiFont): number { } /** - * Paged text viewer for a document. Sized to its hosting stack (a Files - * document window, or pushed over the file browser for view-in-place). + * Paged text viewer for a document: a title line, the page's lines, and a + * page-number line, all inside the padding suggested for the window's edges + * (the title and page number stay put, so the lines page between them). + * Sized to its hosting stack (a Files document window, or pushed over the + * file browser for view-in-place). */ export class TextViewerLayer implements Layer { private lines: string[] | null = null; @@ -42,20 +43,23 @@ export class TextViewerLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getViewerFont(); const lineStep = lineStepOf(font); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - const footerY = height - FOOTER_MARGIN; - this.bodyLineCount = Math.max(1, Math.floor((footerY - BODY_Y) / lineStep)); - image.drawText(font, MARGIN_X + 4, TITLE_Y, truncateText(font, this.title, width - 2 * MARGIN_X - 8), 220); + const bodyX = padding.left; + const bodyWidth = Math.max(0, width - padding.left - padding.right); + const bodyY = padding.top + TITLE_BAND; + const footerY = height - padding.bottom - font.lineHeight; + this.bodyLineCount = Math.max(1, Math.floor((footerY - bodyY) / lineStep)); + image.drawText(font, bodyX + TITLE_INSET_X, padding.top, truncateText(font, this.title, bodyWidth - 2 * TITLE_INSET_X), 220); - const lines = this.getLines(font, width); + const lines = this.getLines(font, bodyWidth); const visibleLines = lines.slice(this.firstLine, this.firstLine + this.bodyLineCount); for (let index = 0; index < visibleLines.length; index++) { - image.drawText(font, BODY_X, BODY_Y + index * lineStep, visibleLines[index]!, 230); + image.drawText(font, bodyX, bodyY + index * lineStep, visibleLines[index]!, 230); } const currentPage = Math.floor(this.firstLine / this.pageStep()) + 1; - image.drawText(font, BODY_X, footerY, `Page ${currentPage}/${this.totalPageCount(lines.length)}`, 110); + image.drawText(font, bodyX, footerY, `Page ${currentPage}/${this.totalPageCount(lines.length)}`, 110); return image; } @@ -89,14 +93,15 @@ export class TextViewerLayer implements Layer { this.firstLine = Math.max(0, Math.min(maxFirstLine, this.firstLine + delta)); } - private getLines(font: UiFont, width: number): string[] { - if (this.lines === null || this.wrappedForWidth !== width || this.wrappedWithFont !== font.fingerprintId) { + /** The document wrapped to the body column's width; cached per width and font. */ + private getLines(font: UiFont, bodyWidth: number): string[] { + if (this.lines === null || this.wrappedForWidth !== bodyWidth || this.wrappedWithFont !== font.fingerprintId) { const normalized = this.documentText.replace(/\t/g, " ").replace(/\r/g, ""); - this.lines = wrapText(font, normalized, width - BODY_X - 12, { + this.lines = wrapText(font, normalized, bodyWidth, { preserveLeadingWhitespace: true, breakLongWords: true, }); - this.wrappedForWidth = width; + this.wrappedForWidth = bodyWidth; this.wrappedWithFont = font.fingerprintId; } return this.lines; diff --git a/app/apps/files/video-window.ts b/app/apps/files/video-window.ts index 2310e117..7b1d8d09 100644 --- a/app/apps/files/video-window.ts +++ b/app/apps/files/video-window.ts @@ -53,9 +53,11 @@ export const videoMonochromeSetting = new ConfigSettingBoolean({ /** How far one ring scroll seeks. */ const SEEK_STEP_MS = 10_000; -const MARGIN_X = 18; -const TITLE_Y = 10; +/** The settings panel's rows: at most this wide, their text this far inside their selection box. */ const PANEL_WIDTH = 340; +const PANEL_ROW_TEXT_INSET = 10; +/** The panel's title: how far below the window's top padding. */ +const TITLE_OFFSET_Y = 2; /** * One opened video: its probe result, the native player, and the window @@ -202,7 +204,9 @@ type PanelRow = { kind: "size" } | { kind: "audio" } | { kind: "monochrome" } | /** * The pre-play settings panel (the window's root): picture size, audio and * monochrome, all remembered for the next video, then Play (or Resume plus - * Play from start once a position is kept). + * Play from start once a position is kept). The rows' selection boxes start + * at the padding suggested for the window's left edge, and the title and + * the lines under it line up with the rows' text. */ class VideoSettingsLayer implements Layer { private readonly menu = new Menu({ @@ -224,11 +228,16 @@ class VideoSettingsLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - image.drawText(font, MARGIN_X, TITLE_Y, truncateText(font, this.session.title, width - 2 * MARGIN_X), 220); + const rowsX = padding.left; + const available = Math.max(0, width - padding.left - padding.right); + const textX = rowsX + PANEL_ROW_TEXT_INSET; + const textWidth = available - 2 * PANEL_ROW_TEXT_INSET; + const titleY = padding.top + TITLE_OFFSET_Y; + image.drawText(font, textX, titleY, truncateText(font, this.session.title, textWidth), 220); const step = lineStep(font); - let y = TITLE_Y + step; + let y = titleY + step; const info = this.session.info; const errors: string[] = []; @@ -236,12 +245,12 @@ class VideoSettingsLayer implements Layer { if (this.session.error) errors.push(`Playback stopped: ${this.session.error}`); if (info) { const facts = [`${info.width}x${info.height}`, formatMediaTime(info.durationMs), info.hasAudio ? "sound" : "no sound"]; - image.drawText(font, MARGIN_X, y, facts.join(" · "), 130); + image.drawText(font, textX, y, facts.join(" · "), 130); y += step; } for (const error of errors) { - for (const line of wrapText(font, error, width - 2 * MARGIN_X, { breakLongWords: true }).slice(0, 3)) { - image.drawText(font, MARGIN_X, y, line, 200); + for (const line of wrapText(font, error, textWidth, { breakLongWords: true }).slice(0, 3)) { + image.drawText(font, textX, y, line, 200); y += step; } } @@ -253,9 +262,10 @@ class VideoSettingsLayer implements Layer { // Land on Resume/Play by default: the settings usually stay as they were. const playIndex = rows.findIndex((row) => row.kind === "play"); this.menu.setItems(rows, index >= 0 ? index : playIndex >= 0 ? playIndex : undefined); - const panelWidth = Math.min(PANEL_WIDTH, width - 2 * (MARGIN_X - 6)); - this.menu.paint(image, { x: MARGIN_X - 6, y, width: panelWidth, height: Math.max(0, height - y - 4) }, - ctx.stack.isFocused()); + // The rows scroll under the fixed lines above, as far as the window's + // bottom edge, with the padding suggested for that edge inside the list. + this.menu.paint(image, { x: rowsX, y, width: Math.min(PANEL_WIDTH, available), height: Math.max(0, height - y), + padTop: 0, padBottom: padding.bottom }, ctx.stack.isFocused()); return image; } @@ -294,8 +304,8 @@ class VideoSettingsLayer implements Layer { private drawRow({ image, item, x, y, width, selected }: MenuDrawArgs): void { const font = getDefaultSmallFont(); - const textX = x + 10; - const textWidth = width - 20; + const textX = x + PANEL_ROW_TEXT_INSET; + const textWidth = width - 2 * PANEL_ROW_TEXT_INSET; switch (item.kind) { case "size": { const size = videoSizeSetting.get(); diff --git a/app/apps/flappy/flappy-app.worker.ts b/app/apps/flappy/flappy-app.worker.ts index 27fae1c7..6dd2f7d6 100644 --- a/app/apps/flappy/flappy-app.worker.ts +++ b/app/apps/flappy/flappy-app.worker.ts @@ -41,6 +41,7 @@ import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { type MenuItem } from "../../ui/menu"; import { WindowMenu } from "../../ui/window-menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import { directionalFallback, GESTURE_CLICK, @@ -95,6 +96,12 @@ const RENDER_TICK_MS = 30; /** Physics steps per wing frame while flying. */ const WING_STEPS_PER_FRAME = 6; +// --- HUD (pixels below the top line's y) -------------------------------------- +/** The title: a shorter font than the score's, centered on the same line. */ +const HUD_TITLE_DROP = 4; +/** The best score, under the title. */ +const HUD_BEST_DROP = 34; + const SFX_FLAP: Step[] = [{ freq: 880, duty: 40, ms: 20 }, { freq: 1175, duty: 40, ms: 25 }]; const SFX_SCORE: Step[] = [{ freq: 1568, duty: 40, ms: 40 }, { freq: 2093, duty: 40, ms: 60 }]; const SFX_HIT: Step[] = [{ freq: 220, duty: 55, ms: 80 }, { freq: 165, duty: 55, ms: 120 }]; @@ -135,6 +142,13 @@ type FlappyWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there. The playfield fills the + * window whatever its edges touch; only the HUD's top line keeps the + * padding (see paintHud). + */ + viewport: Viewport; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; @@ -198,6 +212,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -225,7 +240,8 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); + window.viewport = message.viewport; + window.menu?.resize(message.viewport); if (window.foreground) renderAndSubmit(window, 0); break; } @@ -289,6 +305,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { break; case "navigation-sensors": case "text-input": + case "key": case "tool-call": break; } @@ -372,7 +389,7 @@ function windowMenu(window: FlappyWindow): WindowMenu { post, title: () => window.title, items: () => windowMenuItems(window), - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: window.viewport, paintBase: () => paintContent(window), isFocused: () => window.focused, }); @@ -712,14 +729,18 @@ function birdWingFrame(window: FlappyWindow): number { function paintHud(image: GrayImage, window: FlappyWindow): void { const width = window.viewportWidth; + // The top line (the score, or the title before the first flap) is the + // only thing here placed from a window edge: it keeps the padding + // suggested for the top, and the best score hangs under it. + const top = window.viewport.padding.top; if (window.phase !== "ready") { - drawCenteredIn(image, largeFont, 0, width, 10, String(window.score), 245); + drawCenteredIn(image, largeFont, 0, width, top, String(window.score), 245); } switch (window.phase) { case "ready": - drawCenteredIn(image, mediumFont, 0, width, 14, "FLAPPY", 245); + drawCenteredIn(image, mediumFont, 0, width, top + HUD_TITLE_DROP, "FLAPPY", 245); if (window.highScore > 0) { - drawCenteredIn(image, smallFont, 0, width, 44, `best ${window.highScore}`, 150); + drawCenteredIn(image, smallFont, 0, width, top + HUD_BEST_DROP, `best ${window.highScore}`, 150); } drawCenteredIn(image, smallFont, 0, width, groundTop(window) - 26, "Touch ring / swipe to flap", 150); break; diff --git a/app/apps/freecell/freecell-app.worker.ts b/app/apps/freecell/freecell-app.worker.ts index bd611a44..5805254d 100644 --- a/app/apps/freecell/freecell-app.worker.ts +++ b/app/apps/freecell/freecell-app.worker.ts @@ -33,6 +33,7 @@ import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { WindowMenu } from "../../ui/window-menu"; import type { MenuItem } from "../../ui/menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import { directionalFallback, GESTURE_CLICK, GESTURE_DOUBLE_CLICK, GESTURE_LONG_PRESS, type InputEvent } from "../../ui/gestures"; declare const global: any; @@ -61,8 +62,16 @@ function isRed(card: number): boolean { const CARD_W = 60; const CARD_H = 36; -const TOP_Y = 4; -const CASCADE_Y = 48; +/** How far outside the card or cascade it marks the cursor's outline is drawn. */ +const CURSOR_OUTSET = 3; +/** Gap between the top row (free cells and foundations) and the cascades. */ +const ROW_GAP = 8; +/** The most of a buried cascade card left showing: enough for its label. */ +const MAX_STRIP = 16; +/** Least column pitch that keeps the cursor's outline round one column off the next column's cards. */ +const MIN_PITCH = CARD_W + CURSOR_OUTSET; +/** Height of the longest cascade of a fresh deal (7 cards) fanned at MAX_STRIP. */ +const DEALT_CASCADE_H = 6 * MAX_STRIP + CARD_H; /** * Cursor locations, in scroll order: free cells 0-3, foundations 0-3 (the @@ -106,6 +115,12 @@ type FreecellWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there, which the board is laid + * out inside (see layoutFor). + */ + viewport: Viewport; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; @@ -155,6 +170,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -210,7 +226,8 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); + window.viewport = message.viewport; + window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; if (window.foreground) renderAndSubmit(window, 0); break; @@ -219,6 +236,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { case "navigation-sensors": case "screen": case "text-input": + case "key": case "tool-call": break; } @@ -286,7 +304,7 @@ function windowMenu(window: FreecellWindow): WindowMenu { post, title: () => window.title, items: () => windowMenuItems(window), - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: window.viewport, paintBase: () => paintContent(window), isFocused: () => window.focused, }); @@ -706,21 +724,67 @@ function checkWin(window: FreecellWindow): void { // Painting type Layout = { + /** Distance between the left edges of neighboring columns. */ pitch: number; + /** Left edge of the first column's cards. */ marginX: number; + /** Top of the free cells and foundations. */ + topY: number; + /** Top of the cascades. */ + cascadeY: number; /** Vertical pixels per buried cascade card (its visible label strip). */ strip: (cascadeLength: number) => number; }; +/** + * The eight columns across a window of the given width, keeping the given + * padding at its left and right edges: spread as far apart as a whole-pixel + * pitch allows, with what is left over split between the two sides. + */ +function columnLayout(width: number, padLeft: number, padRight: number): Pick { + const left = padLeft + CURSOR_OUTSET; + const slack = width - padRight - CURSOR_OUTSET - left - CARD_W; + const pitch = Math.floor(slack / 7); + return { pitch, marginX: left + Math.floor((slack - pitch * 7) / 2) }; +} + +/** + * The two rows down a window of the given height, keeping the given padding + * at its top and bottom edges, and the height that leaves a cascade to fan + * out in. + */ +function rowLayout( + height: number, + padTop: number, + padBottom: number, +): Pick & { cascadeH: number } { + const topY = padTop + CURSOR_OUTSET; + const cascadeY = topY + CARD_H + ROW_GAP; + return { topY, cascadeY, cascadeH: height - padBottom - CURSOR_OUTSET - cascadeY }; +} + +/** + * Lay the board out in the window. The cursor's outline is the outermost + * thing drawn toward every edge (CURSOR_OUTSET outside whatever it marks), so + * it is what sits at the padding suggested for the edge; the columns spread + * across the width inside it, and the cascades fan down the height. A + * window too small for that (the RayNeo iO's) is short of room for the cards + * as it is, so along the axis where they would crowd, they take the + * padding's room too. + */ function layoutFor(window: FreecellWindow): Layout { - const pitch = Math.floor((window.viewportWidth - 12) / 8); - const marginX = Math.floor((window.viewportWidth - (pitch * 8 - (pitch - CARD_W))) / 2); - const available = window.viewportHeight - CASCADE_Y - 2; + const { padding } = window.viewport; + let columns = columnLayout(window.viewportWidth, padding.left, padding.right); + if (columns.pitch < MIN_PITCH) columns = columnLayout(window.viewportWidth, 0, 0); + let rows = rowLayout(window.viewportHeight, padding.top, padding.bottom); + if (rows.cascadeH < DEALT_CASCADE_H) rows = rowLayout(window.viewportHeight, 0, 0); + const { topY, cascadeY, cascadeH } = rows; return { - pitch, - marginX, + ...columns, + topY, + cascadeY, strip: (cascadeLength: number) => - cascadeLength <= 1 ? 0 : Math.min(16, Math.floor((available - CARD_H) / (cascadeLength - 1))), + cascadeLength <= 1 ? 0 : Math.min(MAX_STRIP, Math.floor((cascadeH - CARD_H) / (cascadeLength - 1))), }; } @@ -743,25 +807,26 @@ function paintContent(window: FreecellWindow): GrayImage { const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); const layout = layoutFor(window); const colX = (i: number) => layout.marginX + i * layout.pitch; + const { topY } = layout; // Top row: free cells then foundations, with a divider between the groups. for (let i = 0; i < 4; i++) { const card = window.cells[i]!; if (card === null) { - image.drawRoundedRect(colX(i), TOP_Y, CARD_W, CARD_H, 70, 4); + image.drawRoundedRect(colX(i), topY, CARD_W, CARD_H, 70, 4); } else { - paintCard(image, colX(i), TOP_Y, card, window.selected === LOC_CELL0 + i, true); + paintCard(image, colX(i), topY, card, window.selected === LOC_CELL0 + i, true); } } - image.drawLine(colX(4) - 4, TOP_Y + 4, colX(4) - 4, TOP_Y + CARD_H - 4, 70); + image.drawLine(colX(4) - 4, topY + 4, colX(4) - 4, topY + CARD_H - 4, 70); for (let i = 0; i < 4; i++) { const x = colX(4 + i); const card = window.foundations[i]!; if (card === null) { - image.drawRoundedRect(x, TOP_Y, CARD_W, CARD_H, 70, 4); - image.drawText(labelFont, x + Math.round((CARD_W - labelFont.measureText("A")) / 2), TOP_Y + 10, "A", 70); + image.drawRoundedRect(x, topY, CARD_W, CARD_H, 70, 4); + image.drawText(labelFont, x + Math.round((CARD_W - labelFont.measureText("A")) / 2), topY + 10, "A", 70); } else { - paintCard(image, x, TOP_Y, card, window.selected === LOC_FOUNDATION0 + i, true); + paintCard(image, x, topY, card, window.selected === LOC_FOUNDATION0 + i, true); } } @@ -777,7 +842,7 @@ function paintCascade(image: GrayImage, window: FreecellWindow, layout: Layout, const x = layout.marginX + index * layout.pitch; const cascade = window.cascades[index]!; if (cascade.length === 0) { - image.drawRoundedRect(x, CASCADE_Y, CARD_W, CARD_H, 45, 4); + image.drawRoundedRect(x, layout.cascadeY, CARD_W, CARD_H, 45, 4); return; } const strip = layout.strip(cascade.length); @@ -788,7 +853,7 @@ function paintCascade(image: GrayImage, window: FreecellWindow, layout: Layout, highlightFrom = cascade.length - run; } for (let i = 0; i < cascade.length; i++) { - paintCard(image, x, CASCADE_Y + i * strip, cascade[i]!, i >= highlightFrom, i === cascade.length - 1); + paintCard(image, x, layout.cascadeY + i * strip, cascade[i]!, i >= highlightFrom, i === cascade.length - 1); } } @@ -831,17 +896,18 @@ function paintCursor(image: GrayImage, window: FreecellWindow, layout: Layout): let height: number; if (window.cursor < LOC_CASCADE0) { x = layout.marginX + (window.cursor % 8) * layout.pitch; - y = TOP_Y; + y = layout.topY; height = CARD_H; } else { const index = window.cursor - LOC_CASCADE0; const cascade = window.cascades[index]!; x = layout.marginX + index * layout.pitch; - y = CASCADE_Y; + y = layout.cascadeY; height = cascade.length === 0 ? CARD_H : (cascade.length - 1) * layout.strip(cascade.length) + CARD_H; } - image.drawRect(x - 3, y - 3, CARD_W + 6, height + 6, 255); - image.drawRect(x - 2, y - 2, CARD_W + 4, height + 4, 255); + for (const outset of [CURSOR_OUTSET, CURSOR_OUTSET - 1]) { + image.drawRect(x - outset, y - outset, CARD_W + 2 * outset, height + 2 * outset, 255); + } } function paintWinOverlay(image: GrayImage, window: FreecellWindow): void { diff --git a/app/apps/glanceboard/glanceboard-app.ts b/app/apps/glanceboard/glanceboard-app.ts index 93c1b360..3e7b509f 100644 --- a/app/apps/glanceboard/glanceboard-app.ts +++ b/app/apps/glanceboard/glanceboard-app.ts @@ -19,6 +19,7 @@ import { Menu } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, lineStep, listRowHeight } from "../../ui/metrics"; import { createInProcessWindow, type InProcessAppOptions, type InProcessWindow } from "../../ui/shell/in-process-window"; import { shell } from "../../ui/shell/shell"; +import type { Viewport } from "../../ui/viewport"; import { GlanceBoard } from "./board"; import { glanceFont } from "./glance-font"; import { @@ -44,17 +45,20 @@ import { findGlanceWidget, glanceWidgetSpans } from "./widgets"; export const GLANCEBOARD_WINDOW_ID = "glanceboard"; export const GLANCEBOARD_SURFACE_ID = "window:glanceboard"; -const TITLE_X = 18; -const TITLE_Y = 10; -const PARAGRAPH_X = 24; -/** The entry page splits at the middle: menu left, slot preview right. */ +/** The entry page's title: its drop below the top padding. It lines up with the menu rows' text. */ +const TITLE_OFFSET_Y = 2; +/** Indent of the intro paragraph under the title, and how far short of the middle it wraps. */ +const PARAGRAPH_INDENT = 6; +const PARAGRAPH_RIGHT_GAP = 12; +/** The entry page splits at the middle: menu left, slot preview right, this far from the split. */ const PREVIEW_MARGIN = 8; +/** The preview's outline, drawn just outside the scaled board. */ +const PREVIEW_OUTLINE = 1; const PREVIEW_MIN_LINE_VALUE = 20; const PREVIEW_LINE_VALUE = 100; -/** The entry menu's row boxes: left inset, gap below the paragraph, and inset from the page's bottom. */ -const HOME_MENU_X = 20; +/** The entry menu's row boxes: gap below the paragraph, and how far short of the middle they end. */ const HOME_MENU_TOP_GAP = 12; -const HOME_MENU_BOTTOM_MARGIN = 8; +const HOME_MENU_RIGHT_GAP = 20; /** Horizontal inset of row text (and custom row content) from its selection box. */ const HOME_ROW_TEXT_X = 10; // A throwaway menu to satisfy MenuItem.onSelect's second parameter; the @@ -67,9 +71,7 @@ const INTRO = "long-press-and-hold. It will close automatically."; /** Full-page list layout shared by the sub-screens. */ -function pageMenuLayout(width: number) { - return { x: 8, y: 8, width: width - 16, opaque: true, showBorder: false } as const; -} +const PAGE_MENU_LAYOUT = { page: true } as const; /** * The Glanceboard app's entry page. Left half: title, a short description @@ -78,6 +80,10 @@ function pageMenuLayout(width: number) { * name of the widget in each. "Select Contents" moves focus into that * preview, where scroll picks a slot and a tap opens the picker for it; * a double-tap returns focus to the menu. + * + * The menu's row boxes and the preview's outline sit at the padding + * suggested for the window's edges (viewport.ts). The menu scrolls, so it + * runs to the bottom edge itself, with that edge's padding after its last row. */ class GlanceboardHomeLayer implements Layer { private readonly menu: Menu; @@ -136,17 +142,23 @@ class GlanceboardHomeLayer implements Layer { }); } - /** Where the scaled board sits: the right half, board aspect, vertically centred. */ - private previewRect(width: number, height: number): { x: number; y: number; width: number; height: number } { - const half = (width / 2) | 0; - const availableWidth = width - half - 2 * PREVIEW_MARGIN; + /** + * Where the scaled board sits: board aspect, centred in the right half's + * room inside the window's padding, which its outline may reach. + */ + private previewRect(viewport: Viewport): { x: number; y: number; width: number; height: number } { + const { width, height, padding } = viewport; + const left = ((width / 2) | 0) + PREVIEW_MARGIN; + const top = padding.top + PREVIEW_OUTLINE; + const availableWidth = Math.max(0, width - padding.right - PREVIEW_OUTLINE - left); + const availableHeight = Math.max(0, height - padding.bottom - PREVIEW_OUTLINE - top); const layout = glanceLayout(); - const scale = Math.min(availableWidth / layout.width, (height - 2 * PREVIEW_MARGIN) / layout.height); + const scale = Math.min(availableWidth / layout.width, availableHeight / layout.height); const previewWidth = Math.round(layout.width * scale); const previewHeight = Math.round(layout.height * scale); return { - x: half + PREVIEW_MARGIN + (((availableWidth - previewWidth) / 2) | 0), - y: ((height - previewHeight) / 2) | 0, + x: left + (((availableWidth - previewWidth) / 2) | 0), + y: top + (((availableHeight - previewHeight) / 2) | 0), width: previewWidth, height: previewHeight, }; @@ -154,32 +166,37 @@ class GlanceboardHomeLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const viewport = ctx.stack.getBaseSize(); + const { width, height, padding } = viewport; const image = new GrayImage(width, height, 0); const half = (width / 2) | 0; - image.drawText(font, TITLE_X, TITLE_Y, "Glanceboard", 220); + const menuX = padding.left; + const titleX = menuX + HOME_ROW_TEXT_X; + const titleY = padding.top + TITLE_OFFSET_Y; + image.drawText(font, titleX, titleY, "Glanceboard", 220); const step = lineStep(font); - let y = TITLE_Y + step + 6; - for (const line of wrapText(font, INTRO, half - PARAGRAPH_X - 12)) { - image.drawText(font, PARAGRAPH_X, y, line, 160); + const paragraphX = titleX + PARAGRAPH_INDENT; + let y = titleY + step + 6; + for (const line of wrapText(font, INTRO, half - PARAGRAPH_RIGHT_GAP - paragraphX)) { + image.drawText(font, paragraphX, y, line, 160); y += step; } // The menu sits below the paragraph in the left half. While the preview // has focus the menu keeps its outline-only selection. const menuTop = y + HOME_MENU_TOP_GAP; - const menuWidth = half - 2 * HOME_MENU_X; - const menuHeight = Math.max(0, height - menuTop - HOME_MENU_BOTTOM_MARGIN); + const menuWidth = Math.max(0, half - HOME_MENU_RIGHT_GAP - menuX); + const menuHeight = Math.max(0, height - menuTop); this.paintCtx = ctx; try { - this.menu.paint(image, { x: HOME_MENU_X, y: menuTop, width: menuWidth, height: menuHeight }, + this.menu.paint(image, { x: menuX, y: menuTop, width: menuWidth, height: menuHeight, padBottom: padding.bottom }, ctx.stack.isFocused() && this.focus === "menu"); } finally { this.paintCtx = null; } - this.menu.drawScrollbar(image, HOME_MENU_X + menuWidth + 5, menuTop, menuHeight - 4); + this.menu.drawScrollbar(image, menuX + menuWidth + 5, menuTop, Math.max(0, menuHeight - padding.bottom - 4)); this.selectedSlot = Math.min(this.selectedSlot, glanceLayout().slots.length - 1); - const preview = this.previewRect(width, height); + const preview = this.previewRect(viewport); drawSlotPreview(image, preview, { selectedSlot: this.selectedSlot, selectionFocused: ctx.stack.isFocused() && this.focus === "preview", @@ -249,7 +266,7 @@ function drawSlotPreview( height: Math.round(r.height * sy), }); - image.drawRect(rect.x - 1, rect.y - 1, rect.width + 2, rect.height + 2, 72); + image.drawRect(rect.x - PREVIEW_OUTLINE, rect.y - PREVIEW_OUTLINE, rect.width + 2 * PREVIEW_OUTLINE, rect.height + 2 * PREVIEW_OUTLINE, 72); const selected = scaled(layout.slots[options.selectedSlot]!.rect); drawSelectionHighlight(image, selected.x + 1, selected.y + 1, selected.width - 2, selected.height - 2, options.selectionFocused, 4); @@ -338,7 +355,7 @@ function openGlanceSettings(ctx: LayerContext): void { ]; resetHeadAngleCapture(); headAngleCapture = null; - const layer = new MenuLayer("Glanceboard settings", items(), pageMenuLayout(ctx.stack.getBaseSize().width)); + const layer = new MenuLayer("Glanceboard settings", items(), PAGE_MENU_LAYOUT); ctx.stack.push(layer); } @@ -402,7 +419,7 @@ function widgetSettingsMenuItems(): MenuItem[] { return { label: widget.label, description: `${widget.label} has no settings.`, disabled: true, onSelect: () => {} }; } return submenuItem(widget.label, (ctx) => { - ctx.stack.push(new MenuLayer(`${widget.label} settings`, settingsMenuItems(), pageMenuLayout(ctx.stack.getBaseSize().width))); + ctx.stack.push(new MenuLayer(`${widget.label} settings`, settingsMenuItems(), PAGE_MENU_LAYOUT)); }, { description: `Settings for the ${widget.label} widget.` }); }); } diff --git a/app/apps/glanceboard/glanceboard-settings.ts b/app/apps/glanceboard/glanceboard-settings.ts index 022ab30e..603e395f 100644 --- a/app/apps/glanceboard/glanceboard-settings.ts +++ b/app/apps/glanceboard/glanceboard-settings.ts @@ -1,4 +1,4 @@ -import { ConfigSettingBoolean, ConfigSettingEnum } from "../../ui/dashboard-settings"; +import { ConfigSettingBoolean, ConfigSettingEnum, glassesHaveCompass } from "../../ui/dashboard-settings"; import { QUADRANT_LAYOUT, SIX_SLOT_LAYOUT, slotsVerticallyAdjacent, type GlanceLayout } from "./layout"; import { type GlanceWidgetId } from "./widget"; import { glanceWidgetSpans } from "./widgets"; @@ -23,6 +23,11 @@ export function glanceSlotChoiceLabel(choice: GlanceSlotChoice): string { return SLOT_CHOICE_LABELS[choice] ?? choice; } +/** Whether the paired glasses can drive this widget; if not, it is left out of the slot picker. */ +function slotChoiceAvailable(choice: GlanceSlotChoice): boolean { + return choice !== "compass" || glassesHaveCompass(); +} + /** * Slot order follows QUADRANT_LAYOUT: top left, top right, bottom left, bottom * right. Calendar in both right slots merges into one double-height region. @@ -57,9 +62,28 @@ export const glanceboardEnabledSetting = new ConfigSettingBoolean({ "While the display is asleep, a tap, a long-press or a head-tilt shows the Glanceboard instead of the regular UI. Double-tap still wakes the regular UI.", }); -export type GlanceTapDuration = "off" | "3s" | "5s" | "7s" | "10s"; +const TAP_DURATION_SECONDS = { + "3s": 3, + "5s": 5, + "7s": 7, + "10s": 10, + "20s": 20, + "30s": 30, + "1min": 60, +} as const; -const DEFAULT_TAP_DURATION: GlanceTapDuration = "5s"; +type GlanceTapDurationTimed = keyof typeof TAP_DURATION_SECONDS; +export type GlanceTapDuration = "off" | GlanceTapDurationTimed; + +const TAP_DURATION_VALUES: readonly GlanceTapDuration[] = ["off", ...(Object.keys(TAP_DURATION_SECONDS) as GlanceTapDurationTimed[])]; + +const DEFAULT_TAP_DURATION: GlanceTapDurationTimed = "5s"; + +function formatTapDuration(value: GlanceTapDuration): string { + if (value === "off") return "Disabled"; + const seconds = TAP_DURATION_SECONDS[value]; + return seconds % 60 === 0 ? `${seconds / 60} min` : `${seconds} s`; +} /** * How long a tap keeps the board up; each further tap restarts it. "off" @@ -72,8 +96,8 @@ export const glanceTapDurationSetting = new ConfigSettingEnum label: "Show on tap", storageKey: "glanceboard.tapDuration", defaultValue: DEFAULT_TAP_DURATION, - values: ["off", "3s", "5s", "7s", "10s"], - formatValue: (value) => (value === "off" ? "Disabled" : value.replace("s", " s")), + values: TAP_DURATION_VALUES, + formatValue: formatTapDuration, description: "How long a single tap keeps the Glanceboard on screen. Disabled: a single tap does not show the Glanceboard.", }); @@ -85,8 +109,7 @@ export function glanceShowOnTap(): boolean { export function glanceTapTimeoutMs(): number { const duration = glanceTapDurationSetting.get(); - const seconds = duration === "off" ? DEFAULT_TAP_DURATION : duration; - return Number.parseInt(seconds, 10) * 1000; + return TAP_DURATION_SECONDS[duration === "off" ? DEFAULT_TAP_DURATION : duration] * 1000; } /** A long-press holds the board up until the press is released. */ @@ -204,18 +227,26 @@ export const glanceShowLinesSetting = new ConfigSettingBoolean({ export function glanceSlotSettings(layout: GlanceLayout = glanceLayout()): ConfigSettingEnum[] { const grid = layout === QUADRANT_LAYOUT || layout === SIX_SLOT_LAYOUT; const storageId = grid ? QUADRANT_LAYOUT.id : layout.id; - return layout.slots.map( - (slot, index) => - new ConfigSettingEnum({ - id: `glanceboard-${layout.id}-slot-${index}`, - label: slot.label, - storageKey: `glanceboard.${storageId}.slot.${index}`, - defaultValue: (grid ? DEFAULT_QUADRANT_CHOICES[index] : undefined) ?? "none", - values: SLOT_CHOICES, - formatValue: glanceSlotChoiceLabel, - description: `Which widget fills the ${slot.label.toLowerCase()} slot of the Glanceboard.`, - }), - ); + return layout.slots.map((slot, index) => { + const defaultValue: GlanceSlotChoice = (grid ? DEFAULT_QUADRANT_CHOICES[index] : undefined) ?? "none"; + return new ConfigSettingEnum({ + id: `glanceboard-${layout.id}-slot-${index}`, + label: slot.label, + storageKey: `glanceboard.${storageId}.slot.${index}`, + defaultValue, + values: SLOT_CHOICES.filter(slotChoiceAvailable), + // A stored choice the glasses can't drive reads as Empty, not the slot's + // default (which could put a widget on the board twice). The stored value + // stays, so pairing glasses that can drive it brings it back. + normalize: (value) => { + const choice = value as GlanceSlotChoice; + if (!SLOT_CHOICES.includes(choice)) return defaultValue; + return slotChoiceAvailable(choice) ? choice : "none"; + }, + formatValue: glanceSlotChoiceLabel, + description: `Which widget fills the ${slot.label.toLowerCase()} slot of the Glanceboard.`, + }); + }); } /** diff --git a/app/apps/glanceboard/widgets/system-card.ts b/app/apps/glanceboard/widgets/system-card.ts index 2ef3515a..95cb103a 100644 --- a/app/apps/glanceboard/widgets/system-card.ts +++ b/app/apps/glanceboard/widgets/system-card.ts @@ -11,6 +11,7 @@ import { ensureLocationPermission, hasLocationPermission } from "../../../native import { onAndroidNotificationsChanged, readActiveNotificationIcons } from "../../../native/notification-icons"; import { NOTIFICATION_ICON_SIZE } from "../../../native/notification-types"; import { readPhoneBatteryState } from "../../../native/phone-battery"; +import { voiceControlBridge } from "../../../native/voice-control"; import { weatherBridge } from "../../../native/weather"; import { formatClockDate, formatClockTime } from "../../../ui/clock-format"; import { @@ -18,6 +19,7 @@ import { batteryIndicatorVisible, ConfigSettingBoolean, glassesBatteryVisibilitySetting, + glassesModelName, onAnySettingChanged, phoneBatteryVisibilitySetting, ringBatteryVisibilitySetting, @@ -25,6 +27,7 @@ import { watchBatteryVisibilitySetting, type BatteryIndicatorVisibility, } from "../../../ui/dashboard-settings"; +import { RECORDING_ICON } from "../../../ui/listening-header"; import { type MenuItem } from "../../../ui/menu"; import { shell } from "../../../ui/shell/shell"; import { noteStaleDataUsed, renderPassAllowsStaleData } from "../../../util/render-freshness"; @@ -148,13 +151,16 @@ function requestWeatherLocationAccess(): void { * off, and the layout mirrored either way, in the card's submenu of * Glanceboard > Settings. Battery style and per-device visibility follow * Settings > Customization > Battery indicators, so the card agrees with - * the bar. Countdowns tick once a second only while one is running. + * the bar. Countdowns tick once a second only while one is running. While + * Transcribe or Translate is saving the mic's audio (their Save Recording), + * the recording circle sits under the batteries and weather. */ export class SystemCardWidget implements GlanceWidget { private requestRender: (() => void) | null = null; private minuteTimer: ReturnType | null = null; private secondTimer: ReturnType | null = null; private unsubscribeNotifications: (() => void) | null = null; + private unsubscribeRecording: (() => void) | null = null; private unsubscribeSettings: (() => void) | null = null; private unsubscribeTimers: (() => void) | null = null; private unsubscribeWeather: (() => void) | null = null; @@ -163,6 +169,7 @@ export class SystemCardWidget implements GlanceWidget { this.requestRender = requestRender; this.scheduleMinuteTick(); this.unsubscribeNotifications = onAndroidNotificationsChanged(() => this.requestRender?.()); + this.unsubscribeRecording = voiceControlBridge.onRecordingChange(() => this.requestRender?.()); this.unsubscribeSettings = onAnySettingChanged(() => this.requestRender?.()); this.unsubscribeTimers = timerEngine.onChange(() => { this.syncSecondTick(); @@ -181,6 +188,8 @@ export class SystemCardWidget implements GlanceWidget { this.secondTimer = null; this.unsubscribeNotifications?.(); this.unsubscribeNotifications = null; + this.unsubscribeRecording?.(); + this.unsubscribeRecording = null; this.unsubscribeSettings?.(); this.unsubscribeSettings = null; this.unsubscribeTimers?.(); @@ -236,6 +245,8 @@ export class SystemCardWidget implements GlanceWidget { if (batteryItems.length) sideBlocks.push(batteryBlock(small, batteryItems)); const weather = weatherShowOnSystemCardSetting.get() ? weatherBlock(medium, now.getTime()) : null; if (weather) sideBlocks.push(weather); + // Last, so it comes and goes without moving the others. + if (voiceControlBridge.recording) sideBlocks.push(RECORDING_BLOCK); const side: Rect[] = []; let sideOffset = PAD; for (const block of sideBlocks) { @@ -328,7 +339,7 @@ function collectBatteryItems(): BatteryItem[] { push(phoneBatteryVisibilitySetting.get(), "Phone", "phone", phone.battery, phone.charging); const levels = shell.getBatteryLevels(); push(watchBatteryVisibilitySetting.get(), "Watch", "watch", levels.watch, levels.watchCharging); - push(glassesBatteryVisibilitySetting.get(), "G2", "glasses", levels.headset, levels.headsetCharging); + push(glassesBatteryVisibilitySetting.get(), glassesModelName(), "glasses", levels.headset, levels.headsetCharging); if (levels.ring !== null && Number.isInteger(levels.ring) && levels.ring >= 0 && levels.ring <= 100) { push(ringBatteryVisibilitySetting.get(), "R1", "ring", levels.ring, levels.ringCharging); } @@ -381,6 +392,13 @@ function batteryBlock(font: UiFont, items: readonly BatteryItem[]): SideBlock { }; } +/** The recording circle: the mic's audio is being saved (see RECORDING_ICON). */ +const RECORDING_BLOCK: SideBlock = { + width: RECORDING_ICON.width, + height: RECORDING_ICON.height, + draw: (image, left, top) => image.drawImage(RECORDING_ICON, left, top), +}; + /** The current weather's condition icon and temperature, or null without a fresh reading. */ function weatherBlock(font: UiFont, nowMs: number): SideBlock | null { const reading = weatherReading(weatherBridge.snapshot(), nowMs); diff --git a/app/apps/health/health-app.ts b/app/apps/health/health-app.ts index cfea5e21..f8c076f9 100644 --- a/app/apps/health/health-app.ts +++ b/app/apps/health/health-app.ts @@ -123,11 +123,12 @@ class HealthLayer implements Layer { } paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + // The pages lay out inside the padding suggested for the window's edges. + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); drawGlancePage( image, - { width, height }, + { width, height, padding }, { small: getDefaultSmallFont(), large: getDefaultLargeFont() }, GLANCE_PAGES[this.pageIndex] ?? GLANCE_PAGES[0]!, { diff --git a/app/apps/launcher/index.ts b/app/apps/launcher/index.ts index 1c16f4b9..40448347 100644 --- a/app/apps/launcher/index.ts +++ b/app/apps/launcher/index.ts @@ -11,7 +11,7 @@ import { export function launcherEntries(apps: readonly AppDefinition[]) { return [ ...apps - .filter((app) => app.showInLauncher !== false) + .filter((app) => app.showInLauncher !== false && app.isSupported?.() !== false) .map((app) => ({ appId: app.appId, label: app.title, diff --git a/app/apps/launcher/launcher-app.ts b/app/apps/launcher/launcher-app.ts index d7cf2ccf..ad592ff6 100644 --- a/app/apps/launcher/launcher-app.ts +++ b/app/apps/launcher/launcher-app.ts @@ -4,7 +4,7 @@ import { GrayImage } from "../../graphics/image"; import { type Plane } from "../../graphics/plane"; import { renderIcon, type IconName } from "../../graphics/icons"; import { InputEvent } from "../../ui/gestures"; -import { IconGrid, ICON_GRID_BAND_INSET_X, ICON_GRID_HIGHLIGHT_INSET_Y, ICON_GRID_ICON_SIZE } from "../../ui/icon-grid"; +import { IconGrid, ICON_GRID_ICON_SIZE } from "../../ui/icon-grid"; import { Layer, LayerActions, LayerContext } from "../../ui/layers"; import { MenuLayer, type MenuItem } from "../../ui/menu"; import { WINDOW_MENU_LAYOUT } from "../../ui/window-menu"; @@ -43,12 +43,9 @@ export type LauncherOptions = { export const LAUNCHER_WINDOW_ID = "launcher"; export const LAUNCHER_SURFACE_ID = "window:launcher"; -const GRID_TOP = 6; -/** - * The root grid's top: its first row's highlight band then sits as far - * below the window's top edge as it is from the side edges. - */ -const ROOT_GRID_TOP = ICON_GRID_BAND_INSET_X - ICON_GRID_HIGHLIGHT_INSET_Y; +/** A folder's name, above its grid: how far in from the grid's side, and the gap under it. */ +const FOLDER_NAME_INSET_X = 4; +const FOLDER_NAME_GAP = 6; /** One cell of the grid: an app, or a folder holding some of the apps. */ type LauncherGridEntry = @@ -260,16 +257,25 @@ class LauncherGridLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - // The folder-name header band scales with the font. - const gridTop = this.currentFolder !== null ? GRID_TOP + font.lineHeight + 4 : ROOT_GRID_TOP; + const gridX = padding.left; + const gridWidth = width - padding.left - padding.right; + // The grid scrolls, so it runs to the window's top and bottom edges, the + // padding suggested for them inside it: its end rows keep clear of a + // border there, and a row cut off for scrolling meets the border rather + // than a blank strip. A folder's name stays put above its grid instead, + // in a band that scales with the font. + let gridTop = 0; + let padTop = padding.top; if (this.currentFolder !== null) { - image.drawText(font, 8, GRID_TOP - 2, truncateText(font, this.currentFolder, width - 16), 160); + const nameX = gridX + FOLDER_NAME_INSET_X; + image.drawText(font, nameX, padding.top, truncateText(font, this.currentFolder, gridWidth - 2 * FOLDER_NAME_INSET_X), 160); + gridTop = padding.top + font.lineHeight + FOLDER_NAME_GAP; + padTop = 0; } - // The grid runs to the window's bottom edge, so a row cut off there for - // scrolling meets the window's border rather than a blank strip. - this.grid.paint(image, { x: 0, y: gridTop, width, height: height - gridTop }, ctx.stack.isFocused()); + this.grid.paint(image, { x: gridX, y: gridTop, width: gridWidth, height: height - gridTop, padTop, padBottom: padding.bottom }, + ctx.stack.isFocused()); return image; } diff --git a/app/apps/microphones/captions-layer.ts b/app/apps/microphones/captions-layer.ts index 01d87f54..e4a2e8e2 100644 --- a/app/apps/microphones/captions-layer.ts +++ b/app/apps/microphones/captions-layer.ts @@ -5,11 +5,19 @@ import { GESTURE_DOUBLE_CLICK, GESTURE_SCROLL, type InputEvent } from "../../ui/ import { Layer, type LayerContext } from "../../ui/layers"; import { micSession, type CaptionLine, type MicSessionState } from "./mic-session"; +/** From the title's top to the first caption row. */ +const BODY_TOP_OFFSET = 20; +/** Indent of the caption rows under the title. */ +const ROW_INDENT = 4; + /** * On-glasses captions: each line is prefixed with the speaker's name (their * id until tagged); foreign-language lines show the translation directly * beneath the recognized original. Scroll reviews recent lines; the view * snaps back to live on new speech. + * + * The title and the hint line stay put, at the padding suggested for the + * window's top and bottom edges; the caption rows scroll between the two. */ export class CaptionsLayer implements Layer { private state: MicSessionState = micSession.getState(); @@ -33,19 +41,21 @@ export class CaptionsLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const state = this.state; + const left = padding.left; + const rowX = left + ROW_INDENT; + const bodyTop = padding.top + BODY_TOP_OFFSET; - image.drawText(font, 12, 4, "Captions", 220); + image.drawText(font, left, padding.top, "Captions", 220); if (!state.captionsActive) { - image.drawText(font, 12, 26, state.captionsNote, 130); + image.drawText(font, left, bodyTop + 2, state.captionsNote, 130); } - const rows = this.buildRows(font, width - 36, state.captionLines); + const rows = this.buildRows(font, Math.max(0, width - padding.right - rowX), state.captionLines); const step = lineStep(font) + 1; - const bodyTop = 24; - const footerY = height - font.lineHeight - 4; + const footerY = height - padding.bottom - font.lineHeight; const visibleRows = Math.max(1, Math.floor((footerY - bodyTop) / step)); const maxScrollback = Math.max(0, rows.length - visibleRows); this.scrollback = Math.min(this.scrollback, maxScrollback); @@ -54,16 +64,16 @@ export class CaptionsLayer implements Layer { const row = rows[index]!; const y = bodyTop + (index - firstRow) * step; if (row.prefix) { - image.drawText(font, 16, y, row.prefix, row.prefixValue); - image.drawText(font, 16 + font.measureText(row.prefix), y, row.text, row.value); + image.drawText(font, rowX, y, row.prefix, row.prefixValue); + image.drawText(font, rowX + font.measureText(row.prefix), y, row.text, row.value); } else { - image.drawText(font, 16 + row.indent, y, row.text, row.value); + image.drawText(font, rowX + row.indent, y, row.text, row.value); } } image.drawText( font, - 12, + left, footerY, `${GESTURE_SCROLL} history ${GESTURE_DOUBLE_CLICK} back` + (this.scrollback > 0 ? ` (${this.scrollback} back)` : ""), diff --git a/app/apps/microphones/levels-layer.ts b/app/apps/microphones/levels-layer.ts index 5f37c974..c35caca8 100644 --- a/app/apps/microphones/levels-layer.ts +++ b/app/apps/microphones/levels-layer.ts @@ -4,6 +4,12 @@ import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures"; import { Layer, type LayerContext } from "../../ui/layers"; import { micSession, type MicSessionState } from "./mic-session"; +/** From the title's top to the status line, and to the first meter row. */ +const STATUS_OFFSET_Y = 18; +const METERS_OFFSET_Y = 42; +/** Width of the mic-name column left of the meters. */ +const LABEL_COLUMN_WIDTH = 118; + /** * Live level meters, one per active microphone (a single mixed channel on * stock firmware; up to four mics with the mic-control firmware), plus the @@ -22,24 +28,27 @@ export class LevelsLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const state = this.state; + // Text starts at the padding suggested for the window's left edge, and + // the meters run to the right edge's. + const left = padding.left; - image.drawText(font, 12, 6, "Microphone Levels", 220); - image.drawText(font, 12, 24, state.statusText, 110); + image.drawText(font, left, padding.top, "Microphone Levels", 220); + image.drawText(font, left, padding.top + STATUS_OFFSET_Y, state.statusText, 110); - const barX = 130; - const barWidth = width - barX - 40; + const barX = left + LABEL_COLUMN_WIDTH; + const barWidth = Math.max(0, width - padding.right - barX); const rowHeight = 26; - let y = 48; + let y = padding.top + METERS_OFFSET_Y; const labels = state.levelLabels.length ? state.levelLabels : ["Glasses mic"]; labels.forEach((label, index) => { const level = state.levels[index] ?? 0; const enabled = state.levelsEnabled[index] ?? true; - image.drawText(font, 12, y + 3, enabled ? label : `${label} (off)`, enabled ? 190 : 90); + image.drawText(font, left, y + 3, enabled ? label : `${label} (off)`, enabled ? 190 : 90); image.drawRect(barX, y, barWidth, 16, enabled ? 70 : 40); - const fill = Math.round((barWidth - 4) * level); + const fill = Math.round(Math.max(0, barWidth - 4) * level); if (fill > 0) { // A disabled mic still meters (dimly) so its signal can be checked // before switching it back on. @@ -55,15 +64,15 @@ export class LevelsLayer implements Layer { y += 6; if (state.doaDeviceDeg !== null) { - image.drawText(font, 12, y, `Direction of arrival: ${Math.round(state.doaDeviceDeg)}°`, 160); + image.drawText(font, left, y, `Direction of arrival: ${Math.round(state.doaDeviceDeg)}°`, 160); y += 18; } - image.drawText(font, 12, y, `Signal-strength ratio: ${state.ssr}`, 130); + image.drawText(font, left, y, `Signal-strength ratio: ${state.ssr}`, 130); y += 18; const ancText = state.ancOn && state.ancEngine ? `on — ${state.ancEngine}` : "off"; - image.drawText(font, 12, y, `Noise cancellation: ${ancText}`, 130); + image.drawText(font, left, y, `Noise cancellation: ${ancText}`, 130); - image.drawText(font, 12, height - font.lineHeight - 4, `${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(font, left, height - padding.bottom - font.lineHeight, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } diff --git a/app/apps/microphones/mic-control.ts b/app/apps/microphones/mic-control.ts index 6f62b3ad..ddc4a75d 100644 --- a/app/apps/microphones/mic-control.ts +++ b/app/apps/microphones/mic-control.ts @@ -56,6 +56,27 @@ export function saveMicConfig(config: MicConfig): void { setStringSetting(CONFIG_SETTING_KEY, JSON.stringify(config)); } +/** + * The configuration a capture of the temples' own microphones arms them + * with: `mics` of 2 is one microphone per temple (the front one), 4 is both + * of each. The front end and direction detection follow Microphone setup + * (the Microphones app), except that both of a temple's microphones only + * come through the codec front end. Always raw PCM16 at 16 kHz, which is + * what the firmware streams and transcription takes. + */ +export function micArrayCaptureConfig(mics: 2 | 4): MicConfig { + const base = loadMicConfig(); + return { + ...base, + source: mics === 4 ? "codec" : base.source, + channelMask: mics === 4 ? 0b11 : 0b01, + codec: "raw", + format: "pcm16", + sampleRateHz: 16_000, + armHardware: true, + }; +} + class MicArrayController { private readonly statusListeners = new Set<(statuses: MicArrayStatuses) => void>(); private statuses: MicArrayStatuses = { left: null, right: null }; diff --git a/app/apps/microphones/microphones-app.ts b/app/apps/microphones/microphones-app.ts index a520da1d..8accbefb 100644 --- a/app/apps/microphones/microphones-app.ts +++ b/app/apps/microphones/microphones-app.ts @@ -1,6 +1,5 @@ import { imageFromAsciiArt } from "../../graphics/image"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; -import { appViewportSize } from "../../ui/shell/geometry"; import { MenuLayer, TextPageLayer, @@ -62,15 +61,7 @@ const TRAY_ICON = imageFromAsciiArt( { "#": 220 }, ); -const MENU_LAYOUT = { - x: 8, - y: 8, - width: 292, - showBorder: false, - minHeight: 0, - maxHeight: appViewportSize("min").height - 16, - opaque: true, -}; +const MENU_LAYOUT = { page: true, width: 268 } as const; /** Persist a config change; the running session applies it live. */ function updateMicConfig(mutate: (config: MicConfig) => MicConfig): void { diff --git a/app/apps/microphones/radar-layer.ts b/app/apps/microphones/radar-layer.ts index ff986c51..34527ae2 100644 --- a/app/apps/microphones/radar-layer.ts +++ b/app/apps/microphones/radar-layer.ts @@ -5,6 +5,16 @@ import { Layer, type LayerContext } from "../../ui/layers"; import { micSession, type MicSessionState } from "./mic-session"; import { dotBrightness } from "./radar-dots"; +/** Room above the plot's ring for its "front" label. */ +const FRONT_LABEL_BAND = 14; +/** Gap between the ring and the hint line under it. */ +const RING_FOOTER_GAP = 10; +/** The least the ring keeps clear of the window's sides, which leaves the readout panel its corner. */ +const RING_SIDE_CLEARANCE = 90; +/** The readout panel: the least its column is wide, and its drop below the title's top. */ +const PANEL_MIN_WIDTH = 104; +const PANEL_OFFSET_Y = 20; + /** * The Sonic Radar: a top-down view around the wearer's head. The shaded * wedge is the listening beam (scroll rotates it, click locks it onto the @@ -14,6 +24,10 @@ import { dotBrightness } from "./radar-dots"; * scene is world-anchored (an N tick marks north and dots stay put as the * head turns); dots glow full-bright while their speaker is talking and fade * with the time since they last spoke. + * + * The plot is centred on the window, between the title row and the hint + * line; those and the readout panel keep to the padding suggested for the + * window's edges. */ export class RadarLayer implements Layer { private state: MicSessionState = micSession.getState(); @@ -28,17 +42,20 @@ export class RadarLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const state = this.state; + const footerY = height - padding.bottom - font.lineHeight; + const ringTop = padding.top + FRONT_LABEL_BAND; + const ringBottom = footerY - RING_FOOTER_GAP; const centerX = (width / 2) | 0; - const centerY = ((height - 24) / 2 + 6) | 0; - const radius = Math.min(centerX - 90, ((height - 40) / 2) | 0); + const centerY = ((ringTop + ringBottom) / 2) | 0; + const radius = Math.max(0, Math.min(centerX - RING_SIDE_CLEARANCE, ((ringBottom - ringTop) / 2) | 0)); - image.drawText(font, 12, 6, "Sonic Radar", 220); + image.drawText(font, padding.left, padding.top, "Sonic Radar", 220); const modeText = state.mode === "extended" ? "4-mic array" : "firmware DoA"; - image.drawText(font, width - font.measureText(modeText) - 12, 6, modeText, 110); + image.drawText(font, width - padding.right - font.measureText(modeText), padding.top, modeText, 110); // Beam wedge (device frame; the head is the reference for display). const beamDeviceDeg = this.deviceBeamDeg(state); @@ -70,7 +87,7 @@ export class RadarLayer implements Layer { // Radar rings. drawCircle(image, centerX, centerY, radius, 60); drawCircle(image, centerX, centerY, (radius / 2) | 0, 30); - image.drawText(font, centerX - (font.measureText("front") / 2) | 0, centerY - radius - 14, "front", 90); + image.drawText(font, centerX - (font.measureText("front") / 2) | 0, centerY - radius - FRONT_LABEL_BAND, "front", 90); // Compass north tick: anchors the world frame visually as the head turns. if (state.headingDeg !== null) { @@ -127,37 +144,31 @@ export class RadarLayer implements Layer { } const label = dot.name; const labelValue = Math.max(90, value - 50); - const labelX = dotX + 8 + font.measureText(label) > width ? dotX - font.measureText(label) - 8 : dotX + 8; + const labelX = dotX + 8 + font.measureText(label) > width - padding.right ? dotX - font.measureText(label) - 8 : dotX + 8; image.drawText(font, labelX, dotY - 6, label, labelValue); } - // Side panel: beam + level readouts. - const panelX = width - 116; - let panelY = 26; - image.drawText( - font, - panelX, - panelY, - state.headingDeg !== null ? `Heading ${Math.round(state.headingDeg)}°` : "No compass", - state.headingDeg !== null ? 150 : 90, - ); - panelY += 16; - image.drawText(font, panelX, panelY, `Beam ${Math.round(state.beamWorldDeg)}°`, 170); - panelY += 16; - image.drawText(font, panelX, panelY, `Width ${Math.round(state.beamWidthDeg)}°`, 130); - panelY += 16; - image.drawText(font, panelX, panelY, state.beamLocked ? "Locked on talker" : "Manual aim", 130); - panelY += 16; - if (state.doaDeviceDeg !== null) { - image.drawText(font, panelX, panelY, `Heard ${Math.round(state.doaDeviceDeg)}°`, 200); + // Side panel: beam + level readouts, in a column that ends at the right + // edge's padding and is wide enough for its longest line. + const panelLines: Array<[text: string, value: number]> = [ + state.headingDeg !== null ? [`Heading ${Math.round(state.headingDeg)}°`, 150] : ["No compass", 90], + [`Beam ${Math.round(state.beamWorldDeg)}°`, 170], + [`Width ${Math.round(state.beamWidthDeg)}°`, 130], + [state.beamLocked ? "Locked on talker" : "Manual aim", 130], + ]; + if (state.doaDeviceDeg !== null) panelLines.push([`Heard ${Math.round(state.doaDeviceDeg)}°`, 200]); + panelLines.push([state.beamFilterOn ? "Filter: beam only" : "Filter: off", 130]); + const panelWidth = Math.max(PANEL_MIN_WIDTH, ...panelLines.map(([text]) => Math.ceil(font.measureText(text)))); + const panelX = width - padding.right - panelWidth; + let panelY = padding.top + PANEL_OFFSET_Y; + for (const [text, value] of panelLines) { + image.drawText(font, panelX, panelY, text, value); panelY += 16; } - image.drawText(font, panelX, panelY, state.beamFilterOn ? "Filter: beam only" : "Filter: off", 130); - const footerY = height - font.lineHeight - 4; image.drawText( font, - 12, + padding.left, footerY, `${GESTURE_SCROLL} aim ${GESTURE_CLICK} lock ${GESTURE_DOUBLE_CLICK} back`, 110, diff --git a/app/apps/minesweeper/minesweeper-app.worker.ts b/app/apps/minesweeper/minesweeper-app.worker.ts index 3cd49ee9..89629bfe 100644 --- a/app/apps/minesweeper/minesweeper-app.worker.ts +++ b/app/apps/minesweeper/minesweeper-app.worker.ts @@ -33,6 +33,7 @@ import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { type MenuItem } from "../../ui/menu"; import { WindowMenu } from "../../ui/window-menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import { directionalFallback, GESTURE_CLICK, @@ -53,9 +54,10 @@ const smallFont = getDefaultSmallFont(); const COLS = 12; const ROWS = 9; const CELL = 26; -const BOARD_X = 14; -const BOARD_Y = 14; -const PANEL_X = BOARD_X + COLS * CELL + 28; +/** How far outside its cells the board's frame is drawn. */ +const BOARD_FRAME = 2; +/** Gap between the board's cells and the panel to their right. */ +const PANEL_GAP = 28; const DIFFICULTIES = [ { name: "Easy", mines: 14 }, @@ -107,6 +109,12 @@ type MinesweeperWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there, which places the board + * (see boardOrigin). + */ + viewport: Viewport; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; @@ -166,6 +174,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -255,13 +264,15 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); + window.viewport = message.viewport; + window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; if (window.foreground) renderAndSubmit(window, 0); break; } case "navigation-sensors": case "text-input": + case "key": case "tool-call": break; } @@ -352,7 +363,7 @@ function windowMenu(window: MinesweeperWindow): WindowMenu { title: () => window.title, items: () => windowMenuItems(window), claimsLongPress: () => window.phase === "playing", - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: window.viewport, paintBase: () => paintContent(window), isFocused: () => window.focused, }); @@ -666,46 +677,67 @@ function paint(window: MinesweeperWindow): Plane[] { return windowMenu(window).paint(); } +/** Top-left corner of the board's cells, in viewport coordinates. */ +type BoardOrigin = { x: number; y: number }; + +/** + * Where the board goes: its frame, the outermost thing drawn toward the + * window's top and left edges, sits at the padding suggested for them. The + * board is a fixed size and the panel hangs off its right side, so the whole + * layout moves with it and nothing is placed from the other two edges. + */ +function boardOrigin(window: MinesweeperWindow): BoardOrigin { + const { padding } = window.viewport; + return { x: padding.left + BOARD_FRAME, y: padding.top + BOARD_FRAME }; +} + function paintContent(window: MinesweeperWindow): GrayImage { const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); - image.drawRect(BOARD_X - 2, BOARD_Y - 2, COLS * CELL + 4, ROWS * CELL + 4, 120); + const board = boardOrigin(window); + image.drawRect( + board.x - BOARD_FRAME, + board.y - BOARD_FRAME, + COLS * CELL + 2 * BOARD_FRAME, + ROWS * CELL + 2 * BOARD_FRAME, + 120, + ); if (window.phase === "paused") { // Hide the board so pausing can't be used to study it off the clock. - drawCenteredIn(image, mediumFont, BOARD_X, COLS * CELL, BOARD_Y + 80, "PAUSED", 230); - drawCenteredIn(image, smallFont, BOARD_X, COLS * CELL, BOARD_Y + 120, `${GESTURE_CLICK} resume`, 150); - drawCenteredIn(image, smallFont, BOARD_X, COLS * CELL, BOARD_Y + 140, `${GESTURE_DOUBLE_CLICK} leave`, 150); + drawCenteredIn(image, mediumFont, board.x, COLS * CELL, board.y + 80, "PAUSED", 230); + drawCenteredIn(image, smallFont, board.x, COLS * CELL, board.y + 120, `${GESTURE_CLICK} resume`, 150); + drawCenteredIn(image, smallFont, board.x, COLS * CELL, board.y + 140, `${GESTURE_DOUBLE_CLICK} leave`, 150); } else { - paintBoard(image, window); + paintBoard(image, window, board); } - paintPanel(image, window); + paintPanel(image, window, board); return image; } -function paintBoard(image: GrayImage, window: MinesweeperWindow): void { +function paintBoard(image: GrayImage, window: MinesweeperWindow, board: BoardOrigin): void { for (let y = 0; y < ROWS; y++) { for (let x = 0; x < COLS; x++) { - paintCell(image, window, x, y); + paintCell(image, window, board, x, y); } } // Cursor: a double bright outline so it stays visible over any cell. In // row-select it spans the whole selected row; in column-select it marks the // cell (games over show neither). if (window.phase !== "playing") return; - const cx = BOARD_X + window.cursorX * CELL; - const cy = BOARD_Y + window.cursorY * CELL; + const cx = board.x + window.cursorX * CELL; + const cy = board.y + window.cursorY * CELL; if (window.selectMode === "row") { - image.drawRect(BOARD_X - 1, cy - 1, COLS * CELL + 1, CELL + 1, 255); - image.drawRect(BOARD_X, cy, COLS * CELL - 1, CELL - 1, 255); + image.drawRect(board.x - 1, cy - 1, COLS * CELL + 1, CELL + 1, 255); + image.drawRect(board.x, cy, COLS * CELL - 1, CELL - 1, 255); } else { image.drawRect(cx - 1, cy - 1, CELL + 1, CELL + 1, 255); image.drawRect(cx, cy, CELL - 1, CELL - 1, 255); } } -function paintCell(image: GrayImage, window: MinesweeperWindow, x: number, y: number): void { +function paintCell(image: GrayImage, window: MinesweeperWindow, board: BoardOrigin, x: number, y: number): void { const index = y * COLS + x; - const cx = BOARD_X + x * CELL; - const cy = BOARD_Y + y * CELL; + const cx = board.x + x * CELL; + const cy = board.y + y * CELL; const state = window.cellState[index]!; const isMine = window.mines[index] === 1; const gameOver = window.phase === "lost"; @@ -757,21 +789,23 @@ function drawMine(image: GrayImage, cx: number, cy: number, shade: number): void image.drawLine(centerX - 7, centerY + 7, centerX + 7, centerY - 7, shade); } -function paintPanel(image: GrayImage, window: MinesweeperWindow): void { - drawStat(image, PANEL_X, BOARD_Y, "Mines", String(mineCount(window) - window.flagCount)); - drawStat(image, PANEL_X, BOARD_Y + 62, "Time", formatElapsed(elapsedMs(window))); - image.drawText(smallFont, PANEL_X, BOARD_Y + 126, DIFFICULTIES[window.difficultyIndex]!.name, 140); +/** The stats and gesture hints beside the board, laid out down from its top. */ +function paintPanel(image: GrayImage, window: MinesweeperWindow, board: BoardOrigin): void { + const x = board.x + COLS * CELL + PANEL_GAP; + drawStat(image, x, board.y, "Mines", String(mineCount(window) - window.flagCount)); + drawStat(image, x, board.y + 62, "Time", formatElapsed(elapsedMs(window))); + image.drawText(smallFont, x, board.y + 126, DIFFICULTIES[window.difficultyIndex]!.name, 140); if (window.phase === "won" || window.phase === "lost") { - image.drawText(mediumFont, PANEL_X, BOARD_Y + 152, window.phase === "won" ? "CLEARED!" : "BOOM!", 250); - image.drawText(smallFont, PANEL_X, BOARD_Y + 178, `${GESTURE_CLICK} new game`, 150); - image.drawText(smallFont, PANEL_X, BOARD_Y + 198, `${GESTURE_LONG_PRESS} menu`, 150); + image.drawText(mediumFont, x, board.y + 152, window.phase === "won" ? "CLEARED!" : "BOOM!", 250); + image.drawText(smallFont, x, board.y + 178, `${GESTURE_CLICK} new game`, 150); + image.drawText(smallFont, x, board.y + 198, `${GESTURE_LONG_PRESS} menu`, 150); } else if (window.selectMode === "row") { - image.drawText(smallFont, PANEL_X, 200, `${GESTURE_SCROLL} row ${GESTURE_CLICK} pick`, 115); - image.drawText(smallFont, PANEL_X, 222, `${GESTURE_DOUBLE_CLICK} pause`, 115); + image.drawText(smallFont, x, board.y + 186, `${GESTURE_SCROLL} row ${GESTURE_CLICK} pick`, 115); + image.drawText(smallFont, x, board.y + 208, `${GESTURE_DOUBLE_CLICK} pause`, 115); } else { - image.drawText(smallFont, PANEL_X, 200, `${GESTURE_SCROLL} cell ${GESTURE_CLICK} dig`, 115); - image.drawText(smallFont, PANEL_X, 222, `${GESTURE_LONG_PRESS} flag ${GESTURE_DOUBLE_CLICK} rows`, 115); + image.drawText(smallFont, x, board.y + 186, `${GESTURE_SCROLL} cell ${GESTURE_CLICK} dig`, 115); + image.drawText(smallFont, x, board.y + 208, `${GESTURE_LONG_PRESS} flag ${GESTURE_DOUBLE_CLICK} rows`, 115); } } diff --git a/app/apps/music/media-browse.ts b/app/apps/music/media-browse.ts index 3876c67e..da949966 100644 --- a/app/apps/music/media-browse.ts +++ b/app/apps/music/media-browse.ts @@ -11,13 +11,24 @@ import { } from "../../native/media-browser"; import { Layer, type LayerContext } from "../../ui/layers"; -/** Header: title line + path line (34px at the 12px bitmap default). */ +/** Header: title line + path line (26px at the 12px bitmap default), below the window's top padding. */ function headerHeight(font: UiFont): number { - return 8 + lineStep(font) + font.lineHeight; + return lineStep(font) + font.lineHeight; } -const LIST_X = 20; -/** The selection box extends this far left and right of the row text. */ +/** + * The selection box extends this far left and right of the row text. The + * boxes start at the window's left padding, so the title, path and hint + * line, which line up with the row text, start this far in from it. + */ const LIST_HIGHLIGHT_PAD = 6; +/** Status messages (connecting, errors, empty) are indented this far from the title, and sit this far under the header. */ +const MESSAGE_INDENT = 4; +const MESSAGE_GAP = 8; +/** Clear rows between the list and the hint line under it. */ +const FOOTER_GAP = 7; +/** Width of the bar Menu.drawScrollbar draws, and the room kept for it right of the rows. */ +const SCROLLBAR_WIDTH = 3; +const SCROLLBAR_GUTTER = 6; export type MediaBrowseOptions = { app: MediaBrowserApp; @@ -59,55 +70,68 @@ export class MediaBrowseLayer implements Layer { this.startConnect(ctx); } const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + // The list's selection boxes span the window's side padding, less the + // scrollbar's gutter. The header and the hint line are fixed, inside the + // top and bottom padding, with the list scrolling between them. + const listX = padding.left; + const textX = listX + LIST_HIGHLIGHT_PAD; + const textWidth = width - padding.left - padding.right - 2 * LIST_HIGHLIGHT_PAD; + const headerBottom = padding.top + headerHeight(font); + const messageX = textX + MESSAGE_INDENT; + const messageY = headerBottom + MESSAGE_GAP; + const footerY = height - padding.bottom - font.lineHeight; - image.drawText(font, 20, 8, `Library: ${this.options.app.appName}`, 220); + image.drawText(font, textX, padding.top, `Library: ${this.options.app.appName}`, 220); if (this.phase === "connecting" || this.phase === "idle") { - image.drawText(font, 24, headerHeight(font) + 8, `Starting ${this.options.app.appName}...`, 150); - image.drawText(font, 20, height - font.lineHeight - 4, `${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(font, messageX, messageY, `Starting ${this.options.app.appName}...`, 150); + image.drawText(font, textX, footerY, `${GESTURE_DOUBLE_CLICK} back`, 110); return image; } if (this.phase === "failed") { - image.drawText(font, 24, headerHeight(font) + 8, "Could not connect:", 180); - image.drawText(font, 24, headerHeight(font) + 8 + lineStep(font), truncateRight(font, this.connectError, width - 48), 140); - image.drawText(font, 20, height - font.lineHeight - 4, `${GESTURE_CLICK} retry ${GESTURE_DOUBLE_CLICK} back`, 110); + image.drawText(font, messageX, messageY, "Could not connect:", 180); + image.drawText(font, messageX, messageY + lineStep(font), truncateRight(font, this.connectError, textWidth - 2 * MESSAGE_INDENT), 140); + image.drawText(font, textX, footerY, `${GESTURE_CLICK} retry ${GESTURE_DOUBLE_CLICK} back`, 110); return image; } const level = this.currentLevel(); const path = this.levels.map((entry) => entry.title).join(" / "); - image.drawText(font, 20, 8 + lineStep(font), truncateLeft(font, path, width - 40), 130); + image.drawText(font, textX, padding.top + lineStep(font), truncateLeft(font, path, textWidth), 130); if (!level || level.items === null) { - image.drawText(font, 24, headerHeight(font) + 8, level?.error ? level.error : "Loading...", level?.error ? 140 : 150); - image.drawText(font, 20, height - font.lineHeight - 4, `${GESTURE_DOUBLE_CLICK} up / back`, 110); + image.drawText(font, messageX, messageY, level?.error ? level.error : "Loading...", level?.error ? 140 : 150); + image.drawText(font, textX, footerY, `${GESTURE_DOUBLE_CLICK} up / back`, 110); return image; } const items = level.items; if (!items.length) { - image.drawText(font, 24, headerHeight(font) + 8, "(empty)", 120); - image.drawText(font, 20, height - font.lineHeight - 4, `${GESTURE_DOUBLE_CLICK} up / back`, 110); + image.drawText(font, messageX, messageY, "(empty)", 120); + image.drawText(font, textX, footerY, `${GESTURE_DOUBLE_CLICK} up / back`, 110); return image; } - const listTop = headerHeight(font); - const listHeight = height - listTop - font.lineHeight - 10; - const visibleRows = Math.max(1, (listHeight / tightRowHeight(font)) | 0); // Row boxes start one pixel above the header's bottom edge. - level.menu.paint( - image, - { x: LIST_X - LIST_HIGHLIGHT_PAD, y: listTop - 1, width: width - 2 * LIST_X + 2 * LIST_HIGHLIGHT_PAD, height: listHeight }, - ctx.stack.isFocused(), - ); - level.menu.drawScrollbar(image, width - 12, listTop, visibleRows * tightRowHeight(font) - 4); + const listTop = headerBottom - 1; + const listBottom = footerY - FOOTER_GAP; + if (listBottom > listTop) { + level.menu.paint( + image, + { x: listX, y: listTop, width: width - padding.left - padding.right - SCROLLBAR_GUTTER, height: listBottom - listTop }, + ctx.stack.isFocused(), + ); + // The bar hugs the window's right padding, a little short of the list's ends. + const trackHeight = listBottom - listTop - 4; + if (trackHeight > 0) level.menu.drawScrollbar(image, width - padding.right - SCROLLBAR_WIDTH, headerBottom, trackHeight); + } image.drawText( font, - 20, - height - 16, + textX, + footerY, `${GESTURE_SCROLL} select ${GESTURE_CLICK} open/play ${GESTURE_DOUBLE_CLICK} up / back`, 110, ); diff --git a/app/apps/music/music-app.ts b/app/apps/music/music-app.ts index 4a32c2db..117178e1 100644 --- a/app/apps/music/music-app.ts +++ b/app/apps/music/music-app.ts @@ -14,26 +14,41 @@ import { MusicSettingsLayer } from "./music-settings"; import { spotifyMenuItem } from "./spotify-menu"; import { Layer, type LayerContext, type PaintBelow } from "../../ui/layers"; import { createInProcessWindow, YieldAtRootLayer, type InProcessAppOptions, type InProcessWindow } from "../../ui/shell/in-process-window"; +import type { Viewport } from "../../ui/viewport"; export const MUSIC_WINDOW_ID = "music"; export const MUSIC_SURFACE_ID = "window:music"; const ART_SIZE = 112; -const ART_X = 8; // left margin matches the top margin -const ART_Y = 8; -const META_X = ART_X + ART_SIZE + 14; -const PROGRESS_BAR_Y = ART_Y + 116; +/** + * The outline hugging the album art. It is the outermost thing the + * now-playing page draws toward the window's top and left edges, so it sits + * at the padding suggested for them and the art just inside it. + */ +const ART_FRAME = 1; +/** Gap between the art and the metadata column. */ +const META_GAP = 14; +/** The metadata's first line, the progress bar and the lists, down from the art's top. */ +const META_OFFSET_Y = 2; +const PROGRESS_BAR_OFFSET_Y = 116; +const LIST_OFFSET_Y = 128; /** Clear rows between the time labels' baseline (digits have no descenders) and the bar. */ const PROGRESS_TIME_GAP = 3; -const LIST_TOP = 136; -/** Gap between the menus' last row band and the viewport bottom. */ -const LIST_BOTTOM_MARGIN = 4; -const ACTION_X = 22; const ACTION_WIDTH = 154; -const COLUMN_DIVIDER_X = 190; -const QUEUE_X = 204; /** Horizontal inset of row text from its selection box. */ const LIST_TEXT_INSET = 6; +/** The actions column's selection boxes, which start at the window's left padding. */ +const ACTION_BOX_WIDTH = ACTION_WIDTH + 2 * LIST_TEXT_INSET - 4; +/** The column divider and the queue's selection boxes, right of the actions column's left edge. */ +const COLUMN_DIVIDER_OFFSET_X = 174; +const QUEUE_OFFSET_X = 182; +/** Width of the bar Menu.drawScrollbar draws, and the room kept for it right of a list's rows. */ +const SCROLLBAR_WIDTH = 3; +const SCROLLBAR_GUTTER = 6; +/** How far the setup prompt's text is indented from its hint line. */ +const PROMPT_INDENT = 4; +/** Gap between the no-session page's status line, its prompt and its list. */ +const SECTION_GAP = 6; const PLAYLIST_ACTION_INDEX = 1; /** Minimum room for the dim artist after a queue row's title; less and it is left off. */ const QUEUE_SUBTITLE_MIN_WIDTH = 40; @@ -102,107 +117,111 @@ class MusicAppLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); + const viewport = ctx.stack.getBaseSize(); + const { width, height, padding } = viewport; const image = new GrayImage(width, height, 0); const media = mediaControllerBridge.snapshot(); if (!media.accessEnabled) { - const lines = wrapText(font, mediaControllerBridge.accessPrompt, width - 48); + // The hint line sits at the window's left and bottom padding; the + // prompt is indented from it, as far from the right padding as the left. + const lines = wrapText(font, mediaControllerBridge.accessPrompt, width - padding.left - padding.right - 2 * PROMPT_INDENT); for (let index = 0; index < lines.length; index++) { - image.drawText(font, 24, 16 + index * lineStep(font), lines[index]!, 180); + image.drawText(font, padding.left + PROMPT_INDENT, padding.top + index * lineStep(font), lines[index]!, 180); } - image.drawText(font, 20, height - 16, `${GESTURE_CLICK} ${mediaControllerBridge.accessAction}`, 110); + image.drawText(font, padding.left, height - padding.bottom - font.lineHeight, `${GESTURE_CLICK} ${mediaControllerBridge.accessAction}`, 110); return image; } + // Lists' selection boxes start at the window's left padding and stop + // short of the scrollbar, which hugs the right padding. + const listX = padding.left; + const rowsRight = width - padding.right - SCROLLBAR_GUTTER; + const focused = ctx.stack.isFocused(); + if (!media.available) { const apps = mediaBrowserBridge.listBrowsableApps(!this.libraryAppsFresh); this.libraryAppsFresh = true; this.libraryMenu.setItems(apps); - image.drawText(font, 24, 16, global.isIOS ? media.status || "Nothing is playing." : "No active media session.", 180); + // The text lines up with the picker's row text. + const textX = listX + LIST_TEXT_INSET; + const textWidth = rowsRight - listX - 2 * LIST_TEXT_INSET; + image.drawText(font, textX, padding.top, global.isIOS ? media.status || "Nothing is playing." : "No active media session.", 180); const prompt = global.isIOS ? "Browse your library, or start playback on the phone." : apps.length ? "Browse a music app's library, or start playback on the phone." : "Start playback in another app on the phone."; - let y = 22 + lineStep(font); - for (const line of wrapText(font, prompt, width - 48)) { - image.drawText(font, 24, y, line, 150); + let y = padding.top + lineStep(font) + SECTION_GAP; + for (const line of wrapText(font, prompt, textWidth)) { + image.drawText(font, textX, y, line, 150); y += lineStep(font); } // Why the last command failed (e.g. playing from the Spotify library with no device open). - for (const line of media.notice ? wrapText(font, media.notice, width - 48) : []) { - image.drawText(font, 24, y, line, 200); + for (const line of media.notice ? wrapText(font, media.notice, textWidth) : []) { + image.drawText(font, textX, y, line, 200); y += lineStep(font); } if (apps.length) { - const listTop = y + 6; - const listHeight = height - listTop - LIST_BOTTOM_MARGIN; - this.libraryMenu.paint( - image, - { x: 24 - LIST_TEXT_INSET, y: listTop - 1, width: width - 48 + 2 * LIST_TEXT_INSET - 4, height: listHeight }, - ctx.stack.isFocused(), - ); - this.libraryMenu.drawScrollbar(image, width - 12, listTop, listHeight - 4); + paintListToBottomEdge(image, this.libraryMenu, { x: listX, top: y + SECTION_GAP, width: rowsRight - listX }, viewport, focused, true); } return image; } this.libraryAppsFresh = false; - this.drawArt(image, media); + const artX = padding.left + ART_FRAME; + const artY = padding.top + ART_FRAME; + this.drawArt(image, media, artX, artY); - const metaWidth = width - META_X - 24; + // The metadata column and the progress bar end at the window's right padding. + const metaX = artX + ART_SIZE + META_GAP; + const metaWidth = width - padding.right - metaX; const metaStep = lineStep(font) + 1; - const metaTop = ART_Y + 2; + const metaTop = artY + META_OFFSET_Y; + const progressBarY = artY + PROGRESS_BAR_OFFSET_Y; // Line budget above the progress-bar time line: the layout is five slots // (title, second title line, artist, album, player app); when the font is // too large for all five, the title gets one truncated line instead of // wrapping to two, and the rest shift up a slot. - const maxLines = Math.floor((progressTimeY(font) - metaTop - 4 - font.lineHeight) / metaStep) + 1; + const maxLines = Math.floor((progressTimeY(font, progressBarY) - metaTop - 4 - font.lineHeight) / metaStep) + 1; const titleSlots = maxLines >= 5 ? 2 : 1; const title = media.title || "Unknown title"; const titleLines = titleSlots === 2 ? wrapText(font, title, metaWidth).slice(0, 2) : [truncateText(font, title, metaWidth)]; for (let index = 0; index < titleLines.length; index++) { - image.drawText(font, META_X, metaTop + index * metaStep, titleLines[index]!, 230); + image.drawText(font, metaX, metaTop + index * metaStep, titleLines[index]!, 230); } - image.drawText(font, META_X, metaTop + 4 + titleSlots * metaStep, media.artist || "Unknown artist", 180); + image.drawText(font, metaX, metaTop + 4 + titleSlots * metaStep, media.artist || "Unknown artist", 180); if (media.album) { - image.drawText(font, META_X, metaTop + 4 + (titleSlots + 1) * metaStep, truncateText(font, media.album, metaWidth), 150); + image.drawText(font, metaX, metaTop + 4 + (titleSlots + 1) * metaStep, truncateText(font, media.album, metaWidth), 150); } // The player line, or for a few seconds why a command failed. image.drawText( font, - META_X, + metaX, metaTop + 4 + (titleSlots + 2) * metaStep, truncateText(font, media.notice || media.appName || media.packageName, metaWidth), media.notice ? 200 : 110, ); - this.drawProgress(image, media, metaWidth); + this.drawProgress(image, media, metaX, progressBarY, metaWidth); const queue = mediaControllerBridge.getQueue(); const actions = this.buildActions(media, queue); this.reconcileSelection(actions, queue); - const listHeight = height - LIST_TOP - LIST_BOTTOM_MARGIN; - const focused = ctx.stack.isFocused(); - // Row boxes start one pixel above LIST_TOP, level with the column divider. - this.actionsMenu.paint( - image, - { x: ACTION_X - LIST_TEXT_INSET, y: LIST_TOP - 1, width: ACTION_WIDTH + 2 * LIST_TEXT_INSET - 4, height: listHeight }, - focused && this.focusColumn === "actions", - ); + const listTop = artY + LIST_OFFSET_Y; + paintListToBottomEdge(image, this.actionsMenu, { x: listX, top: listTop, width: ACTION_BOX_WIDTH }, viewport, + focused && this.focusColumn === "actions"); - image.drawLine(COLUMN_DIVIDER_X, LIST_TOP - 3, COLUMN_DIVIDER_X, height - LIST_BOTTOM_MARGIN - 3, 45); + // The divider is fixed, so it stops at the window's bottom padding. + const dividerX = listX + COLUMN_DIVIDER_OFFSET_X; + const dividerBottom = height - padding.bottom - 1; + if (dividerBottom > listTop) image.drawLine(dividerX, listTop - 3, dividerX, dividerBottom, 45); + const queueX = listX + QUEUE_OFFSET_X; if (!queue.length) { - image.drawText(font, QUEUE_X, LIST_TOP + 1, "Playlist unavailable", 90); + image.drawText(font, queueX + LIST_TEXT_INSET, listTop + 1, "Playlist unavailable", 90); } else { - const queueWidth = width - QUEUE_X - 20; - this.queueMenu.paint( - image, - { x: QUEUE_X - LIST_TEXT_INSET, y: LIST_TOP - 1, width: queueWidth + 2 * LIST_TEXT_INSET - 4, height: listHeight }, - focused && this.focusColumn === "playlist", - ); - this.queueMenu.drawScrollbar(image, width - 12, LIST_TOP, listHeight - 4); + paintListToBottomEdge(image, this.queueMenu, { x: queueX, top: listTop, width: rowsRight - queueX }, viewport, + focused && this.focusColumn === "playlist", true); } return image; @@ -386,22 +405,23 @@ class MusicAppLayer implements Layer { } } - private drawProgress(image: GrayImage, media: MediaControllerState, width: number): void { + /** The elapsed/duration labels and, under them, the bar at (x, barY), `width` wide. */ + private drawProgress(image: GrayImage, media: MediaControllerState, x: number, barY: number, width: number): void { if (media.durationMs <= 0 || media.positionMs < 0) return; const font = getDefaultSmallFont(); const elapsed = formatMediaTime(media.positionMs); const duration = formatMediaTime(media.durationMs); - const timeY = progressTimeY(font); - image.drawText(font, META_X, timeY, elapsed, 140); - image.drawText(font, META_X + width - font.measureText(duration), timeY, duration, 140); + const timeY = progressTimeY(font, barY); + image.drawText(font, x, timeY, elapsed, 140); + image.drawText(font, x + width - font.measureText(duration), timeY, duration, 140); - const barY = PROGRESS_BAR_Y; - image.drawRect(META_X, barY, width, 5, 55); + image.drawRect(x, barY, width, 5, 55); const progress = clamp(media.positionMs / media.durationMs, 0, 1); - image.fillRect(META_X + 1, barY + 1, Math.round((width - 2) * progress), 3, 170); + image.fillRect(x + 1, barY + 1, Math.round((width - 2) * progress), 3, 170); } - private drawArt(image: GrayImage, media: MediaControllerState): void { + /** The album art, or a placeholder, in the ART_SIZE box at (artX, artY), with its outline around it. */ + private drawArt(image: GrayImage, media: MediaControllerState, artX: number, artY: number): void { // Keyed on artVersion, not the strings: players (e.g. Spotify) publish // metadata before the art bitmap is downloaded, or with the previous // track's bitmap after a quick double skip, then re-emit the same @@ -412,17 +432,18 @@ class MusicAppLayer implements Layer { } if (this.art) { // Center within the art box. - const dx = ART_X + Math.max(0, ((ART_SIZE - this.art.width) / 2) | 0); - const dy = ART_Y + Math.max(0, ((ART_SIZE - this.art.height) / 2) | 0); + const dx = artX + Math.max(0, ((ART_SIZE - this.art.width) / 2) | 0); + const dy = artY + Math.max(0, ((ART_SIZE - this.art.height) / 2) | 0); image.bitBlt(this.art, dx, dy); - image.drawRect(dx - 1, dy - 1, this.art.width + 2, this.art.height + 2, 60); + image.drawRect(dx - ART_FRAME, dy - ART_FRAME, this.art.width + 2 * ART_FRAME, this.art.height + 2 * ART_FRAME, 60); } else { - image.drawRect(ART_X, ART_Y, ART_SIZE, ART_SIZE, 60); + // The placeholder's outline is where a full-size cover's would be. + image.drawRect(artX - ART_FRAME, artY - ART_FRAME, ART_SIZE + 2 * ART_FRAME, ART_SIZE + 2 * ART_FRAME, 60); const font = getDefaultSmallFont(); image.drawText( font, - ART_X + Math.round((ART_SIZE - font.measureText("no art")) / 2), - ART_Y + Math.round((ART_SIZE - font.lineHeight) / 2), + artX + Math.round((ART_SIZE - font.measureText("no art")) / 2), + artY + Math.round((ART_SIZE - font.lineHeight) / 2), "no art", 90, ); @@ -567,12 +588,37 @@ export function createMusicAppWindow(options: InProcessAppOptions): InProcessWin } /** - * Line top of the elapsed/duration labels: their baseline sits a fixed gap - * above the progress bar, so the labels hug the bar whatever the font's - * height (a taller face grows upward into the metadata's line budget). + * Paint a list that scrolls under fixed content: from `top` down to the + * window's bottom edge, where a row cut off for scrolling meets the edge, + * with that edge's padding inside the list after its last row. Selection + * boxes start one pixel above `top`. The scrollbar, when asked for, stays + * inside the window's right and bottom padding. */ -function progressTimeY(font: UiFont): number { - return PROGRESS_BAR_Y - PROGRESS_TIME_GAP - font.ascent; +function paintListToBottomEdge( + image: GrayImage, + menu: Menu, + rows: { x: number; top: number; width: number }, + viewport: Viewport, + focused: boolean, + scrollbar = false, +): void { + const { width, height, padding } = viewport; + const boxTop = rows.top - 1; + if (boxTop >= height || rows.width <= 0) return; + menu.paint(image, { x: rows.x, y: boxTop, width: rows.width, height: height - boxTop, padBottom: padding.bottom }, focused); + const trackHeight = height - padding.bottom - rows.top; + if (scrollbar && trackHeight > 0) { + menu.drawScrollbar(image, width - padding.right - SCROLLBAR_WIDTH, rows.top, trackHeight); + } +} + +/** + * Line top of the elapsed/duration labels: their baseline sits a fixed gap + * above the progress bar (at barY), so the labels hug the bar whatever the + * font's height (a taller face grows upward into the metadata's line budget). + */ +function progressTimeY(font: UiFont, barY: number): number { + return barY - PROGRESS_TIME_GAP - font.ascent; } function formatMediaTime(milliseconds: number): string { diff --git a/app/apps/music/music-settings.ts b/app/apps/music/music-settings.ts index c4c45207..e04c8f48 100644 --- a/app/apps/music/music-settings.ts +++ b/app/apps/music/music-settings.ts @@ -10,7 +10,6 @@ import { drawToggleMenuItem, MenuLayer, type MenuItem } from "../../ui/menu"; /** Discovered apps stay visible even when ignored or no longer publishing a session. */ export class MusicSettingsLayer implements Layer { private menu: MenuLayer | null = null; - private menuWidth = 0; /** The package behind each current row, parallel to the menu's items. */ private packages: string[] = []; @@ -20,7 +19,7 @@ export class MusicSettingsLayer implements Layer { } /** Refresh the rows from the remembered apps, keeping the selection on the same package. */ - private currentMenu(ctx: LayerContext): MenuLayer { + private currentMenu(): MenuLayer { const apps = readMediaApps().sort((a, b) => a.appName.localeCompare(b.appName) || a.packageName.localeCompare(b.packageName)); const items: MenuItem[] = apps.map((app) => ({ @@ -39,14 +38,8 @@ export class MusicSettingsLayer implements Layer { const index = apps.findIndex((app) => app.packageName === selectedPackage); this.packages = apps.map((app) => app.packageName); - const width = ctx.stack.getBaseSize().width; - if (!this.menu || width !== this.menuWidth) { - this.menuWidth = width; - this.menu = new MenuLayer("Music settings", items, { - x: 8, y: 8, width: width - 16, - opaque: true, showBorder: false, - footer: "On = enabled Off = ignored", - }).selectItem(Math.max(0, index)); + if (!this.menu) { + this.menu = new MenuLayer("Music settings", items, { page: true, footer: "On = enabled Off = ignored" }).selectItem(Math.max(0, index)); } else { this.menu.setItems(items, index >= 0 ? index : undefined); } @@ -54,10 +47,10 @@ export class MusicSettingsLayer implements Layer { } paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage { - return this.currentMenu(ctx).paint(ctx, paintBelow); + return this.currentMenu().paint(ctx, paintBelow); } async handleInput(event: InputEvent, ctx: LayerContext): Promise { - await this.currentMenu(ctx).handleInput(event, ctx); + await this.currentMenu().handleInput(event, ctx); } } diff --git a/app/apps/navigate/navigate-app.worker.ts b/app/apps/navigate/navigate-app.worker.ts index 142cef5e..9adbc82a 100644 --- a/app/apps/navigate/navigate-app.worker.ts +++ b/app/apps/navigate/navigate-app.worker.ts @@ -59,6 +59,7 @@ import { type SavedDestination, } from "./destinations"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import { sameViewport, type Viewport } from "../../ui/viewport"; import type { ToolSpec, ToolResult } from "../../assistant/tool-registry"; import { GESTURE_CLICK, @@ -95,7 +96,11 @@ import { drawManeuverGlyph } from "./maneuver-icons"; declare const global: any; const MAP_SIZE = 260; +/** The guidance panel's region beside the map pane, and how far in its content starts. */ const PANEL_X = MAP_SIZE + 10; +const PANEL_INSET = 8; +/** Clear space between the footer hint line and what ends above it (the idle list, the map-mode map). */ +const FOOTER_GAP = 8; /** Map refetch policy knobs (design doc: never per-fix, only when stale). */ const BEARING_BUCKET_DEG = 15; const MOVE_REFRESH_FRACTION = 0.15; @@ -132,6 +137,13 @@ type NavWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there. The maps fill their panes + * whatever the edges touch; text, the idle list and the footer hints keep + * the padding. + */ + viewport: Viewport; foreground: boolean; focused: boolean; menu: WindowMenu | null; @@ -306,6 +318,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -313,19 +326,29 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { }; post({ type: "set-tools", windowId: message.windowId, tools: NAVIGATE_TOOLS }); break; - case "resize-window": + case "resize-window": { if (!window || window.windowId !== message.windowId) break; - if (window.viewportWidth === message.viewport.width && window.viewportHeight === message.viewport.height) break; + // The layout follows the padding as well as the size, so a change to + // what the edges touch alone is laid out and painted again too. + if (sameViewport(window.viewport, message.viewport)) break; + const mapSize = phase === "map" ? mapDimensions() : null; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; + window.viewport = message.viewport; window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; - if (phase === "map") { - resetMapState(); - maybeRefreshMap(); + // The map is fetched at the size it is shown at: only a change to that + // needs a new one. + if (mapSize) { + const resized = mapDimensions(); + if (resized.width !== mapSize.width || resized.height !== mapSize.height) { + resetMapState(); + maybeRefreshMap(); + } } render(); break; + } case "close-window": if (editing) { // Window closed mid-edit: shut the phone editor down. @@ -347,6 +370,9 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { frameTimings.logFrame(message.frameId, `input received in ${message.windowId} worker`); handleInput(window, message.event as InputEvent, message.frameId); break; + case "key": + // Only windows opened with acceptsKeys are sent keys. + break; case "text-input": if (editing) { // Voice input as an alternative to the phone keyboard. @@ -826,9 +852,13 @@ function maybeRefreshMap(): void { }); } +/** + * The map's size: the pane beside the guidance panel, or in map mode the + * whole window down to the footer hint. + */ function mapDimensions(): { width: number; height: number } { return phase === "map" && window - ? { width: window.viewportWidth, height: Math.max(1, window.viewportHeight - 30) } + ? { width: window.viewportWidth, height: Math.max(1, footerY(window.viewport) - FOOTER_GAP) } : { width: MAP_SIZE, height: MAP_SIZE }; } @@ -1212,10 +1242,11 @@ function idleEntries(): IdleEntry[] { return entries; } -/** Horizontal inset of the idle list's selection boxes. */ -const IDLE_LIST_X = 20; /** Pixels between consecutive idle rows' selection boxes. */ const IDLE_ROW_GAP = 2; +/** The idle list's scrollbar, and the gap its rows leave before it. */ +const IDLE_SCROLLBAR_WIDTH = 3; +const IDLE_SCROLLBAR_GAP = 4; function idleList(): Menu { idleMenu ??= new Menu({ @@ -1260,7 +1291,7 @@ function windowMenu(win: NavWindow): WindowMenu { post, title: () => win.title, items: () => windowMenuItems(), - size: { width: win.viewportWidth, height: win.viewportHeight }, + size: win.viewport, paintBase: () => paintContent(win), isFocused: () => win.focused, }); @@ -1342,12 +1373,28 @@ function paint(win: NavWindow): Plane[] { return windowMenu(win).paint(); } +/** + * Page text (a title, hints, status messages) starts this far inside the + * padding suggested for the window's sides, which is where the idle list's + * selection boxes and the footer hints start. + */ +const TEXT_INSET = 4; +/** How far below a page's title (at the top padding) its text starts: the idle page's hint, the edit screen's message. */ +const IDLE_HINT_DROP = 36; +const EDIT_MESSAGE_DROP = 48; + +/** Where a page's text starts and how wide it may run. */ +function pageText(viewport: Viewport): { x: number; width: number } { + const { width, padding } = viewport; + return { x: padding.left + TEXT_INSET, width: width - padding.left - padding.right - 2 * TEXT_INSET }; +} + function paintContent(win: NavWindow): GrayImage { const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); if (editing) { - paintEdit(image, editing); + paintEdit(image, win, editing); } else if (phase === "map") { - paintMap(image); + paintMap(image, win); } else if (phase === "idle" || phase === "acquiring" || phase === "routing") { paintIdle(image, win); } else { @@ -1357,27 +1404,31 @@ function paintContent(win: NavWindow): GrayImage { } /** The "type on the phone" screen for a destination name/address edit. */ -function paintEdit(image: GrayImage, edit: DestinationEdit): void { +function paintEdit(image: GrayImage, win: NavWindow, edit: DestinationEdit): void { + const { padding } = win.viewport; + const text = pageText(win.viewport); const step = smallFont.lineHeight + 2; - image.drawText(mediumFont, 24, 16, edit.title, 245); - const messageY = 64; - const lines = wrapText(smallFont, "Type the value in the phone app, or use voice input.", image.width - 48); + image.drawText(mediumFont, text.x, padding.top, edit.title, 245); + const messageY = padding.top + EDIT_MESSAGE_DROP; + const lines = wrapText(smallFont, "Type the value in the phone app, or use voice input.", text.width); for (let index = 0; index < lines.length; index++) { - image.drawText(smallFont, 24, messageY + index * step, lines[index]!, 190); + image.drawText(smallFont, text.x, messageY + index * step, lines[index]!, 190); } const value = edit.setting.get(); image.drawText( smallFont, - 24, + text.x, messageY + (lines.length + 1) * step, - truncateText(smallFont, value || "(empty)", image.width - 48), + truncateText(smallFont, value || "(empty)", text.width), value ? 225 : 130, ); - drawFooter(image, `${GESTURE_CLICK} done ${GESTURE_DOUBLE_CLICK} cancel`); + drawFooter(image, win.viewport, `${GESTURE_CLICK} done ${GESTURE_DOUBLE_CLICK} cancel`); } function paintIdle(image: GrayImage, win: NavWindow): void { - image.drawText(mediumFont, 24, 16, "Navigate", 245); + const { padding } = win.viewport; + const text = pageText(win.viewport); + image.drawText(mediumFont, text.x, padding.top, "Navigate", 245); const busy = phase !== "idle"; const entries = busy ? [] : idleEntries(); const configured = isMapboxConfigured(); @@ -1386,16 +1437,17 @@ function paintIdle(image: GrayImage, win: NavWindow): void { : entries.length ? "View the map or pick a destination below. Use Voice input (system menu, long-press) to say a destination." : "Ask the voice assistant to navigate somewhere, or pick Voice input from the system menu (long-press) to say a destination. Save Home, Work and other places from the app menu."; - const hintLines = wrapText(smallFont, hint, image.width - 48); + const hintLines = wrapText(smallFont, hint, text.width); const hintStep = smallFont.lineHeight + 2; + const hintY = padding.top + IDLE_HINT_DROP; for (let index = 0; index < hintLines.length; index++) { - image.drawText(smallFont, 24, 52 + index * hintStep, hintLines[index]!, 170); + image.drawText(smallFont, text.x, hintY + index * hintStep, hintLines[index]!, 170); } - let y = 52 + hintLines.length * hintStep + 6; + let y = hintY + hintLines.length * hintStep + 6; if (statusMessage) { - const statusLines = wrapText(smallFont, statusMessage, image.width - 48); + const statusLines = wrapText(smallFont, statusMessage, text.width); for (let index = 0; index < statusLines.length; index++) { - image.drawText(smallFont, 24, y + index * hintStep, statusLines[index]!, busy ? 220 : 190); + image.drawText(smallFont, text.x, y + index * hintStep, statusLines[index]!, busy ? 220 : 190); } y += statusLines.length * hintStep + 6; } @@ -1403,23 +1455,34 @@ function paintIdle(image: GrayImage, win: NavWindow): void { paintIdleList(image, win, entries, y); drawFooter( image, + win.viewport, `${GESTURE_SCROLL} select ${GESTURE_CLICK} ${configured ? "go" : "choose"} ${GESTURE_SHORT_THEN_LONG_PRESS} app menu ${GESTURE_DOUBLE_CLICK} back`, ); } else { - drawFooter(image, `${GESTURE_SHORT_THEN_LONG_PRESS} app menu ${GESTURE_DOUBLE_CLICK} back`); + drawFooter(image, win.viewport, `${GESTURE_SHORT_THEN_LONG_PRESS} app menu ${GESTURE_DOUBLE_CLICK} back`); } } -/** Map action, saved destinations, then recent places, one selectable row each. */ +/** + * Map action, saved destinations, then recent places, one selectable row + * each. The list scrolls between the page's text above it and the footer + * hint, both of which stay put, so it needs no padding of its own at its + * top and bottom; its selection boxes span the window between the padding + * suggested for the sides. + */ function paintIdleList(image: GrayImage, win: NavWindow, entries: IdleEntry[], top: number): void { + const { width, padding } = win.viewport; const rowHeight = listRowHeight(smallFont); - const listBottom = image.height - 30; + const listBottom = footerY(win.viewport) - FOOTER_GAP; const visibleRows = Math.max(1, Math.floor((listBottom - top) / rowHeight)); - const rowWidth = image.width - 40 - (entries.length > visibleRows ? 10 : 0); + const listHeight = visibleRows * rowHeight - IDLE_ROW_GAP; + // The scrollbar hugs the right padding; the rows give way to it only when there is one. + const right = width - padding.right; + const scrollbar = entries.length > visibleRows ? IDLE_SCROLLBAR_GAP + IDLE_SCROLLBAR_WIDTH : 0; const list = idleList(); list.setItems(entries); - list.paint(image, { x: IDLE_LIST_X, y: top, width: rowWidth, height: visibleRows * rowHeight - IDLE_ROW_GAP }, win.focused); - list.drawScrollbar(image, IDLE_LIST_X + rowWidth + 4, top, visibleRows * rowHeight - 2); + list.paint(image, { x: padding.left, y: top, width: right - scrollbar - padding.left, height: listHeight }, win.focused); + list.drawScrollbar(image, right - IDLE_SCROLLBAR_WIDTH, top, listHeight); } /** Two columns: the entry's name, then its detail (action hint, address or place). */ @@ -1444,6 +1507,22 @@ function drawIdleRow({ image, item: entry, x, y, width, selected }: MenuDrawArgs image.drawText(smallFont, detailX, textY, truncateText(smallFont, detail, x + width - 6 - detailX), selected ? 170 : 130); } +// The guidance panel's head, measured from the maneuver glyph's top-left +// corner (the panel's content x, at the window's top padding). +const GLYPH_SIZE = 56; +/** Text beside the glyph: the distance to the maneuver, or "Arrived". */ +const GLYPH_CAPTION_X = 68; +const DISTANCE_Y = 10; +const ARRIVED_Y = 12; +/** A roundabout's exit number, inside its glyph. */ +const EXIT_NUMBER_X = 22; +const EXIT_NUMBER_Y = 32; +/** The instruction (or the destination's name) under the glyph. */ +const INSTRUCTION_Y = 70; +/** Clear space under the panel's status line (above the footer hint) and under its ETA line (above the status). */ +const PANEL_STATUS_GAP = 10; +const PANEL_ETA_GAP = 6; + function paintNavigating(image: GrayImage, win: NavWindow): void { // Map pane (left). if (mapImage) { @@ -1460,72 +1539,87 @@ function paintNavigating(image: GrayImage, win: NavWindow): void { image.drawText(smallFont, 24, MAP_SIZE / 2 - 8, text, 120); } - // Guidance panel (right) — its own region so text deltas never overlap the map's. - const panelWidth = win.viewportWidth - PANEL_X; + // Guidance panel (right) — its own region so text deltas never overlap the + // map's. Its left side is placed from the map pane; its top, right and + // bottom keep the padding suggested for the window's edges. + const { padding } = win.viewport; + const x = PANEL_X + PANEL_INSET; + const top = padding.top; + const textWidth = win.viewportWidth - padding.right - x; if (phase === "arrived") { - drawManeuverGlyph(image, PANEL_X + 8, 14, 56, "arrive", "", 245); - image.drawText(mediumFont, PANEL_X + 76, 26, "Arrived", 245); + drawManeuverGlyph(image, x, top, GLYPH_SIZE, "arrive", "", 245); + image.drawText(mediumFont, x + GLYPH_CAPTION_X, top + ARRIVED_Y, "Arrived", 245); image.drawTextWrapped({ font: smallFont, - x: PANEL_X + 8, - y: 84, - width: panelWidth - 16, + x, + y: top + INSTRUCTION_Y, + width: textWidth, text: destinationName, value: 200, }); - drawFooter(image, `${GESTURE_CLICK} done ${GESTURE_DOUBLE_CLICK} back`); + drawFooter(image, win.viewport, `${GESTURE_CLICK} done ${GESTURE_DOUBLE_CLICK} back`); return; } + // The status and ETA lines stack above the footer hint. + const statusY = footerY(win.viewport) - smallFont.lineHeight - PANEL_STATUS_GAP; const step = follower && progress ? follower.route.steps[progress.nextStepIndex] : null; if (step && progress) { - drawManeuverGlyph(image, PANEL_X + 8, 14, 56, step.maneuverType, step.maneuverModifier, 245); + drawManeuverGlyph(image, x, top, GLYPH_SIZE, step.maneuverType, step.maneuverModifier, 245); if (step.exit !== null && (step.maneuverType === "roundabout" || step.maneuverType === "rotary")) { - image.drawText(smallFont, PANEL_X + 30, 46, String(step.exit), 245); + image.drawText(smallFont, x + EXIT_NUMBER_X, top + EXIT_NUMBER_Y, String(step.exit), 245); } - image.drawText(largeFont, PANEL_X + 76, 24, formatDistanceShort(progress.metersToNextManeuver), 250); + image.drawText(largeFont, x + GLYPH_CAPTION_X, top + DISTANCE_Y, formatDistanceShort(progress.metersToNextManeuver), 250); image.drawTextWrapped({ font: mediumFont, - x: PANEL_X + 8, - y: 84, - width: panelWidth - 16, + x, + y: top + INSTRUCTION_Y, + width: textWidth, text: step.instruction || step.name || step.maneuverType, value: 220, }); const eta = `${formatDistance(progress.remainingMeters)} · ${formatDurationShort(progress.remainingSec)} · ${formatClock( Date.now() + progress.remainingSec * 1000, )}`; - image.drawText(smallFont, PANEL_X + 8, win.viewportHeight - 62, eta, 170); + image.drawText(smallFont, x, statusY - smallFont.lineHeight - PANEL_ETA_GAP, eta, 170); } else { image.drawTextWrapped({ font: mediumFont, - x: PANEL_X + 8, - y: 24, - width: panelWidth - 16, + x, + y: top, + width: textWidth, text: `Waiting for GPS...`, value: 200, }); } if (statusMessage) { - image.drawText(smallFont, PANEL_X + 8, win.viewportHeight - 44, statusMessage, 200); + image.drawText(smallFont, x, statusY, truncateText(smallFont, statusMessage, textWidth), 200); } const modeHint = mapMode === "follow" ? "overview" : "follow"; - drawFooter(image, `${GESTURE_SCROLL} zoom ${GESTURE_CLICK} ${modeHint} ${GESTURE_DOUBLE_CLICK} back`, PANEL_X + 8); + drawFooter(image, win.viewport, `${GESTURE_SCROLL} zoom ${GESTURE_CLICK} ${modeHint} ${GESTURE_DOUBLE_CLICK} back`, x); } -function paintMap(image: GrayImage): void { +/** Clear space under the text of the map-mode status banner. */ +const STATUS_BANNER_GAP = 4; + +function paintMap(image: GrayImage, win: NavWindow): void { + const { padding } = win.viewport; const { width, height } = mapDimensions(); if (mapImage) { image.bitBlt(mapImage, 0, 0); drawChevron(image, width / 2, height / 2, headHeadingDeg ?? 0); } else { - image.drawText(smallFont, 24, height / 2 - 8, mapLastError ? "Map unavailable; retrying..." : "Loading map...", 170); + const text = mapLastError ? "Map unavailable; retrying..." : "Loading map..."; + image.drawText(smallFont, pageText(win.viewport).x, height / 2 - 8, text, 170); } if (statusMessage) { - image.fillRect(0, 0, width, smallFont.lineHeight + 8, 0); - image.drawText(smallFont, 16, 4, truncateText(smallFont, statusMessage, width - 32), 200); + // A banner across the map's top: the strip runs edge to edge, and its + // text keeps the padding suggested for the edges it lies along. + image.fillRect(0, 0, width, padding.top + smallFont.lineHeight + STATUS_BANNER_GAP, 0); + image.drawText(smallFont, padding.left, padding.top, + truncateText(smallFont, statusMessage, width - padding.left - padding.right), 200); } - drawFooter(image, `${GESTURE_SCROLL} zoom ${GESTURE_CLICK} destinations ${GESTURE_DOUBLE_CLICK} back`); + drawFooter(image, win.viewport, `${GESTURE_SCROLL} zoom ${GESTURE_CLICK} destinations ${GESTURE_DOUBLE_CLICK} back`); } /** @@ -1575,8 +1669,15 @@ function fillTriangle(image: GrayImage, x0: number, y0: number, x1: number, y1: } } -function drawFooter(image: GrayImage, text: string, x = 16): void { - image.drawText(smallFont, x, image.height - 22, text, 115); +/** Top of the footer hint line, which rests on the padding suggested for the window's bottom edge. */ +function footerY(viewport: Viewport): number { + return viewport.height - viewport.padding.bottom - smallFont.lineHeight; +} + +/** Draw the footer hint line from `x` (default: the left padding), cut short at the right padding. */ +function drawFooter(image: GrayImage, viewport: Viewport, text: string, x = viewport.padding.left): void { + const maxWidth = viewport.width - viewport.padding.right - x; + image.drawText(smallFont, x, footerY(viewport), truncateText(smallFont, text, maxWidth), 115); } // --------------------------------------------------------------------------- diff --git a/app/apps/nightscout/missed-bolus-notification.ts b/app/apps/nightscout/missed-bolus-notification.ts index 3b09ecf0..660f771f 100644 --- a/app/apps/nightscout/missed-bolus-notification.ts +++ b/app/apps/nightscout/missed-bolus-notification.ts @@ -8,11 +8,9 @@ import { type InputEvent } from "../../ui/gestures"; import { type Layer, type LayerContext } from "../../ui/layers"; import { lineStep } from "../../ui/metrics"; import { - NOTIFICATION_CONTENT_X, createNotificationActionMenu, drawNotificationHeader, - notificationActionMenuBox, - notificationContentWidth, + notificationDetailLayout, } from "../../ui/notifications"; import { type GlucoseRise } from "./missed-bolus-detector"; import { @@ -25,7 +23,6 @@ import { const ICON_SIZE = 24; const GRAPH_GAP = 6; -const GRAPH_BOTTOM_MARGIN = 12; const MIN_GRAPH_HEIGHT = 32; type ActionItem = { label: string; run: () => void }; @@ -56,13 +53,15 @@ export class MissedBolusNotificationLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); const step = lineStep(font); - const { width, height } = ctx.stack.getBaseSize(); - const image = new GrayImage(width, height, 0); - const contentX = NOTIFICATION_CONTENT_X; - const contentWidth = notificationContentWidth(width); + const viewport = ctx.stack.getBaseSize(); + const image = new GrayImage(viewport.width, viewport.height, 0); + // The same columns as a notification's detail view, inside the padding + // suggested for the edges of whatever hosts this (the shell's modal). + const layout = notificationDetailLayout(viewport); + const { contentX, contentWidth } = layout; const nowMs = Date.now(); - let y = drawNotificationHeader(image, font, renderIcon("nightscout", ICON_SIZE), `Nightscout ${formatRelativeTime(this.postedAtMs)}`); + let y = drawNotificationHeader(image, font, renderIcon("nightscout", ICON_SIZE), `Nightscout ${formatRelativeTime(this.postedAtMs)}`, layout); image.drawText(font, contentX, y, "Missed bolus?", 230); y += step; const minutes = Math.round((this.rise.latestMs - this.rise.onsetMs) / 60_000); @@ -90,12 +89,12 @@ export class MissedBolusNotificationLayer implements Layer { y += step; } const graphTop = y + GRAPH_GAP; - const graphHeight = height - GRAPH_BOTTOM_MARGIN - graphTop; + const graphHeight = layout.bottom - graphTop; if (graphHeight >= MIN_GRAPH_HEIGHT) { drawNightscoutGraph(image, { x: contentX, y: graphTop, width: contentWidth, height: graphHeight }, nightscout, nowMs, font); } - this.menu.paint(image, notificationActionMenuBox(width, height), ctx.stack.isFocused()); + this.menu.paint(image, layout.menuBox, ctx.stack.isFocused()); return image; } diff --git a/app/apps/nightscout/nightscout-app.ts b/app/apps/nightscout/nightscout-app.ts index 6458541a..01032319 100644 --- a/app/apps/nightscout/nightscout-app.ts +++ b/app/apps/nightscout/nightscout-app.ts @@ -84,7 +84,8 @@ function buildNightscoutTrayIcon(state: NightscoutState): GrayImage { const font = getDefaultSmallFont(); const nowMs = Date.now(); const label = state.latest ? `${state.latest.sgv}` : "--"; - const labelWidth = font.measureText(label); + // A TTF face measures fractionally; the icon's size and layout need whole pixels. + const labelWidth = Math.ceil(font.measureText(label)); const warning = evaluateNightscoutAlerts(state, loadNightscoutThresholds(), nowMs).any; const graphEnd = labelWidth + 4 + TRAY_GRAPH_WIDTH; const image = new GrayImage(graphEnd + (warning ? 24 : 0), TRAY_HEIGHT, 0); diff --git a/app/apps/nightscout/nightscout.ts b/app/apps/nightscout/nightscout.ts index 8266a31d..5ebcc902 100644 --- a/app/apps/nightscout/nightscout.ts +++ b/app/apps/nightscout/nightscout.ts @@ -30,6 +30,19 @@ export const NIGHTSCOUT_STALE_MS = 15 * 60 * 1000; const NIGHTSCOUT_GRAPH_WINDOW_MS = 2 * 60 * 60 * 1000; const NIGHTSCOUT_GRAPH_TIME_QUANTUM_MS = 60 * 1000; +/** + * The app page's fixed parts, placed from the title at the window's top and + * left padding: a status message and the graph, down from the title's top, + * and the status lines' column, right of the readout's left edge. + */ +const PAGE_MESSAGE_OFFSET_Y = 28; +const PAGE_GRAPH_OFFSET_Y = 112; +const PAGE_STATUS_OFFSET_X = 148; +/** Gap between the page's graph and the caption under it. */ +const PAGE_CAPTION_GAP = 6; +/** The shortest graph the page draws above its caption; with less room the graph takes the caption's. */ +const PAGE_MIN_GRAPH_HEIGHT = 40; + /** Draws the trend indicator; returns its width. */ export function drawDirectionIndicator( image: GrayImage, @@ -298,36 +311,44 @@ function drawNightscoutReferenceLine( export class NightscoutLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - // Sized to the hosting stack (the Nightscout app viewport). - const { width, height } = ctx.stack.getBaseSize(); + // Sized to the hosting stack (the Nightscout app viewport). Nothing here + // scrolls, so the page keeps inside the padding suggested for each of + // the viewport's edges: the title, the readout and the graph start at + // the left padding, and the graph and its caption end at the bottom's. + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); const nightscout = nightscoutBridge.snapshot(); const nowMs = Date.now(); const step = lineStep(font); - image.drawText(font, 22, 16, "Nightscout", 220); + const left = padding.left; + const top = padding.top; + const right = width - padding.right; + const bottom = height - padding.bottom; + image.drawText(font, left, top, "Nightscout", 220); + const messageY = top + PAGE_MESSAGE_OFFSET_Y; if (!isNightscoutSettingsConfigured() || nightscout.configurationMissing) { - image.drawText(font, 22, 44, "Nightscout needs configuration.", 180); - image.drawText(font, 22, 44 + step, "Long-press for the menu, then pick Settings to set", 140); - image.drawText(font, 22, 44 + 2 * step, "the site URL and API token.", 140); + image.drawText(font, left, messageY, "Nightscout needs configuration.", 180); + image.drawText(font, left, messageY + step, "Long-press for the menu, then pick Settings to set", 140); + image.drawText(font, left, messageY + 2 * step, "the site URL and API token.", 140); return image; } if (!nightscout.available || !nightscout.latest) { - image.drawText(font, 22, 44, "No Nightscout data available.", 180); - image.drawText(font, 22, 44 + step, truncateLine(nightscout.status, 60), 140); + image.drawText(font, left, messageY, "No Nightscout data available.", 180); + image.drawText(font, left, messageY + step, truncateLine(nightscout.status, 60), 140); return image; } // Two-column header above the graph: title + current glucose on the // left, the status lines bottom-aligned on the right. - const graphTop = 128; + const graphTop = top + PAGE_GRAPH_OFFSET_Y; const latest = nightscout.latest; const glucoseText = `${latest.sgv}`; - const glucoseX = 22; + const glucoseX = left; const glucoseWidth = nightscoutLargeFont.measureText(glucoseText); // Glucose value vertically centered between the title and the graph. - const titleBottom = 16 + font.lineHeight; + const titleBottom = top + font.lineHeight; const glucoseY = Math.round((titleBottom + graphTop - nightscoutLargeFont.lineHeight) / 2); image.drawText(nightscoutLargeFont, glucoseX, glucoseY, glucoseText, 230); if (isNightscoutPointStale(latest, nowMs)) { @@ -335,8 +356,8 @@ export class NightscoutLayer implements Layer { } image.drawText(font, glucoseX + glucoseWidth + 8, glucoseY + nightscoutLargeFont.lineHeight - font.lineHeight, nightscout.units, 140); - const statusX = 170; - const statusWidth = width - 22 - statusX; + const statusX = left + PAGE_STATUS_OFFSET_X; + const statusWidth = right - statusX; const alerts = evaluateNightscoutAlerts(nightscout, loadNightscoutThresholds(), nowMs); const statusLines: { text: string; shade: number; direction?: string; fields?: { text: string; warning?: boolean }[] }[] = [ { text: `Delta ${formatDelta(nightscout.delta)} Trend `, shade: 180, direction: nightscout.direction }, @@ -382,10 +403,14 @@ export class NightscoutLayer implements Layer { statusY += step; } - const captionY = height - font.lineHeight - 6; - const graphHeight = Math.max(40, captionY - 6 - graphTop); - drawNightscoutGraph(image, { x: 22, y: graphTop, width: width - 44, height: graphHeight }, nightscout, nowMs, font); - image.drawText(font, 22, captionY, "2-hour glucose history with basal / carbs / boluses", 130); + // The graph spans the padded width, down to the caption on the last + // line above the bottom padding. A window too short for both gives the + // caption's room to the graph. + const captionY = bottom - font.lineHeight; + const captioned = captionY - PAGE_CAPTION_GAP - graphTop >= PAGE_MIN_GRAPH_HEIGHT; + const graphBottom = captioned ? captionY - PAGE_CAPTION_GAP : bottom; + drawNightscoutGraph(image, { x: left, y: graphTop, width: right - left, height: graphBottom - graphTop }, nightscout, nowMs, font); + if (captioned) image.drawText(font, left, captionY, "2-hour glucose history with basal / carbs / boluses", 130); return image; } diff --git a/app/apps/notifications/index.ts b/app/apps/notifications/index.ts index 6f9cd5ed..426ddfd1 100644 --- a/app/apps/notifications/index.ts +++ b/app/apps/notifications/index.ts @@ -14,7 +14,12 @@ const notificationsApp: AppDefinition = { if (listenerState === "no-access" || listenerState === "stuck") { requestNotificationListenerAccess(); } - return ctx.launchInProcessApp(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow); + return ctx.launchInProcessApp(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, (options) => + createNotificationsAppWindow(options, (section) => { + void ctx.launchApp("settings", { section }).catch((error) => { + ctx.appendLog(`settings launch failed: ${error}`); + }); + })); }, }; diff --git a/app/apps/notifications/notifications-app.ts b/app/apps/notifications/notifications-app.ts index 65719b3f..561bb3dd 100644 --- a/app/apps/notifications/notifications-app.ts +++ b/app/apps/notifications/notifications-app.ts @@ -1,5 +1,5 @@ import { NotificationsListLayer } from "../../ui/notifications"; -import { NotificationFilterLayer } from "../../ui/notification-filter"; +import { NOTIFICATIONS_SETTINGS_SECTION } from "../../ui/dashboard/settings-menus"; import { onAndroidNotificationsChanged } from "../../native/notification-icons"; import { createInProcessWindow, @@ -14,9 +14,13 @@ export const NOTIFICATIONS_SURFACE_ID = "window:notifications"; /** * The Notifications app: the Android-notification list (previously a * dashboard page) in its own in-process window; selecting a notification - * opens the detail view with its quick actions. + * opens the detail view with its quick actions. `openSettings` opens a + * Settings section (the menu's "Settings" goes to Notifications). */ -export function createNotificationsAppWindow(options: InProcessAppOptions): InProcessWindow { +export function createNotificationsAppWindow( + options: InProcessAppOptions, + openSettings: (section: string) => void, +): InProcessWindow { // Newly posted notifications repaint the list while the window is open. let offNotificationsChanged: (() => void) | null = null; const created = createInProcessWindow({ @@ -27,10 +31,10 @@ export function createNotificationsAppWindow(options: InProcessAppOptions): InPr icon: "bell", closeable: true, menuItems: () => [{ - label: "Notification filter", + label: "Settings", onSelect: (ctx) => { ctx.stack.pop(); - ctx.stack.push(new NotificationFilterLayer()); + openSettings(NOTIFICATIONS_SETTINGS_SECTION); }, }], actions: options.actions, diff --git a/app/apps/onboarding/data-collection-page.ts b/app/apps/onboarding/data-collection-page.ts index ad52e32b..2dbbc352 100644 --- a/app/apps/onboarding/data-collection-page.ts +++ b/app/apps/onboarding/data-collection-page.ts @@ -4,11 +4,11 @@ import { dataCollectionSetting, dataCollectionSummary, type DataCollectionLevel import type { InputEvent } from "../../ui/gestures"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, listRowHeight } from "../../ui/metrics"; +import type { Edges } from "../../ui/viewport"; import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { drawPageHeading, PAGE_TEXT_INSET, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const CONTENT_GAP = 10; -const BOTTOM_MARGIN = 8; const LABEL_GAP = 24; /** None / Minimal / Full, each with a one-line summary; a tap saves the selected level. */ @@ -29,21 +29,27 @@ export class DataCollectionPage implements OnboardingPage { this.menu.select(dataCollectionSetting.values.indexOf(dataCollectionSetting.get())); } - paint(image: GrayImage, focused: boolean): void { + paint(image: GrayImage, focused: boolean, padding: Edges): void { const top = drawPageHeading( image, - "Data Sharing", - (global.isIOS ? "If using TestFlight, crash/usage reports cannot be disabled here. " : "") + - "Choose how much data you want to share. Change later in Settings > Privacy.", + padding, + "Faceclaw Statistics", + (global.isIOS ? "TestFlight reports are separate. " : "Google ML Kit diagnostics are separate. ") + + "Choose Faceclaw statistics below. Details and controls: Settings > Privacy.", 3, ) + CONTENT_GAP; const body = onboardingFont("body"); this.labelColumnWidth = Math.max(...dataCollectionSetting.values.map((level) => body.measureText(dataCollectionSetting.displayValue(level)))) + LABEL_GAP; + // The list scrolls, so it runs to the window's bottom edge, with that + // edge's padding after its last row. this.menu.paint( image, - { x: PAGE_X - 10, y: top, width: image.width - 2 * (PAGE_X - 10), height: image.height - top - BOTTOM_MARGIN }, + { + x: padding.left, y: top, width: Math.max(0, image.width - padding.left - padding.right), height: Math.max(0, image.height - top), + padBottom: padding.bottom, + }, focused, ); } @@ -68,9 +74,9 @@ export class DataCollectionPage implements OnboardingPage { private drawRow({ image, item: level, x, y, width, height, selected }: MenuDrawArgs): void { const body = onboardingFont("body"); const detail = onboardingFont("detail"); - image.drawText(body, x + 10, y + LIST_ROW_TEXT_INSET, dataCollectionSetting.displayValue(level), selected ? 255 : 200); - const summaryX = x + 10 + this.labelColumnWidth; - const summary = truncateText(detail, dataCollectionSummary(level), x + width - 10 - summaryX); + image.drawText(body, x + PAGE_TEXT_INSET, y + LIST_ROW_TEXT_INSET, dataCollectionSetting.displayValue(level), selected ? 255 : 200); + const summaryX = x + PAGE_TEXT_INSET + this.labelColumnWidth; + const summary = truncateText(detail, dataCollectionSummary(level), x + width - PAGE_TEXT_INSET - summaryX); image.drawText(detail, summaryX, y + Math.round((height - detail.lineHeight) / 2), summary, selected ? 210 : 150); } } diff --git a/app/apps/onboarding/depth-page.ts b/app/apps/onboarding/depth-page.ts index ad3b1c1d..29625240 100644 --- a/app/apps/onboarding/depth-page.ts +++ b/app/apps/onboarding/depth-page.ts @@ -3,12 +3,12 @@ import { appSwitcherPositionSetting, uiDepthSetting, type UiDepth } from "../../ import type { InputEvent } from "../../ui/gestures"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, listRowHeight } from "../../ui/metrics"; +import type { Edges } from "../../ui/viewport"; import { layoutHasDepth } from "./layout-page"; import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { drawPageHeading, PAGE_TEXT_INSET, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const CONTENT_GAP = 10; -const BOTTOM_MARGIN = 8; const COLUMN_WIDTH = 220; /** @@ -35,15 +35,21 @@ export class DepthPage implements OnboardingPage { this.menu.select(uiDepthSetting.values.indexOf(uiDepthSetting.get())); } - paint(image: GrayImage, focused: boolean): void { + paint(image: GrayImage, focused: boolean, padding: Edges): void { const top = drawPageHeading( image, + padding, "Depth", "Swipe to move the display nearer or farther away, then tap to continue. Change later in Settings > Customization.", ) + CONTENT_GAP; + // The list scrolls, so it runs to the window's bottom edge, with that + // edge's padding after its last row. this.menu.paint( image, - { x: PAGE_X - 10, y: top, width: COLUMN_WIDTH, height: image.height - top - BOTTOM_MARGIN }, + { + x: padding.left, y: top, width: Math.min(COLUMN_WIDTH, Math.max(0, image.width - padding.left - padding.right)), + height: Math.max(0, image.height - top), padBottom: padding.bottom, + }, focused, ); } @@ -66,6 +72,6 @@ export class DepthPage implements OnboardingPage { } private drawRow({ image, item: depth, x, y, selected }: MenuDrawArgs): void { - image.drawText(onboardingFont("body"), x + 10, y + LIST_ROW_TEXT_INSET, uiDepthSetting.displayValue(depth), selected ? 255 : 190); + image.drawText(onboardingFont("body"), x + PAGE_TEXT_INSET, y + LIST_ROW_TEXT_INSET, uiDepthSetting.displayValue(depth), selected ? 255 : 190); } } diff --git a/app/apps/onboarding/display-mode-page.ts b/app/apps/onboarding/display-mode-page.ts index 5f449478..464433fb 100644 --- a/app/apps/onboarding/display-mode-page.ts +++ b/app/apps/onboarding/display-mode-page.ts @@ -4,11 +4,11 @@ import { displayLayoutSetting, type DisplayLayout } from "../../ui/dashboard-set import type { InputEvent } from "../../ui/gestures"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, listRowHeight } from "../../ui/metrics"; +import type { Edges } from "../../ui/viewport"; import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { drawPageHeading, PAGE_TEXT_INSET, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const CONTENT_GAP = 10; -const BOTTOM_MARGIN = 8; const COLUMN_GAP = 16; const DESCRIPTIONS = { @@ -41,24 +41,29 @@ export class DisplayModePage implements OnboardingPage { this.menu.setItems(values, index >= 0 ? index : values.indexOf("tall")); } - paint(image: GrayImage, focused: boolean): void { + paint(image: GrayImage, focused: boolean, padding: Edges): void { const top = drawPageHeading( image, + padding, "Display mode", "Swipe to choose how much of the display windows use; it changes as you go. Tap to continue.", ) + CONTENT_GAP; const body = onboardingFont("body"); // TTF widths are fractional; the menu's row images need whole pixels. - const columnWidth = Math.ceil(20 + Math.max(...this.menu.items.map((value) => body.measureText(displayLayoutSetting.displayValue(value))))); - const menuBox = { x: PAGE_X - 10, y: top, width: columnWidth, height: image.height - top - BOTTOM_MARGIN }; + const columnWidth = Math.ceil(2 * PAGE_TEXT_INSET + + Math.max(...this.menu.items.map((value) => body.measureText(displayLayoutSetting.displayValue(value))))); + // The list scrolls, so it runs to the window's bottom edge, with that + // edge's padding after its last row. + const menuBox = { x: padding.left, y: top, width: columnWidth, height: Math.max(0, image.height - top), padBottom: padding.bottom }; this.menu.paint(image, menuBox, focused); const layout = this.menu.selectedItem; if (layout === null) return; + // The description stays put beside the list, inside the right and bottom padding. const detail = onboardingFont("detail"); const left = menuBox.x + columnWidth + COLUMN_GAP; let y = top + LIST_ROW_TEXT_INSET; - for (const line of wrapText(detail, description(layout), image.width - PAGE_X - left)) { - if (y + detail.lineHeight > image.height - BOTTOM_MARGIN) break; + for (const line of wrapText(detail, description(layout), image.width - padding.right - PAGE_TEXT_INSET - left)) { + if (y + detail.lineHeight > image.height - padding.bottom) break; image.drawText(detail, left, y, line, 170); y += detail.lineHeight; } @@ -86,7 +91,7 @@ export class DisplayModePage implements OnboardingPage { } private drawRow({ image, item: layout, x, y, selected }: MenuDrawArgs): void { - image.drawText(onboardingFont("body"), x + 10, y + LIST_ROW_TEXT_INSET, displayLayoutSetting.displayValue(layout), selected ? 255 : 190); + image.drawText(onboardingFont("body"), x + PAGE_TEXT_INSET, y + LIST_ROW_TEXT_INSET, displayLayoutSetting.displayValue(layout), selected ? 255 : 190); } } diff --git a/app/apps/onboarding/ios-privacy-page.ts b/app/apps/onboarding/ios-privacy-page.ts deleted file mode 100644 index dd3b94c6..00000000 --- a/app/apps/onboarding/ios-privacy-page.ts +++ /dev/null @@ -1,43 +0,0 @@ -import { IOS_PRIVACY_NOTICE } from "../../analytics/privacy-disclosure"; -import type { GrayImage } from "../../graphics/image"; -import { wrapText } from "../../graphics/textwrap"; -import type { InputEvent } from "../../ui/gestures"; -import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; - -/** Paginate the notice so no disclosure is silently clipped on a short glasses viewport. */ -export class IosPrivacyPage implements OnboardingPage { - readonly immersive = true; - private page = 0; - private pageCount = 1; - - enter(): void { this.page = 0; } - - paint(image: GrayImage): void { - const top = drawPageHeading(image, "iOS / TestFlight privacy", "") + 8; - const font = onboardingFont("detail"); - const lines = IOS_PRIVACY_NOTICE.split("\n\n").flatMap((paragraph, index) => [ - ...(index ? [""] : []), ...wrapText(font, paragraph, image.width - 2 * PAGE_X), - ]); - const perPage = Math.max(1, Math.floor((image.height - top - font.lineHeight - 20) / font.lineHeight)); - this.pageCount = Math.ceil(lines.length / perPage); - this.page = Math.min(this.page, this.pageCount - 1); - lines.slice(this.page * perPage, (this.page + 1) * perPage).forEach((line, index) => { - image.drawText(font, PAGE_X, top + index * font.lineHeight, line, 200); - }); - const action = this.page + 1 < this.pageCount ? "Tap for more" : "Tap to choose statistics"; - image.drawText(font, PAGE_X, image.height - font.lineHeight - 8, - `${this.page + 1}/${this.pageCount} - ${action}`, 230); - } - - handleInput(event: InputEvent, nav: OnboardingNav): void { - if (event.type === "click") { - if (this.page + 1 < this.pageCount) this.page++; - else nav.next(); - } else if (event.type === "scroll-down" || event.type === "swipe-up") { - this.page = Math.min(this.page + 1, this.pageCount - 1); - } else if (event.type === "scroll-up" || event.type === "swipe-down") { - this.page = Math.max(0, this.page - 1); - } - } -} diff --git a/app/apps/onboarding/layout-diagram.ts b/app/apps/onboarding/layout-diagram.ts index 3ade4108..c92bda21 100644 --- a/app/apps/onboarding/layout-diagram.ts +++ b/app/apps/onboarding/layout-diagram.ts @@ -3,9 +3,9 @@ * page: to scale in real-display pixels, simplified, and drawn brighter * than the real chrome, which they shrink to a few pixels. */ -import { G2_LENS_WIDTH, type GrayImage } from "../../graphics/image"; +import type { GrayImage } from "../../graphics/image"; import { statusBarPositionSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; -import { SIDEBAR_WIDTH, SWITCHER_ROW_HEIGHT, MIN_WINDOW_HEIGHT, TOP_BAR_HEIGHT } from "../../ui/shell/geometry"; +import { MIN_WINDOW_HEIGHT, screenHeight, screenWidth, SIDEBAR_WIDTH, SWITCHER_ROW_HEIGHT, TOP_BAR_HEIGHT } from "../../ui/shell/geometry"; export const AREA_OUTLINE = 30; const CHROME_LINE = 100; @@ -80,14 +80,14 @@ export function drawLayout(d: Diagram, position: AppSwitcherPosition, band: Diag switch (position) { case "left": case "right": { - const stripLeft = position === "left" ? 0 : G2_LENS_WIDTH - SIDEBAR_WIDTH; + const stripLeft = position === "left" ? 0 : screenWidth() - SIDEBAR_WIDTH; const contentLeft = position === "left" ? SIDEBAR_WIDTH : 0; - const windowWidth = G2_LENS_WIDTH - SIDEBAR_WIDTH; + const windowWidth = screenWidth() - SIDEBAR_WIDTH; drawStatusBar(d, contentLeft, top, windowWidth, TOP_BAR_HEIGHT - 1); drawContent(d, contentLeft, top + TOP_BAR_HEIGHT, windowWidth, height - TOP_BAR_HEIGHT, 1); - // The strip keeps to the 288px band's height, even beside taller windows. + // The strip keeps to the min band's height (288px, or the whole short screen), even beside taller windows. const separator = position === "left" ? SIDEBAR_WIDTH - 1 : stripLeft; - d.vline(separator, top + TOP_BAR_HEIGHT, MIN_WINDOW_HEIGHT - TOP_BAR_HEIGHT, CHROME_LINE); + d.vline(separator, top + TOP_BAR_HEIGHT, diagramBandHeight("left") - TOP_BAR_HEIGHT, CHROME_LINE); // One column of icons against the separator. const column = position === "left" ? SIDEBAR_WIDTH - 36 : stripLeft; for (let slot = 0; slot < 4; slot++) drawIcon(d, column + 2, top + TOP_BAR_HEIGHT + 10 + slot * 40, slot === 0); @@ -131,11 +131,11 @@ export function drawLayout(d: Diagram, position: AppSwitcherPosition, band: Diag } } -/** A bottom row or popup layout's window: centred at 576 wide and framed, or the panel's width without a frame. */ +/** A bottom row or popup layout's window: centred, SIDEBAR_WIDTH narrower, framed; or the screen's width without a frame. */ function windowSpan(band: DiagramBand): { left: number; width: number; framed: boolean } { return band.fullWidth - ? { left: 0, width: G2_LENS_WIDTH, framed: false } - : { left: SIDEBAR_WIDTH / 2, width: G2_LENS_WIDTH - SIDEBAR_WIDTH, framed: true }; + ? { left: 0, width: screenWidth(), framed: false } + : { left: SIDEBAR_WIDTH / 2, width: screenWidth() - SIDEBAR_WIDTH, framed: true }; } /** @@ -173,5 +173,16 @@ function drawContent(d: Diagram, x: number, y: number, width: number, height: nu } } -/** Real-display rows the Layout page's diagrams cover: a 288px band and a bottom switcher row under it. */ -export const LAYOUT_AREA_HEIGHT = MIN_WINDOW_HEIGHT + SWITCHER_ROW_HEIGHT; +/** + * Real-display rows the Layout page's diagrams cover: a 288px band and a + * bottom switcher row under it, or the whole screen where that is shorter + * (the RayNeo iO's 220 rows). + */ +export function layoutAreaHeight(): number { + return Math.min(MIN_WINDOW_HEIGHT + SWITCHER_ROW_HEIGHT, screenHeight()); +} + +/** A layout's min-height band within the diagram area: 288px, less a bottom row where the screen is short. */ +export function diagramBandHeight(position: AppSwitcherPosition): number { + return Math.min(MIN_WINDOW_HEIGHT, layoutAreaHeight() - (position === "bottom" ? SWITCHER_ROW_HEIGHT : 0)); +} diff --git a/app/apps/onboarding/layout-page.ts b/app/apps/onboarding/layout-page.ts index 0d2eae6c..59cbbac0 100644 --- a/app/apps/onboarding/layout-page.ts +++ b/app/apps/onboarding/layout-page.ts @@ -1,14 +1,14 @@ -import { G2_LENS_WIDTH, type GrayImage, type UiFont } from "../../graphics/image"; -import { appSwitcherPositionSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; +import type { GrayImage, UiFont } from "../../graphics/image"; +import { appSwitcherPositionSetting, glassesTypeSetting, type AppSwitcherPosition } from "../../ui/dashboard-settings"; import type { InputEvent } from "../../ui/gestures"; import { MENU_HIGHLIGHT_FILL, MENU_HIGHLIGHT_STROKE } from "../../ui/menu-core"; -import { MIN_WINDOW_HEIGHT } from "../../ui/shell/geometry"; -import { AREA_OUTLINE, Diagram, drawLayout, LAYOUT_AREA_HEIGHT } from "./layout-diagram"; +import { screenWidth } from "../../ui/shell/geometry"; +import type { Edges } from "../../ui/viewport"; +import { AREA_OUTLINE, Diagram, diagramBandHeight, drawLayout, layoutAreaHeight } from "./layout-diagram"; import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { centredX, drawPageHeading, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const CONTENT_GAP = 10; -const BOTTOM_MARGIN = 8; /** Diagram width as a fraction of the display's: the most a diagram is drawn at. */ const DIAGRAM_SCALE = 0.4; /** Padding inside a cell's selection box, round the diagram and its caption. */ @@ -19,8 +19,13 @@ const ROW_GAP = 6; const DEPTH_SUBTITLE = "Customizable Depth"; /** Grid order, in rows of two: the layouts with depth on top. */ const LAYOUT_ORDER: readonly AppSwitcherPosition[] = ["bottom", "popup", "left", "right"]; -/** Selected on the first visit, and marked. */ -const RECOMMENDED_LAYOUT: AppSwitcherPosition = "bottom"; +/** + * Selected on the first visit, and marked: Bottom on the G2, whose 480 rows + * leave room for the row; a side strip on the RayNeo iO, whose 220 can't. + */ +export function recommendedLayout(): AppSwitcherPosition { + return glassesTypeSetting.get() === "rayneo-io" ? "left" : "bottom"; +} /** Whether a layout leaves the side margins the display's stereo depth shifts into (geometry.ts uiDepth). */ export function layoutHasDepth(position: AppSwitcherPosition): boolean { @@ -29,38 +34,42 @@ export function layoutHasDepth(position: AppSwitcherPosition): boolean { /** * The app switcher position, as a 2×2 grid of captioned diagrams of each - * layout, Bottom (recommended, and selected at first) and Popup on top; + * layout, Bottom and Popup on top, the recommended one selected at first; * swipes move through them in reading order, a tap saves the selected one. * The page is immersive, so the diagrams get 40% of the display's width - * each. Choosing a layout reflows open windows (the dashboard controller - * watches the setting). + * each. The grid is centred in the window, its cells' selection boxes + * keeping inside the padding of the window's edges. Choosing a layout + * reflows open windows (the dashboard controller watches the setting). */ export class LayoutPage implements OnboardingPage { readonly immersive = true; /** Kept across visits, so going back returns to the last choice. */ - private selected = LAYOUT_ORDER.indexOf(RECOMMENDED_LAYOUT); + private selected = LAYOUT_ORDER.indexOf(recommendedLayout()); - paint(image: GrayImage, focused: boolean): void { + paint(image: GrayImage, focused: boolean, padding: Edges): void { const top = drawPageHeading( image, + padding, "Layout", "Swipe to choose where the app switcher goes, then tap to continue.", ) + CONTENT_GAP; const title = onboardingFont("body"); const subtitle = onboardingFont("detail"); const captionHeight = CAPTION_GAP + title.lineHeight + subtitle.lineHeight; - const available = image.height - top - BOTTOM_MARGIN; + const available = image.height - top - padding.bottom; + const availableWidth = image.width - padding.left - padding.right; + // The most a diagram can take for two rows and two columns of cells to + // fit, in whole pixels, so rounding its size can't push the grid past + // the window's padding. + const maxDiagramHeight = Math.floor((available - ROW_GAP) / 2 - 2 * CELL_PADDING - captionHeight); + const maxDiagramWidth = Math.floor((availableWidth - COLUMN_GAP) / 2 - 2 * CELL_PADDING); // Short of DIAGRAM_SCALE only where two rows of cells wouldn't fit. - const scale = Math.min( - DIAGRAM_SCALE, - ((available - ROW_GAP) / 2 - 2 * CELL_PADDING - captionHeight) / LAYOUT_AREA_HEIGHT, - ((image.width - COLUMN_GAP) / 2 - 2 * CELL_PADDING) / G2_LENS_WIDTH, - ); - const diagramWidth = Math.round(G2_LENS_WIDTH * scale); - const diagramHeight = Math.round(LAYOUT_AREA_HEIGHT * scale); + const scale = Math.max(0, Math.min(DIAGRAM_SCALE, maxDiagramHeight / layoutAreaHeight(), maxDiagramWidth / screenWidth())); + const diagramWidth = Math.round(screenWidth() * scale); + const diagramHeight = Math.round(layoutAreaHeight() * scale); const cellWidth = diagramWidth + 2 * CELL_PADDING; const cellHeight = diagramHeight + 2 * CELL_PADDING + captionHeight; - const left = Math.round((image.width - 2 * cellWidth - COLUMN_GAP) / 2); + const left = centredX(image, padding, 2 * cellWidth + COLUMN_GAP); const gridTop = top + Math.max(0, Math.round((available - 2 * cellHeight - ROW_GAP) / 2)); LAYOUT_ORDER.forEach((position, index) => { const x = left + (index % 2) * (cellWidth + COLUMN_GAP); @@ -75,7 +84,7 @@ export class LayoutPage implements OnboardingPage { image.drawText(font, x + Math.round((cellWidth - font.measureText(text)) / 2), textY, text, value); const captionTop = y + CELL_PADDING + diagramHeight + CAPTION_GAP; const name = appSwitcherPositionSetting.displayValue(position); - const caption = position === RECOMMENDED_LAYOUT ? `${name} (Recommended)` : name; + const caption = position === recommendedLayout() ? `${name} (Recommended)` : name; centre(caption, title, captionTop, selected ? 255 : 190); if (layoutHasDepth(position)) { centre(DEPTH_SUBTITLE, subtitle, captionTop + title.lineHeight, selected ? 210 : 150); @@ -103,12 +112,14 @@ export class LayoutPage implements OnboardingPage { } /** - * A layout's diagram: the 288px band, with the popup switcher open. Only a - * bottom switcher row takes rows under the band; without one, the band sits - * centred in their place, as the band and row share the screen's slack. + * A layout's diagram: the min-height band, with the popup switcher open. + * Only a bottom switcher row takes rows under the band; without one, the + * band sits centred in their place, as the band and row share the screen's + * slack (none on a screen as short as the RayNeo iO's: the band fills it). */ function drawLayoutDiagram(d: Diagram, position: AppSwitcherPosition): void { - d.outline(0, 0, G2_LENS_WIDTH, LAYOUT_AREA_HEIGHT, AREA_OUTLINE, 12); - const top = position === "bottom" ? 0 : (LAYOUT_AREA_HEIGHT - MIN_WINDOW_HEIGHT) / 2; - drawLayout(d, position, { top, height: MIN_WINDOW_HEIGHT, fullWidth: false }, true); + d.outline(0, 0, screenWidth(), layoutAreaHeight(), AREA_OUTLINE, 12); + const height = diagramBandHeight(position); + const top = position === "bottom" ? 0 : (layoutAreaHeight() - height) / 2; + drawLayout(d, position, { top, height, fullWidth: false }, true); } diff --git a/app/apps/onboarding/onboarding-app.ts b/app/apps/onboarding/onboarding-app.ts index 66a7000d..4a6e713f 100644 --- a/app/apps/onboarding/onboarding-app.ts +++ b/app/apps/onboarding/onboarding-app.ts @@ -7,7 +7,6 @@ import { findSoundEffect, playSoundEffect } from "../../ui/sound-effects"; import { DataCollectionPage } from "./data-collection-page"; import { DepthPage } from "./depth-page"; import { DisplayModePage } from "./display-mode-page"; -import { IosPrivacyPage } from "./ios-privacy-page"; import { LayoutPage } from "./layout-page"; import { markGlassesOnboardingFinished, ONBOARDING_APP_ID } from "./onboarding-progress"; import type { OnboardingPage } from "./onboarding-page"; @@ -26,9 +25,7 @@ export const ONBOARDING_SURFACE_ID = "window:onboarding"; */ export function createOnboardingAppWindow(options: InProcessAppOptions): InProcessWindow { const pages: OnboardingPage[] = [ - new WelcomePage(), new TextSizePage(), - ...(global.isIOS ? [new IosPrivacyPage()] : []), - new DataCollectionPage(), new LayoutPage(), new DepthPage(), new DisplayModePage(), + new WelcomePage(), new TextSizePage(), new DataCollectionPage(), new LayoutPage(), new DepthPage(), new DisplayModePage(), ]; const app = createInProcessWindow({ appId: ONBOARDING_APP_ID, @@ -87,9 +84,9 @@ export class OnboardingLayer implements Layer { } paint(ctx: LayerContext): GrayImage { - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); - this.pages[this.index]!.paint(image, ctx.stack.isFocused()); + this.pages[this.index]!.paint(image, ctx.stack.isFocused(), padding); return image; } diff --git a/app/apps/onboarding/onboarding-page.ts b/app/apps/onboarding/onboarding-page.ts index 5081854d..460b3f19 100644 --- a/app/apps/onboarding/onboarding-page.ts +++ b/app/apps/onboarding/onboarding-page.ts @@ -1,6 +1,7 @@ import type { GrayImage } from "../../graphics/image"; import { wrapText } from "../../graphics/textwrap"; import type { InputEvent } from "../../ui/gestures"; +import type { Edges } from "../../ui/viewport"; import { onboardingFont } from "./onboarding-fonts"; /** Page-to-flow navigation, handed to a page's input handler. */ @@ -25,13 +26,31 @@ export interface OnboardingPage { applies?(): boolean; /** The page became current, going forward or back. */ enter?(): void; - paint(image: GrayImage, focused: boolean): void; + /** + * Paint the page over the whole image, the window's viewport. `padding` + * is the padding suggested for each of its edges (viewport.ts): none on an + * immersive page, whose edges are the screen's. + */ + paint(image: GrayImage, focused: boolean, padding: Edges): void; handleInput(event: InputEvent, nav: OnboardingNav): void | Promise; } -/** Left margin and title position shared by the pages (the UI-wide (18, 10) title spot). */ -export const PAGE_X = 18; -export const TITLE_Y = 10; +/** + * How far a page's text (its title and explanation, a list row's label) + * sits inside the side padding. A list's selection boxes start at the + * padding itself, so the title lines up with the rows' text. + */ +export const PAGE_TEXT_INSET = 10; +/** The title's drop below the top padding. */ +const TITLE_OFFSET_Y = 2; + +/** + * The x that centres something `width` wide in the window, short of + * entering either side's padding. + */ +export function centredX(image: GrayImage, padding: Edges, width: number): number { + return Math.max(padding.left, Math.min(image.width - padding.right - width, Math.round((image.width - width) / 2))); +} /** * Draw a page's title and its wrapped explanation (at most `maxLines` @@ -39,17 +58,21 @@ export const TITLE_Y = 10; */ export function drawPageHeading( image: GrayImage, + padding: Edges, title: string, explanation: string, maxLines = 2, ): number { const titleFont = onboardingFont("title"); const detailFont = onboardingFont("detail"); - image.drawText(titleFont, PAGE_X, TITLE_Y, title, 230); - let y = TITLE_Y + titleFont.lineHeight + 2; - const lines = wrapText(detailFont, explanation, image.width - 2 * PAGE_X).slice(0, maxLines); + const x = padding.left + PAGE_TEXT_INSET; + const textWidth = Math.max(0, image.width - padding.left - padding.right - 2 * PAGE_TEXT_INSET); + const titleY = padding.top + TITLE_OFFSET_Y; + image.drawText(titleFont, x, titleY, title, 230); + let y = titleY + titleFont.lineHeight + 2; + const lines = wrapText(detailFont, explanation, textWidth).slice(0, maxLines); for (const line of lines) { - image.drawText(detailFont, PAGE_X, y, line, 160); + image.drawText(detailFont, x, y, line, 160); y += detailFont.lineHeight; } return y; diff --git a/app/apps/onboarding/text-size-page.ts b/app/apps/onboarding/text-size-page.ts index 46498f45..69ff4f2b 100644 --- a/app/apps/onboarding/text-size-page.ts +++ b/app/apps/onboarding/text-size-page.ts @@ -3,6 +3,7 @@ import { installedFontPath } from "../../graphics/installed-fonts"; import { wrapText } from "../../graphics/textwrap"; import { TtfFont } from "../../graphics/ttf-font"; import { + defaultUiFontSize, fontSelectionLabel, getDefaultSmallFont, getUiFontSelection, @@ -13,11 +14,11 @@ import { FONT_SIZE_CHOICES } from "../../ui/font-picker"; import type { InputEvent } from "../../ui/gestures"; import { Menu, type MenuBox, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, listRowHeight } from "../../ui/metrics"; +import type { Edges } from "../../ui/viewport"; import { onboardingFont } from "./onboarding-fonts"; -import { drawPageHeading, PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { drawPageHeading, PAGE_TEXT_INSET, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const CONTENT_GAP = 10; -const BOTTOM_MARGIN = 8; const COLUMN_GAP = 12; const PREVIEW_PADDING = 10; const ROW_GAP = 2; @@ -25,8 +26,6 @@ const ROW_GAP = 2; const NOTE_GAP = 8; /** The sizes offered here; Settings has the full range. */ const SIZE_CHOICES = FONT_SIZE_CHOICES.filter((size) => size >= 12 && size <= 18); -/** Selected on the first visit, and marked. */ -const RECOMMENDED_SIZE = 16; const RECOMMENDED_NOTE = "Recommended"; /** Drawn while they fit, so smaller sizes visibly show more words. */ const PREVIEW_PARAGRAPHS = [ @@ -41,7 +40,8 @@ type Face = | { kind: "fixed"; label: string }; /** - * The UI font's size, 12 to 18px (16 recommended, and selected at first), + * The UI font's size, 12 to 18px (the default size recommended, and + * selected at first: 16px, or 14px on the RayNeo iO), * beside a preview of text in the selected size. The face and weight stay * as they are (they live in the Settings font picker); a bitmap face has * only one size, so the page just says so. The size is saved on tap, not @@ -67,7 +67,7 @@ export class TextSizePage implements OnboardingPage { if (sizes.length) { this.face = { kind: "sized", file: selection.file, path, sizes }; // The recommended size the first time; on a return, what was left selected. - this.sizeMenu.setItems(sizes, nearestIndex(sizes, this.sizeMenu.selectedItem ?? RECOMMENDED_SIZE)); + this.sizeMenu.setItems(sizes, nearestIndex(sizes, this.sizeMenu.selectedItem ?? defaultUiFontSize())); return; } } @@ -75,39 +75,40 @@ export class TextSizePage implements OnboardingPage { this.face = { kind: "fixed", label: selection.kind === "bitmap" ? fontSelectionLabel(selection) : "Terminus" }; } - paint(image: GrayImage, focused: boolean): void { + paint(image: GrayImage, focused: boolean, padding: Edges): void { + // The preview's frame keeps inside the padding of the window's edges. + const right = image.width - padding.right; + const bottom = image.height - padding.bottom; if (this.face.kind === "fixed") { const top = drawPageHeading( image, + padding, "Text size", `Your UI font, ${this.face.label}, comes in one size. To choose a size, pick a different font in ` + "Settings > Customization. Tap to continue.", 3, ) + CONTENT_GAP; - drawPreview(image, getDefaultSmallFont(), { - x: PAGE_X - 10, - y: top, - width: image.width - 2 * (PAGE_X - 10), - height: image.height - top - BOTTOM_MARGIN, - }); + drawPreview(image, getDefaultSmallFont(), { x: padding.left, y: top, width: right - padding.left, height: bottom - top }); return; } const top = drawPageHeading( image, + padding, "Text size", "Swipe to choose a size, then tap to continue. The typeface and weight can be changed in Settings.", ) + CONTENT_GAP; - const height = image.height - top - BOTTOM_MARGIN; const body = onboardingFont("body"); // TTF widths are fractional; the menu's row images need whole pixels. - const columnWidth = Math.ceil(20 + Math.max(...this.face.sizes.map((size) => body.measureText(sizeLabel(size)))) + + const columnWidth = Math.ceil(2 * PAGE_TEXT_INSET + Math.max(...this.face.sizes.map((size) => body.measureText(sizeLabel(size)))) + NOTE_GAP + onboardingFont("detail").measureText(RECOMMENDED_NOTE)); - const menuBox = { x: PAGE_X - 10, y: top, width: columnWidth, height }; + // The list scrolls, so it runs to the window's bottom edge, with that + // edge's padding after its last row. + const menuBox = { x: padding.left, y: top, width: columnWidth, height: Math.max(0, image.height - top), padBottom: padding.bottom }; this.sizeMenu.paint(image, menuBox, focused); const previewX = menuBox.x + menuBox.width + COLUMN_GAP; const size = this.sizeMenu.selectedItem; const font = (size !== null ? TtfFont.load(this.face.path, size) : null) ?? getDefaultSmallFont(); - drawPreview(image, font, { x: previewX, y: top, width: image.width - (PAGE_X - 10) - previewX, height }); + drawPreview(image, font, { x: previewX, y: top, width: right - previewX, height: bottom - top }); } handleInput(event: InputEvent, nav: OnboardingNav): void { @@ -136,11 +137,11 @@ export class TextSizePage implements OnboardingPage { private drawSizeRow({ image, item: size, x, y, height, selected }: MenuDrawArgs): void { const body = onboardingFont("body"); const label = sizeLabel(size); - image.drawText(body, x + 10, y + LIST_ROW_TEXT_INSET, label, selected ? 255 : 190); - if (size !== RECOMMENDED_SIZE) return; + image.drawText(body, x + PAGE_TEXT_INSET, y + LIST_ROW_TEXT_INSET, label, selected ? 255 : 190); + if (size !== defaultUiFontSize()) return; const detail = onboardingFont("detail"); const noteY = y + Math.round((height - detail.lineHeight) / 2); - image.drawText(detail, x + 10 + body.measureText(label) + NOTE_GAP, noteY, RECOMMENDED_NOTE, selected ? 210 : 150); + image.drawText(detail, x + PAGE_TEXT_INSET + body.measureText(label) + NOTE_GAP, noteY, RECOMMENDED_NOTE, selected ? 210 : 150); } } diff --git a/app/apps/onboarding/welcome-page.ts b/app/apps/onboarding/welcome-page.ts index 4d9c62b4..bfec82dd 100644 --- a/app/apps/onboarding/welcome-page.ts +++ b/app/apps/onboarding/welcome-page.ts @@ -2,31 +2,35 @@ import type { GrayImage, UiFont } from "../../graphics/image"; import { getFullLogo } from "../../graphics/logo"; import { wrapText } from "../../graphics/textwrap"; import type { InputEvent } from "../../ui/gestures"; +import type { Edges } from "../../ui/viewport"; import { FACECLAW_VERSION } from "../../version"; import { onboardingFont } from "./onboarding-fonts"; -import { PAGE_X, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; +import { centredX, type OnboardingNav, type OnboardingPage } from "./onboarding-page"; const LOGO_MAX_HEIGHT = 180; -const LOGO_MARGIN = 12; const LOGO_TEXT_GAP = 28; const PROMPT_GAP = 22; const PROMPT = "Tap the ring or touchpad to continue"; type TextLine = { font: UiFont; text: string; value: number; spaceBefore: number }; -/** The splash: logo beside the name, version and how to go on, centred as one group. */ +/** + * The splash: logo beside the name, version and how to go on, centred in + * the window as one group, which keeps inside the padding of its edges. + */ export class WelcomePage implements OnboardingPage { readonly immersive = true; - paint(image: GrayImage): void { + paint(image: GrayImage, _focused: boolean, padding: Edges): void { const { width, height } = image; - const logo = getFullLogo(Math.min(LOGO_MAX_HEIGHT, height - 2 * LOGO_MARGIN)); + const availableWidth = Math.max(0, width - padding.left - padding.right); + const logo = getFullLogo(Math.min(LOGO_MAX_HEIGHT, height - padding.top - padding.bottom)); const logoWidth = logo ? logo.width + LOGO_TEXT_GAP : 0; const body = onboardingFont("body"); const lines: TextLine[] = [ { font: onboardingFont("hero"), text: "Faceclaw", value: 240, spaceBefore: 0 }, { font: body, text: `Version ${FACECLAW_VERSION}`, value: 150, spaceBefore: 0 }, - ...wrapText(body, PROMPT, width - 2 * PAGE_X - logoWidth).map((text, index) => ({ + ...wrapText(body, PROMPT, availableWidth - logoWidth).map((text, index) => ({ font: body, text, value: 215, @@ -35,7 +39,7 @@ export class WelcomePage implements OnboardingPage { ]; const textWidth = Math.max(...lines.map((line) => line.font.measureText(line.text))); const textHeight = lines.reduce((total, line) => total + line.spaceBefore + line.font.lineHeight, 0); - const left = Math.max(PAGE_X, Math.round((width - logoWidth - textWidth) / 2)); + const left = centredX(image, padding, logoWidth + textWidth); if (logo) { image.bitBlt(logo, left, Math.round((height - logo.height) / 2), { transparentZero: true }); } diff --git a/app/apps/pinball/pinball-app.worker.ts b/app/apps/pinball/pinball-app.worker.ts index 8ff5a1bb..aba49b78 100644 --- a/app/apps/pinball/pinball-app.worker.ts +++ b/app/apps/pinball/pinball-app.worker.ts @@ -37,6 +37,7 @@ import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { type MenuItem } from "../../ui/menu"; import { WindowMenu } from "../../ui/window-menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import { directionalFallback, GESTURE_CLICK, @@ -250,6 +251,13 @@ type PinballWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there. The window menu's layers + * lay out by it; the table and its panel are fixed art, drawn at the + * coordinates the physics runs in (see LAYOUT_HEIGHT). + */ + viewport: Viewport; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; @@ -314,6 +322,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -416,13 +425,15 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); + window.viewport = message.viewport; + window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; if (window.foreground) renderAndSubmit(window, 0); break; } case "navigation-sensors": case "text-input": + case "key": case "tool-call": break; } @@ -507,7 +518,7 @@ function windowMenu(window: PinballWindow): WindowMenu { post, title: () => window.title, items: () => (window.phase === "playing" ? [] : windowMenuItems(window)), - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: window.viewport, paintBase: () => paintContent(window), isFocused: () => window.focused, }); diff --git a/app/apps/roam/roam-app.worker.ts b/app/apps/roam/roam-app.worker.ts index a06be8bc..b3564c7d 100644 --- a/app/apps/roam/roam-app.worker.ts +++ b/app/apps/roam/roam-app.worker.ts @@ -22,6 +22,7 @@ import type { MenuItem } from "../../ui/menu"; import { WindowMenu } from "../../ui/window-menu"; import { DatePickerLayer } from "../../ui/date-picker"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; +import type { Viewport } from "../../ui/viewport"; import type { ToolResult, ToolSpec } from "../../assistant/tool-registry"; import { GESTURE_CLICK, type InputEvent } from "../../ui/gestures"; import { @@ -29,7 +30,7 @@ import { roamGraphNameSetting, type ConfigSettingString, } from "../../ui/dashboard-settings"; -import { DocumentView } from "../../ui/document/document-view"; +import { DocumentView, type DocumentViewSize } from "../../ui/document/document-view"; import { docNodePageLink, type DocNode } from "../../ui/document/document-model"; import { createBlock, @@ -56,9 +57,18 @@ import { declare const global: any; -const HEADER_HEIGHT = 30; -const BOTTOM_MARGIN = 6; -const DOC_MARGIN = 6; +/** + * The fixed header, measured down from the padding suggested for the + * window's top edge: the rule under its title line, and its bottom, where + * the page's body starts. + */ +const HEADER_RULE_Y = 20; +const HEADER_HEIGHT = 24; +/** The header's title starts this far right of the rule's left end. */ +const TITLE_INSET = 2; +/** Message text (the body messages, the setting-edit screen): its indent from the padding at each side, and its drop below the header. */ +const MESSAGE_INSET = 12; +const MESSAGE_DROP = 16; /** Reload the shown page when it is foregrounded and older than this. */ const STALE_AFTER_MS = 60_000; @@ -70,6 +80,12 @@ type RoamWindow = { title: string; viewportWidth: number; viewportHeight: number; + /** + * The viewport as the shell last sent it: besides the size above, what each + * edge touches and the padding suggested there, which the header and the + * document are placed by (see documentBox). + */ + viewport: Viewport; foreground: boolean; focused: boolean; menu: WindowMenu | null; @@ -181,13 +197,11 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, - view: new DocumentView( - message.viewport.width - DOC_MARGIN * 2, - message.viewport.height - HEADER_HEIGHT - BOTTOM_MARGIN, - ), + view: new DocumentView(documentBox(message.viewport)), lastSubmittedFingerprint: "", }; post({ type: "set-tools", windowId: message.windowId, tools: ROAM_TOOLS }); @@ -213,6 +227,9 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { frameTimings.logFrame(message.frameId, `input received in ${message.windowId} worker`); handleInput(window, message.event as InputEvent, message.frameId); break; + case "key": + // Only windows opened with acceptsKeys are sent keys. + break; case "text-input": if (editingSetting) { // Voice input as an alternative to the phone keyboard. @@ -258,7 +275,8 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { if (!window || window.windowId !== message.windowId) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; - window.view.resize(message.viewport.width - DOC_MARGIN * 2, message.viewport.height - HEADER_HEIGHT - BOTTOM_MARGIN); + window.viewport = message.viewport; + window.view.resize(documentBox(message.viewport)); window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; render(); @@ -357,7 +375,7 @@ function windowMenu(win: RoamWindow): WindowMenu { post, title: () => win.title, items: () => menuItems(), - size: { width: win.viewportWidth, height: win.viewportHeight }, + size: win.viewport, paintBase: () => paintContent(win), isFocused: () => win.focused, }); @@ -631,65 +649,97 @@ function paint(win: RoamWindow): Plane[] { ); } +/** Bottom of the fixed header, where the page's body starts. */ +function headerBottom(viewport: Viewport): number { + return viewport.padding.top + HEADER_HEIGHT; +} + +/** + * The document's region: from the header down to the window's bottom edge, + * between the padding suggested for its sides. The document scrolls, so the + * bottom edge's padding goes inside it, after its last line, and lines + * scrolled past use the room right up to the edge. + */ +function documentBox(viewport: Viewport): DocumentViewSize & { x: number; y: number } { + const { width, height, padding } = viewport; + const y = headerBottom(viewport); + return { + x: padding.left, + y, + width: Math.max(0, width - padding.left - padding.right), + height: Math.max(0, height - y), + padBottom: padding.bottom, + }; +} + +/** Where message text starts and how wide it may run. */ +function messageText(viewport: Viewport): { x: number; width: number } { + const { width, padding } = viewport; + return { x: padding.left + MESSAGE_INSET, width: width - padding.left - padding.right - 2 * MESSAGE_INSET }; +} + +/** + * The header's title, at the padding suggested for the window's top edge, + * and the rule under it, which spans the window between the side padding. + */ +function drawHeader(image: GrayImage, viewport: Viewport, title: string): void { + const { width, padding } = viewport; + image.drawText(smallFont, padding.left + TITLE_INSET, padding.top, title, 225); + const ruleY = padding.top + HEADER_RULE_Y; + image.drawLine(padding.left, ruleY, width - padding.right - 1, ruleY, 40); +} + /** The "type on the phone" screen shown while a Roam setting is being edited. */ function paintSettingEdit(win: RoamWindow, setting: ConfigSettingString): GrayImage { + const { height, padding } = win.viewport; const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); const step = smallFont.lineHeight + 2; - image.drawText(smallFont, DOC_MARGIN + 2, 6, setting.glassesEditTitle, 225); - image.drawLine(DOC_MARGIN, HEADER_HEIGHT - 4, win.viewportWidth - DOC_MARGIN, HEADER_HEIGHT - 4, 40); - const messageY = HEADER_HEIGHT + 16; - const lines = wrapText(smallFont, "Type the value in the phone app, or use voice input.", win.viewportWidth - DOC_MARGIN * 2 - 24); + drawHeader(image, win.viewport, setting.glassesEditTitle); + const text = messageText(win.viewport); + const messageY = headerBottom(win.viewport) + MESSAGE_DROP; + const lines = wrapText(smallFont, "Type the value in the phone app, or use voice input.", text.width); for (let index = 0; index < lines.length; index++) { - image.drawText(smallFont, DOC_MARGIN + 12, messageY + index * step, lines[index]!, 190); + image.drawText(smallFont, text.x, messageY + index * step, lines[index]!, 190); } // The live value, unmasked so the user can check what they typed. const value = setting.get(); const valueY = messageY + (lines.length + 1) * step; - image.drawText( - smallFont, - DOC_MARGIN + 12, - valueY, - truncateText(smallFont, value || "(empty)", win.viewportWidth - DOC_MARGIN * 2 - 24), - value ? 225 : 130, - ); - image.drawText(smallFont, DOC_MARGIN + 12, win.viewportHeight - smallFont.lineHeight - 12, `${GESTURE_CLICK} done`, 110); + image.drawText(smallFont, text.x, valueY, truncateText(smallFont, value || "(empty)", text.width), value ? 225 : 130); + // The hint line rests on the padding suggested for the window's bottom edge. + image.drawText(smallFont, text.x, height - padding.bottom - smallFont.lineHeight, `${GESTURE_CLICK} done`, 110); return image; } function paintContent(win: RoamWindow): GrayImage { + const { width, padding } = win.viewport; const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); const title = currentRef?.title ?? "Roam"; const status = loading ? "Loading..." : pageMissing ? "(new page)" : ""; const statusWidth = status ? smallFont.measureText(status) + 12 : 0; - image.drawText( - smallFont, - DOC_MARGIN + 2, - 6, - truncateText(smallFont, title, win.viewportWidth - DOC_MARGIN * 2 - statusWidth - 4), - 225, - ); + const titleWidth = width - padding.left - padding.right - statusWidth - 2 * TITLE_INSET; + drawHeader(image, win.viewport, truncateText(smallFont, title, titleWidth)); if (status) { - image.drawText(smallFont, win.viewportWidth - DOC_MARGIN - smallFont.measureText(status), 6, status, 130); + image.drawText(smallFont, width - padding.right - smallFont.measureText(status), padding.top, status, 130); } - image.drawLine(DOC_MARGIN, HEADER_HEIGHT - 4, win.viewportWidth - DOC_MARGIN, HEADER_HEIGHT - 4, 40); if (!isRoamConfigured()) { - drawBodyMessage(image, win, "Set the Roam graph name and API token: tap, then hold, for the menu; pick Set graph name and Set API token."); + drawBodyMessage(image, win.viewport, "Set the Roam graph name and API token: tap, then hold, for the menu; pick Set graph name and Set API token."); } else if (errorMessage) { - drawBodyMessage(image, win, `${errorMessage}\n\n${GESTURE_CLICK} retry`); + drawBodyMessage(image, win.viewport, `${errorMessage}\n\n${GESTURE_CLICK} retry`); } else if (currentPage && currentPage.children.length === 0 && !loading) { - drawBodyMessage(image, win, "Nothing here yet. Use voice input to add a todo."); + drawBodyMessage(image, win.viewport, "Nothing here yet. Use voice input to add a todo."); } else { - win.view.paint(image, DOC_MARGIN, HEADER_HEIGHT, win.focused); + const box = documentBox(win.viewport); + win.view.paint(image, box.x, box.y, win.focused); } return image; } -function drawBodyMessage(image: GrayImage, win: RoamWindow, message: string): void { - const lines = wrapText(smallFont, message, win.viewportWidth - DOC_MARGIN * 2 - 24); - let y = HEADER_HEIGHT + 16; - for (const line of lines) { - image.drawText(smallFont, DOC_MARGIN + 12, y, line, 190); +function drawBodyMessage(image: GrayImage, viewport: Viewport, message: string): void { + const text = messageText(viewport); + let y = headerBottom(viewport) + MESSAGE_DROP; + for (const line of wrapText(smallFont, message, text.width)) { + image.drawText(smallFont, text.x, y, line, 190); y += smallFont.lineHeight + 2; } } diff --git a/app/apps/t3code/t3code-app.worker.ts b/app/apps/t3code/t3code-app.worker.ts index ec2697fc..305c0332 100644 --- a/app/apps/t3code/t3code-app.worker.ts +++ b/app/apps/t3code/t3code-app.worker.ts @@ -43,6 +43,7 @@ import { drawSubmenuIndicator, submenuItem, type MenuItem } from "../../ui/menu" import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, lineStep, listRowHeight } from "../../ui/metrics"; import { WindowMenu, WindowMenuLayer } from "../../ui/window-menu"; +import type { Viewport } from "../../ui/viewport"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; import type { ToolResult, ToolSpec } from "../../assistant/tool-registry"; import { GESTURE_CLICK, GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures"; @@ -131,12 +132,27 @@ const VISIT_THROTTLE_MS = 10_000; /** How long a transient status ("Sent", an error) stays in a footer. */ const NOTICE_MS = 6_000; const SETTLED_SHOWN = 25; -const LIST_LEFT = 12; -const LIST_RIGHT = 20; -const TITLE_X = 18; -const TITLE_Y = 10; -const BODY_LEFT = 14; -const BODY_RIGHT = 18; +// Every screen lays out inside the padding suggested for its window's edges +// (viewport.ts); these are offsets from it. +/** + * A list screen's title: how far right of the rows' selection boxes, which + * start at the left padding (so it lines up with their text), and how far + * below the top padding. + */ +const LIST_TITLE_INSET_X = 6; +const LIST_TITLE_OFFSET_Y = 2; +/** Between a title and a status that shares its row. */ +const TITLE_STATUS_GAP = 16; +/** Below a title's line: the gap before the list's first text line, and how far above that line its selection box starts. */ +const LIST_TITLE_GAP = 8; +const LIST_LEAD = 2; +/** A list's scrollbar (Menu.drawScrollbar's bar), hugging the right padding, and the gap the rows keep from it. */ +const LIST_SCROLLBAR_WIDTH = 3; +const LIST_SCROLLBAR_GAP = 10; +/** How far a list's scrollbar track stops short of the rows' span at each end. */ +const LIST_SCROLLBAR_INSET = 2; +/** Between a list and lines of text pinned under it. */ +const LIST_FOOTER_GAP = 6; function font(): UiFont { return getDefaultSmallFont(); @@ -155,8 +171,8 @@ type Screen = type AppWindow = { windowId: string; surfaceId: string; - viewportWidth: number; - viewportHeight: number; + /** The window's size, what its edges touch and their padding, as of the last open or resize message. */ + viewport: Viewport; foreground: boolean; focused: boolean; menu: WindowMenu | null; @@ -365,8 +381,7 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { window = { windowId: message.windowId, surfaceId: message.surfaceId, - viewportWidth: message.viewport.width, - viewportHeight: message.viewport.height, + viewport: message.viewport, foreground: false, focused: false, menu: null, @@ -379,8 +394,9 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { break; case "resize-window": if (!window || window.windowId !== message.windowId) break; - window.viewportWidth = message.viewport.width; - window.viewportHeight = message.viewport.height; + // A new size, or the same size with different edges (so padding): + // either way every screen lays out again. + window.viewport = message.viewport; window.menu?.resize(message.viewport); window.lastSubmittedFingerprint = ""; render(); @@ -408,6 +424,9 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { frameTimings.logFrame(message.frameId, `input received in ${message.windowId} worker`); handleInput(window, message.event as InputEvent, message.frameId); break; + case "key": + // Only windows opened with acceptsKeys are sent keys. + break; case "text-input": if (window && window.windowId === message.windowId) handleTextInput(message.text.trim()); break; @@ -760,7 +779,7 @@ function windowMenu(win: AppWindow): WindowMenu { post, title: () => (screen.kind === "thread" ? threadTitle() : APP_TITLE), items: () => menuItems(), - size: { width: win.viewportWidth, height: win.viewportHeight }, + size: win.viewport, paintBase: () => paintContent(win), isFocused: () => win.focused, }); @@ -1886,49 +1905,110 @@ function listStatusLine(): string { return glanceSummary({ needsYou: needs, working }); } +/** + * Paint a list screen's title, and a dim status beside it, inside the + * window's top padding. Returns the title's x (other text on the screen + * lines up with it) and the y of the first text line below it. + */ +function paintListTitle(image: GrayImage, viewport: Viewport, title: string, status: string): { x: number; listTop: number } { + const f = font(); + const { width, padding } = viewport; + const x = padding.left + LIST_TITLE_INSET_X; + const y = padding.top + LIST_TITLE_OFFSET_Y; + image.drawText(f, x, y, title, 220); + if (status) { + const statusX = x + f.measureText(title) + TITLE_STATUS_GAP; + image.drawText(f, statusX, y, truncateText(f, status, width - padding.right - statusX), 150); + } + return { x, listTop: y + lineStep(f) + LIST_TITLE_GAP }; +} + +/** Where a list's scrollbar starts: it hugs the window's right padding. */ +function listScrollbarX(viewport: Viewport): number { + return viewport.width - viewport.padding.right - LIST_SCROLLBAR_WIDTH; +} + +/** Width of a list's rows, from the window's left padding to the scrollbar's gutter. */ +function listRowsWidth(viewport: Viewport): number { + return Math.max(0, listScrollbarX(viewport) - LIST_SCROLLBAR_GAP - viewport.padding.left); +} + +/** + * Paint the list from just above the text line at `listTop` down to the + * window's bottom edge, or to above the text pinned under it at `footerTop`. + * The list scrolls, so at the window's edge it takes that edge's padding + * inside it, after its last row: the row rests clear of a border there, and + * rows scrolled past the end are cut off at the edge itself. + */ +function paintListRows(win: AppWindow, image: GrayImage, menu: Menu, listTop: number, footerTop?: number): void { + const { height, padding } = win.viewport; + const toEdge = footerTop === undefined; + const boxTop = listTop - LIST_LEAD; + const boxBottom = toEdge ? height : footerTop - LIST_FOOTER_GAP; + // Where the last row ends once scrolled to it. + const rowsBottom = toEdge ? height - padding.bottom : boxBottom; + menu.paint( + image, + { x: padding.left, y: boxTop, width: listRowsWidth(win.viewport), height: Math.max(0, boxBottom - boxTop), padBottom: toEdge ? padding.bottom : 0 }, + win.focused, + ); + const trackTop = boxTop + LIST_SCROLLBAR_INSET; + menu.drawScrollbar(image, listScrollbarX(win.viewport), trackTop, Math.max(0, rowsBottom - LIST_SCROLLBAR_INSET - trackTop)); +} + function paintList(win: AppWindow, mode: "list" | "environments"): GrayImage { - const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); + const { width, height, padding } = win.viewport; + const image = new GrayImage(width, height, 0); const f = font(); const step = lineStep(f); const title = mode === "environments" ? "T3 Code - Environments" : APP_TITLE; - image.drawText(f, TITLE_X, TITLE_Y, title, 220); const status = mode === "list" ? listStatusLine() : notice?.text ?? ""; - if (status) { - const statusX = TITLE_X + f.measureText(title) + 16; - image.drawText(f, statusX, TITLE_Y, truncateText(f, status, win.viewportWidth - statusX - 14), 150); - } - let listTop = TITLE_Y + step + 8; + const header = paintListTitle(image, win.viewport, title, status); + let listTop = header.listTop; if (mode === "list" && clients.size === 0) { const help = wrapText( f, "Run `t3 pair` on the computer running T3 Code (serve it on your network with `t3 serve --host 0.0.0.0`, or use Tailscale), then pick Pair below and paste the link into the phone app.", - win.viewportWidth - TITLE_X * 2, + width - padding.right - header.x, ); - help.forEach((line, index) => image.drawText(f, TITLE_X, listTop + index * step, line, 160)); + help.forEach((line, index) => image.drawText(f, header.x, listTop + index * step, line, 160)); listTop += help.length * step + 8; } const items = mode === "environments" ? environmentItems() : listItems(); const menu = list(); menu.setItems(items, selectionIndex(items)); listSelectionKey = menu.selectedItem?.key ?? listSelectionKey; - const listHeight = win.viewportHeight - 6 - listTop; - menu.paint(image, { x: LIST_LEFT, y: listTop - 2, width: win.viewportWidth - LIST_LEFT - LIST_RIGHT, height: listHeight }, win.focused); - menu.drawScrollbar(image, win.viewportWidth - 10, listTop, listHeight - 4); + paintListRows(win, image, menu, listTop); return image; } -const THREAD_HEADER_HEIGHT = 28; +/** The thread screen's header, below its title's top: the rule under the title, and the transcript's first line. */ +const THREAD_RULE_OFFSET = 18; +const THREAD_BODY_OFFSET = 26; +/** How far the thread screen's text sits inside the ends of its header rule. */ +const THREAD_TEXT_INSET = 2; +/** The transcript's scrollbar, hugging the window's right padding, and the gap the header rule keeps from it. */ +const THREAD_SCROLLBAR_WIDTH = 2; +const THREAD_SCROLLBAR_GAP = 8; +/** Between the transcript and the footer under it. */ +const THREAD_FOOTER_GAP = 4; +/** The transcript's top: its header stays put above it, inside the window's top padding. */ function threadBodyTop(): number { - return THREAD_HEADER_HEIGHT + 4; + return (window?.viewport.padding.top ?? 0) + THREAD_BODY_OFFSET; } -/** Body height above the footer (hint line, plus a plan line when there is one). */ +/** + * Body height above the footer (hint line, plus a plan line when there is + * one), whose last line rests on the window's bottom padding. + */ function threadBodyHeight(): number { if (!window) return 0; - const step = lineStep(font()); + const f = font(); + const { height, padding } = window.viewport; const footerLines = threadView?.handle.model.todoList() && currentShellThread() && threadStatus(currentShellThread()!) === "working" ? 2 : 1; - return window.viewportHeight - threadBodyTop() - footerLines * step - 8; + const footerTop = height - padding.bottom - f.lineHeight - (footerLines - 1) * lineStep(f); + return footerTop - THREAD_FOOTER_GAP - threadBodyTop(); } function threadFooterHint(): { text: string; value: number } { @@ -1948,18 +2028,28 @@ function threadFooterHint(): { text: string; value: number } { } function paintThread(win: AppWindow): GrayImage { - const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); + const { width: windowWidth, height, padding } = win.viewport; + const image = new GrayImage(windowWidth, height, 0); const view = threadView; const f = font(); const step = lineStep(f); - const width = win.viewportWidth - BODY_LEFT - BODY_RIGHT; + // The header rule runs from the window's left padding to the gutter kept + // for the scrollbar, which hugs the right padding; text sits just inside + // the rule's ends. + const scrollbarX = windowWidth - padding.right - THREAD_SCROLLBAR_WIDTH; + const ruleLeft = padding.left; + const ruleRight = scrollbarX - THREAD_SCROLLBAR_GAP; + const left = ruleLeft + THREAD_TEXT_INSET; + const right = ruleRight - THREAD_TEXT_INSET; + const width = Math.max(0, right - left); if (!view) return image; const shell = currentShellThread(); const status = shell ? threadStatusLabel(threadStatus(shell)) : ""; const statusWidth = status ? f.measureText(status) + 12 : 0; - image.drawText(f, BODY_LEFT, 6, truncateText(f, threadTitle(), width - statusWidth), 225); - if (status) image.drawText(f, win.viewportWidth - BODY_RIGHT - f.measureText(status), 6, status, 150); - image.drawLine(BODY_LEFT - 2, THREAD_HEADER_HEIGHT - 4, win.viewportWidth - BODY_RIGHT + 2, THREAD_HEADER_HEIGHT - 4, 40); + const titleY = padding.top; + image.drawText(f, left, titleY, truncateText(f, threadTitle(), width - statusWidth), 225); + if (status) image.drawText(f, right - f.measureText(status), titleY, status, 150); + image.drawLine(ruleLeft, titleY + THREAD_RULE_OFFSET, ruleRight, titleY + THREAD_RULE_OFFSET, 40); const model = view.handle.model; const bodyTop = threadBodyTop(); @@ -1967,9 +2057,9 @@ function paintThread(win: AppWindow): GrayImage { const visible = Math.max(1, Math.floor(bodyHeight / step)); if (model.sequence === null) { const client = clients.get(view.envId); - image.drawText(f, BODY_LEFT, bodyTop, client?.ready ? "Loading…" : client?.status || "Not connected", 150); + image.drawText(f, left, bodyTop, client?.ready ? "Loading…" : client?.status || "Not connected", 150); } else if (model.deleted) { - image.drawText(f, BODY_LEFT, bodyTop, "This thread was deleted.", 150); + image.drawText(f, left, bodyTop, "This thread was deleted.", 150); } else { const lines = view.layout.layout(timelineEntries(model), f, width); if (model.hasMoreHistory) lines.unshift({ text: "(earlier messages on the computer)", value: 90, indent: 0 }, { text: "", value: 0, indent: 0 }); @@ -1978,21 +2068,22 @@ function paintThread(win: AppWindow): GrayImage { const first = view.firstLine ?? view.maxFirstLine; for (let row = 0; row < visible; row++) { const line = lines[first + row]; - if (line?.text) image.drawText(f, BODY_LEFT + line.indent, bodyTop + row * step, line.text, line.value); + if (line?.text) image.drawText(f, left + line.indent, bodyTop + row * step, line.text, line.value); } if (view.maxFirstLine > 0) { const track = visible * step; const thumb = Math.max(8, Math.floor((track * visible) / lines.length)); - image.fillRect(win.viewportWidth - 8, bodyTop + Math.floor(((track - thumb) * first) / view.maxFirstLine), 2, thumb, 110); + image.fillRect(scrollbarX, bodyTop + Math.floor(((track - thumb) * first) / view.maxFirstLine), THREAD_SCROLLBAR_WIDTH, thumb, 110); } } - // Footer: the agent's plan progress while it works, then the hint/status line. - let footerY = win.viewportHeight - step - 4; + // Footer: the agent's plan progress while it works, then the hint/status + // line, resting on the window's bottom padding. + let footerY = height - padding.bottom - f.lineHeight; const hint = threadFooterHint(); if (hint.text) { const text = truncateText(f, hint.text, width); - image.drawText(f, win.viewportWidth - BODY_RIGHT - f.measureText(text), footerY, text, hint.value); + image.drawText(f, right - f.measureText(text), footerY, text, hint.value); } const todo = model.todoList(); if (todo && shell && threadStatus(shell) === "working") { @@ -2001,28 +2092,38 @@ function paintThread(win: AppWindow): GrayImage { const done = steps.filter((entry) => entry.status === "completed").length; const current = steps.find((entry) => entry.status === "running") ?? steps.find((entry) => entry.status === "pending"); const text = `Plan ${done}/${steps.length}${current ? ` · ${plainMarkdown(current.text)}` : ""}`; - image.drawText(f, BODY_LEFT, footerY, truncateText(f, text, width), 160); + image.drawText(f, left, footerY, truncateText(f, text, width), 160); } return image; } +/** + * A screen of text: a title, paragraphs wrapped to the window, and a hint + * line. With no rows to line up with, the text sits right at the window's + * padding on every side. + */ function paintMessageScreen(win: AppWindow, title: string, paragraphs: Array<{ text: string; value: number }>, footer: string): GrayImage { - const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); + const { width: windowWidth, height, padding } = win.viewport; + const image = new GrayImage(windowWidth, height, 0); const f = font(); const step = lineStep(f); - const width = win.viewportWidth - TITLE_X * 2; - image.drawText(f, TITLE_X, TITLE_Y, title, 220); - let y = TITLE_Y + step + 10; + const x = padding.left; + const width = windowWidth - padding.left - padding.right; + image.drawText(f, x, padding.top, title, 220); + let y = padding.top + step + 10; + const footerY = height - padding.bottom - f.lineHeight; + // Paragraph lines stop above the hint line, or at the bottom padding when there is none. + const bodyBottom = footer ? footerY : height - padding.bottom; for (const paragraph of paragraphs) { if (!paragraph.text) continue; for (const line of wrapText(f, paragraph.text, width)) { - if (y > win.viewportHeight - 2 * step) break; - image.drawText(f, TITLE_X, y, line, paragraph.value); + if (y + f.lineHeight > bodyBottom) break; + image.drawText(f, x, y, line, paragraph.value); y += step; } y += 6; } - if (footer) image.drawText(f, TITLE_X, win.viewportHeight - step - 6, footer, 110); + if (footer) image.drawText(f, x, footerY, footer, 110); return image; } @@ -2050,32 +2151,26 @@ function paintPair(win: AppWindow): GrayImage { function paintCompose(win: AppWindow): GrayImage { const target = composeTarget(); if (!target) return paintMessageScreen(win, "New thread", [{ text: "That project is no longer available.", value: 170 }], ""); - const image = new GrayImage(win.viewportWidth, win.viewportHeight, 0); + const { width, height, padding } = win.viewport; + const image = new GrayImage(width, height, 0); const f = font(); const step = lineStep(f); - const title = "New thread"; - image.drawText(f, TITLE_X, TITLE_Y, title, 220); - const status = busyText || notice?.text || ""; - if (status) { - const statusX = TITLE_X + f.measureText(title) + 16; - image.drawText(f, statusX, TITLE_Y, truncateText(f, status, win.viewportWidth - statusX - 14), 150); - } - // Below the list: an error, or why nothing can start here. + const header = paintListTitle(image, win.viewport, "New thread", busyText || notice?.text || ""); + // Below the list: an error, or why nothing can start here. Its lines stay + // put, the last resting on the window's bottom padding, and the list ends + // above them. const resolved = composeResolved(target); const problem = screenError || (resolved.model ? "" : (resolved.blocker ?? "")); - const problemLines = problem ? wrapText(f, problem, win.viewportWidth - TITLE_X * 2).slice(0, 3) : []; - const listTop = TITLE_Y + step + 8; - const listWidth = win.viewportWidth - LIST_LEFT - LIST_RIGHT; - const listHeight = win.viewportHeight - 6 - listTop - (problemLines.length ? problemLines.length * step + 6 : 0); + const problemLines = problem ? wrapText(f, problem, width - padding.right - header.x).slice(0, 3) : []; + const problemTop = height - padding.bottom - f.lineHeight - (problemLines.length - 1) * step; const items = composeItems(); const widest = Math.max(0, ...items.filter((item) => item.kind === "field").map((item) => f.measureText(item.label))); - composeValueColumn = Math.min(widest + 16, Math.floor(listWidth * 0.4)); + composeValueColumn = Math.min(widest + 16, Math.floor(listRowsWidth(win.viewport) * 0.4)); const menu = list(); menu.setItems(items, selectionIndex(items)); composeSelectionKey = menu.selectedItem?.key ?? composeSelectionKey; - menu.paint(image, { x: LIST_LEFT, y: listTop - 2, width: listWidth, height: listHeight }, win.focused); - menu.drawScrollbar(image, win.viewportWidth - 10, listTop, listHeight - 4); - problemLines.forEach((line, index) => image.drawText(f, TITLE_X, listTop + listHeight + 4 + index * step, line, 230)); + paintListRows(win, image, menu, header.listTop, problemLines.length ? problemTop : undefined); + problemLines.forEach((line, index) => image.drawText(f, header.x, problemTop + index * step, line, 230)); return image; } diff --git a/app/apps/teleprompter/reader.ts b/app/apps/teleprompter/reader.ts index a3c39205..3c20da16 100644 --- a/app/apps/teleprompter/reader.ts +++ b/app/apps/teleprompter/reader.ts @@ -9,8 +9,6 @@ import { lineStep } from "../../ui/metrics"; import { clamp } from "../../util/numeric-util"; import { ScriptTracker, tokenizeScript, type TokenizedScript } from "./script-tracker"; -const MARGIN_X = 18; -const BODY_TOP = 6; /** Gap between the last body line and the footer. */ const FOOTER_GAP = 4; /** Lines per ring scroll tick. */ @@ -41,6 +39,11 @@ export type ReaderHooks = { * and re-anchor the tracker to what is now at the anchor row, so scrolling * doubles as "I'm here now". Click pauses/resumes tracking; double-click * goes back to the file list. + * + * The script's column and the footer line keep inside the padding suggested + * for the window's edges. The lines scroll, so they run from the window's + * top edge itself: only the script's first line keeps that edge's padding + * above it. */ export class TeleprompterReaderLayer implements Layer { private readonly script: TokenizedScript; @@ -116,13 +119,18 @@ export class TeleprompterReaderLayer implements Layer { const font = getDefaultMediumFont(); const smallFont = getDefaultSmallFont(); const step = lineStep(font); - const { width, height } = ctx.stack.getBaseSize(); + const { width, height, padding } = ctx.stack.getBaseSize(); const image = new GrayImage(width, height, 0); + const bodyX = padding.left; + const bodyWidth = Math.max(0, width - padding.left - padding.right); - const footerY = height - smallFont.lineHeight - 4; - this.visibleRows = Math.max(1, Math.floor((footerY - FOOTER_GAP - BODY_TOP) / step)); + const footerY = height - padding.bottom - smallFont.lineHeight; + const bodyBottom = footerY - FOOTER_GAP; + // Rows that fit wherever the script is scrolled to, which is what + // scrolling and the anchor row go by. + this.visibleRows = Math.max(1, Math.floor((bodyBottom - padding.top) / step)); this.anchorRow = Math.floor(this.visibleRows / 3); - const lines = this.layout(font, width - 2 * MARGIN_X); + const lines = this.layout(font, bodyWidth); if (this.autoScrollPending) { this.autoScrollPending = false; @@ -133,20 +141,24 @@ export class TeleprompterReaderLayer implements Layer { const position = this.tracker.position; const nextToken = position < this.script.words.length ? this.script.wordTokens[position]! : this.script.tokens.length; - const lastLine = Math.min(lines.length, this.firstLine + this.visibleRows); + // Scrolled past the script's start, the lines begin at the window's top + // edge and the top padding's room may hold one more of them. + const bodyTop = this.firstLine === 0 ? padding.top : 0; + const shownRows = Math.max(1, Math.floor((bodyBottom - bodyTop) / step)); + const lastLine = Math.min(lines.length, this.firstLine + shownRows); for (let lineIndex = this.firstLine; lineIndex < lastLine; lineIndex++) { - const y = BODY_TOP + (lineIndex - this.firstLine) * step; + const y = bodyTop + (lineIndex - this.firstLine) * step; for (const span of lines[lineIndex]!.spans) { const isNext = span.tokenIndex === nextToken; const value = isNext ? NEXT_VALUE : span.tokenIndex < nextToken ? PAST_VALUE : UPCOMING_VALUE; - image.drawText(font, MARGIN_X + span.x, y, span.text, value); + image.drawText(font, bodyX + span.x, y, span.text, value); if (isNext) { - image.fillRect(MARGIN_X + span.x, y + font.lineHeight - 2, span.width, 2, NEXT_VALUE); + image.fillRect(bodyX + span.x, y + font.lineHeight - 2, span.width, 2, NEXT_VALUE); } } } - this.paintFooter(image, smallFont, width, footerY); + this.paintFooter(image, smallFont, bodyX, bodyWidth, footerY); return image; } @@ -169,15 +181,16 @@ export class TeleprompterReaderLayer implements Layer { } } - private paintFooter(image: GrayImage, font: UiFont, width: number, y: number): void { + /** The footer line across [x, x + width): the script's name at its left, status and progress at its right. */ + private paintFooter(image: GrayImage, font: UiFont, x: number, width: number, y: number): void { const total = this.script.words.length; const percent = total === 0 ? 0 : Math.round((100 * this.tracker.position) / total); const right = `${this.tracking ? this.status || "Listening" : "Paused"} ${percent}%`; const rightWidth = font.measureText(right); - image.drawText(font, width - MARGIN_X - rightWidth, y, right, 110); - const titleMax = width - 2 * MARGIN_X - rightWidth - 12; + image.drawText(font, x + width - rightWidth, y, right, 110); + const titleMax = width - rightWidth - 12; if (titleMax > 20) { - image.drawText(font, MARGIN_X, y, truncateText(font, this.title, titleMax), 110); + image.drawText(font, x, y, truncateText(font, this.title, titleMax), 110); } } diff --git a/app/apps/teleprompter/teleprompter-app.ts b/app/apps/teleprompter/teleprompter-app.ts index c615297b..ee9f8150 100644 --- a/app/apps/teleprompter/teleprompter-app.ts +++ b/app/apps/teleprompter/teleprompter-app.ts @@ -4,7 +4,6 @@ import { readTextFile, type DirectoryEntry } from "../../native/file-access"; import { LIST_ROW_TEXT_INSET } from "../../ui/metrics"; import { MenuLayer, type MenuItem } from "../../ui/menu"; import { type Layer, type LayerContext } from "../../ui/layers"; -import { appViewportSize } from "../../ui/shell/geometry"; import { createInProcessWindow, YieldAtRootLayer, @@ -28,15 +27,7 @@ export const TELEPROMPTER_SURFACE_ID = "window:teleprompter"; const SCRIPT_FILE = /\.(txt|md|markdown|text|log)$/i; -const HOME_LAYOUT = { - x: 8, - y: 8, - width: 272, - showBorder: false, - minHeight: 0, - maxHeight: appViewportSize("min").height - 16, - opaque: true, -}; +const HOME_LAYOUT = { page: true, width: 248 } as const; export type TeleprompterAppOptions = InProcessAppOptions & { /** Hold continuous mic capture while a script is being tracked. */ diff --git a/app/apps/terminal/hub-header.ts b/app/apps/terminal/hub-header.ts index c3fbbe7a..b3eefd3f 100644 --- a/app/apps/terminal/hub-header.ts +++ b/app/apps/terminal/hub-header.ts @@ -1,14 +1,41 @@ import { wrapText, type WrapFont } from '../../graphics/textwrap'; +import type { Edges } from '../../ui/viewport'; -/** Left edge of the hub's title line (and of a wrapped status block under it). */ -export const HUB_TITLE_X = 12; +/** + * Where the hub's title line (and a wrapped status block under it) starts, + * right of the window's left padding: the list's selection boxes start at + * the padding and unindented row text sits this far inside its box, so the + * title lines up with it. + */ +export const HUB_TITLE_INSET_X = 6; +/** The title line's top, below the window's top padding. */ +const HUB_TITLE_OFFSET_Y = 2; +/** Between the title and a status that shares its row. */ +const HUB_STATUS_GAP = 16; +/** Between the header's last line and the list's first text line. */ +const HUB_LIST_GAP = 6; -/** Keep short status on the title row; give long errors their full width. */ -export function layoutHubHeader(font: WrapFont, title: string, status: string, width: number, step: number) { - const inlineX = HUB_TITLE_X + font.measureText(title) + 16; - const inline = !/[\r\n]/.test(status) && font.measureText(status) <= Math.max(0, width - inlineX - 12); - const lines = inline ? [status] : wrapText(font, status, Math.max(1, width - HUB_TITLE_X - 12)); - const x = inline ? inlineX : HUB_TITLE_X; - const y = inline ? 10 : 10 + step; - return { x, y, lines, listTop: inline ? 16 + step : 16 + step * (1 + lines.length) }; +/** + * Lay the hub's header out in a window `width` wide with the suggested + * `padding` (viewport.ts): the title inside the top and left padding, the + * status ending at the right padding. Keep short status on the title row; + * give long errors their full width. + */ +export function layoutHubHeader( + font: WrapFont, + title: string, + status: string, + viewport: { width: number; padding: Edges }, + step: number, +) { + const { width, padding } = viewport; + const titleX = padding.left + HUB_TITLE_INSET_X; + const titleY = padding.top + HUB_TITLE_OFFSET_Y; + const right = width - padding.right; + const inlineX = titleX + font.measureText(title) + HUB_STATUS_GAP; + const inline = !/[\r\n]/.test(status) && font.measureText(status) <= Math.max(0, right - inlineX); + const lines = inline ? [status] : wrapText(font, status, Math.max(1, right - titleX)); + const x = inline ? inlineX : titleX; + const y = inline ? titleY : titleY + step; + return { titleX, titleY, x, y, lines, listTop: titleY + HUB_LIST_GAP + step * (inline ? 1 : 1 + lines.length) }; } diff --git a/app/apps/terminal/index.ts b/app/apps/terminal/index.ts index 9de1e7e9..e305c21e 100644 --- a/app/apps/terminal/index.ts +++ b/app/apps/terminal/index.ts @@ -14,6 +14,8 @@ const terminalApp: AppDefinition = { // Session windows stay independent: launching reopens the hub even // while terminal sessions are open. matchExistingBy: "windowId", + // The hub window can show a session too, so it takes keys like one. + acceptsKeys: true, }), }; diff --git a/app/apps/terminal/terminal-app.worker.ts b/app/apps/terminal/terminal-app.worker.ts index 87bf9fdc..2445895f 100644 --- a/app/apps/terminal/terminal-app.worker.ts +++ b/app/apps/terminal/terminal-app.worker.ts @@ -6,9 +6,15 @@ * connected host's heading launches a shell there), and hosts the Manage * Connections section * where g2mirror:// connections are added, removed, and toggled. - * - "terminal:view:N": opened by selecting a session in the hub; each has - * its own websocket connection (the protocol allows one attached session - * per connection) and its own xterm emulator. + * - Selecting a session in the hub shows it in the hub's own window: a view + * takes the hub's place in `windows` under the same window id, and + * double-click puts the hub back. The window grows to the view's height + * meanwhile. Sessions already open in a window of their own focus it instead. + * - "terminal:view:N": a session in a window of its own, opened with "Open in + * new window" from the window menu (or by launching a session). + * + * Each view has its own websocket connection (the protocol allows one attached + * session per connection) and its own xterm emulator. * * Connections are g2mirror://@[:port] strings (g2mirrors:// for * TLS), stored as JSON in the settings store (see connections.ts). Each @@ -39,7 +45,7 @@ import { GrayImage, type UiFont } from "../../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, type Plane } from "../../graphics/plane"; import { prepareFrameDraws } from "../../graphics/glyph-wire"; import { getDefaultSmallFont, getTerminalFontConfig } from "../../graphics/ui-fonts"; -import { HUB_TITLE_X, layoutHubHeader } from "./hub-header"; +import { HUB_TITLE_INSET_X, layoutHubHeader } from "./hub-header"; import { TERMINAL_ICON_GLYPHS, type IconActivity } from "../../graphics/icons"; import { drawSessionRow, @@ -49,6 +55,8 @@ import { import * as frameTimings from "../../native/frame-timings"; import { getActiveDisplay } from "../../native/active-display"; import { GESTURE_DOUBLE_CLICK, type InputEvent } from "../../ui/gestures"; +import type { KeyEvent } from "../../g2/keyboard/keys"; +import { encodeTerminalKey, terminalScrollbackKey } from "./terminal-keys"; import { G2MirrorClient, type G2MirrorClientOptions, type G2MirrorSession, type G2MirrorState } from "../../native/g2mirror-client"; import { onSettingsStoreChanged } from "../../native/settings-store"; import { clamp } from "../../util/numeric-util"; @@ -69,7 +77,8 @@ import { drawSubmenuIndicator, submenuItem, type MenuItem } from "../../ui/menu" import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { centeredTextY, lineStep, listRowHeight, textInkHeight } from "../../ui/metrics"; import { WindowMenu, WindowMenuLayer } from "../../ui/window-menu"; -import { appViewportSize } from "../../ui/shell/geometry"; +import { appViewportSize, type WindowHeightMode } from "../../ui/shell/geometry"; +import type { EdgeKind, Edges, Viewport } from "../../ui/viewport"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; import type { ToolResult, ToolSpec } from "../../assistant/tool-registry"; @@ -109,11 +118,21 @@ const LAUNCH_PRESETS_KEY = "terminal.launchPresets"; type BaseWindow = { windowId: string; surfaceId: string; - /** Shell-side window title, echoed back in the open-window message. */ + /** + * Window menu title: the shell-side window title, echoed back in the + * open-window message, or the session's label for a view in the hub's window. + */ title: string; /** Content viewport from the shell's open-window message; grid = viewport / cell. */ viewportWidth: number; viewportHeight: number; + /** + * What the viewport's edges touch and the padding suggested for them + * (viewport.ts), as of the last open or resize message. The hub's pages lay + * out inside the padding; a session's grid fills the window regardless. + */ + edges: Edges; + padding: Edges; gridCols: number; gridRows: number; foreground: boolean; @@ -155,6 +174,11 @@ type HubWindow = BaseWindow & { type ViewWindow = BaseWindow & { kind: "view"; + /** + * Set when this view is showing in the hub's window rather than one of its + * own: the hub it replaced, which double-click restores. + */ + hub: HubWindow | null; /** Grid font and integer cell pitch, captured at window creation. */ font: UiFont; cellWidth: number; @@ -204,6 +228,9 @@ type PendingView = { const windows = new Map(); const pendingViews = new Map(); +// Windows waiting on the shell's answer to a set-height-mode, by window id: +// what to do with the viewport it comes back with (see changeWindowHeight). +const pendingHeightChanges = new Map void>(); // The view an assistant tool acts on when the terminal isn't foregrounded: // the last view to be foregrounded or receive input. let activeViewId: string | null = null; @@ -338,12 +365,29 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { openWindow(message.windowId, message.surfaceId, message.title, message.viewport); break; case "resize-window": { + const heightChange = pendingHeightChanges.get(message.windowId); + if (heightChange) { + pendingHeightChanges.delete(message.windowId); + heightChange(message.viewport); + break; + } const window = windows.get(message.windowId); - if (!window || (window.viewportWidth === message.viewport.width && window.viewportHeight === message.viewport.height)) break; + if (!window) break; + const resized = window.viewportWidth !== message.viewport.width || window.viewportHeight !== message.viewport.height; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; + window.edges = message.viewport.edges; + window.padding = message.viewport.padding; window.menu?.resize(message.viewport); - window.lastSubmittedFingerprint = ""; + // A resize at the same size says what the window's edges touch has + // changed. The hub's pages move with their padding; a session's grid + // does not, so it keeps its connection, and only a menu page open over + // it (which lays out in the padding) has anything to repaint. + if (window.kind === "view" && !resized) { + if (window.menu?.isOpen()) scheduleRender(window); + break; + } + if (resized) window.lastSubmittedFingerprint = ""; if (window.kind === "view") { window.gridCols = Math.floor(window.viewportWidth / window.cellWidth); window.gridRows = Math.floor(window.viewportHeight / window.cellHeight); @@ -393,6 +437,13 @@ global.onmessage = (event: { data: WorkerAppMessage }) => { } break; } + case "key": { + const window = windows.get(message.windowId); + if (!window) break; + window.focused = message.focused; + handleKey(window, message.event as KeyEvent); + break; + } case "render": { const window = windows.get(message.windowId); if (!window) break; @@ -506,7 +557,7 @@ function cancelPendingReconnects(): void { } } -function openWindow(windowId: string, surfaceId: string, title: string, viewport: { width: number; height: number }): void { +function openWindow(windowId: string, surfaceId: string, title: string, viewport: Viewport): void { const pendingView = pendingViews.get(windowId); if (pendingView) { pendingViews.delete(windowId); @@ -523,6 +574,8 @@ function openWindow(windowId: string, surfaceId: string, title: string, viewport title, viewportWidth: viewport.width, viewportHeight: viewport.height, + edges: viewport.edges, + padding: viewport.padding, gridCols: Math.floor(viewport.width / hubCell.cellWidth), gridRows: Math.floor(viewport.height / hubCell.cellHeight), foreground: false, @@ -543,18 +596,24 @@ function openWindow(windowId: string, surfaceId: string, title: string, viewport updateHubAnimation(); } +/** Drop a view's connection for good: its window closed or the hub took its place. */ +function stopViewConnection(window: ViewWindow): void { + for (const unsubscribe of window.unsubscribers.splice(0)) { + unsubscribe(); + } + if (window.reconnectTimer) { + clearTimeout(window.reconnectTimer); + window.reconnectTimer = null; + } + window.client.stop(); +} + function closeWindow(windowId: string): void { const window = windows.get(windowId); if (!window) return; + pendingHeightChanges.delete(windowId); if (window.kind === "view") { - for (const unsubscribe of window.unsubscribers.splice(0)) { - unsubscribe(); - } - if (window.reconnectTimer) { - clearTimeout(window.reconnectTimer); - window.reconnectTimer = null; - } - window.client.stop(); + stopViewConnection(window); } if (window.kind === "hub" && window.mode === "add") { // Window closed mid-add: shut the phone editor down. @@ -759,10 +818,11 @@ function routeBell(connectionId: string, socket: string, lastBellAtMs: number): } } if (terminalWakeOnBellSetting.get()) { - // Wake to the belling session's view window, or the hub if it has none. - // The shell drops the message unless the glasses are actually asleep. + // Wake to the belling session's view window, or the hub's window (whatever + // it is showing) if it has none. The shell drops the message unless the + // glasses are actually asleep. const viewId = viewWindowIdForSocket(connectionId, socket); - const hubId = [...windows.values()].find((window) => window.kind === "hub")?.windowId ?? null; + const hubId = [...windows.values()].find((window) => window.kind === "hub" || window.hub)?.windowId ?? null; const target = viewId ?? hubId; if (target) post({ type: "wake-window", windowId: target }); } @@ -882,7 +942,7 @@ function createViewWindow( windowId: string, surfaceId: string, title: string, - viewport: { width: number; height: number }, + viewport: Viewport, view: PendingView, ): ViewWindow { const { connectionId, socket, label, glyph } = view; @@ -895,11 +955,14 @@ function createViewWindow( const client = new G2MirrorClient({ ...view.options, cols: gridCols, rows: gridRows }); const window: ViewWindow = { kind: "view", + hub: null, windowId, surfaceId, title, viewportWidth: viewport.width, viewportHeight: viewport.height, + edges: viewport.edges, + padding: viewport.padding, gridCols, gridRows, font: cell.font, @@ -1034,7 +1097,7 @@ function windowMenu(window: TerminalWindow): WindowMenu { post, title: () => window.title, items: () => windowMenuItems(window), - size: { width: window.viewportWidth, height: window.viewportHeight }, + size: { width: window.viewportWidth, height: window.viewportHeight, edges: window.edges, padding: window.padding }, paintBase: () => paintContent(window), isFocused: () => window.focused, }); @@ -1053,12 +1116,41 @@ function connectedControls(): ControlConnection[] { return [...controls.values()].filter(isControlConnected); } +/** + * What the window menu's "Open in new window" does here, if it applies: to the + * session selected in the hub's list, or the session showing in the hub's + * window (which gives way to the list, as a session has one window at a time). + */ +function openInNewWindowAction(window: TerminalWindow): (() => void) | null { + if (window.kind === "hub") { + const row = hubMenu(window).selectedItem?.sessionRow; + if (!row) return null; + return () => { + if (!focusSessionWindow(row.control, row.session)) openViewWindowFor(row.control, row.session); + }; + } + const control = window.hub && controls.get(window.connectionId); + if (!control) return null; + return () => returnToHub(window, () => openViewWindow(control, window.socket, window.label)); +} + function windowMenuItems(window: TerminalWindow): MenuItem[] { - const items: MenuItem[] = [ + const items: MenuItem[] = []; + const openInNewWindow = openInNewWindowAction(window); + if (openInNewWindow) { + items.push({ + label: "Open in new window", + onSelect: (ctx) => { + ctx.stack.pop(); + openInNewWindow(); + }, + }); + } + items.push( submenuItem("Settings", (ctx) => { ctx.stack.push(new WindowMenuLayer("Terminal settings", settingsMenuItems())); }), - ]; + ); if (window.kind === "hub") { const connected = connectedControls(); const multiHost = connected.length > 1; @@ -1142,8 +1234,14 @@ function handleInput(window: TerminalWindow, event: InputEvent, frameId: number) return; } if (event.type === "double-click") { - // Inside the hub's sub-sections, double-click backs out one level; at the - // top level (and in views) it yields focus to the sidebar as everywhere. + // Inside the hub's sub-sections and a session shown in its window, + // double-click backs out one level; at the top level (and in views with + // windows of their own) it yields focus to the sidebar as everywhere. + if (window.kind === "view" && window.hub) { + frameTimings.finishFrame(frameId, "discarded: terminal returning to the session list"); + returnToHub(window); + return; + } if (window.kind === "hub" && window.mode === "add") { cancelAddConnection(window); renderAndSubmit(window, frameId); @@ -1171,6 +1269,35 @@ function handleInput(window: TerminalWindow, event: InputEvent, frameId: number) frameTimings.finishFrame(frameId, "discarded: terminal view ignored input"); } +/** + * A key from a hardware keyboard (the glasses' keyboard bridge) that no + * keybinding claimed. A session with nothing over it gets the key as its + * terminal would: Escape and the arrows belong to the program, and the way + * out is Escape with Shift, Ctrl or Alt, which never arrives here (it is a + * built-in keybinding for "back"). Anywhere else (the hub's lists, an open + * menu) the key is handed back, to act as navigation. + */ +function handleKey(window: TerminalWindow, event: KeyEvent): void { + if (window.kind === "view" && !window.menu?.isOpen()) { + activeViewId = window.windowId; + const page = terminalScrollbackKey(event); + if (page !== null) { + handleViewScroll(window, page, 0); + return; + } + const bytes = encodeTerminalKey(event, window.emulator.applicationCursorKeys()); + if (bytes === null) return; + // Typing follows the live screen, as in any terminal emulator. + if (window.scrollTop !== null) { + window.scrollTop = null; + scheduleRender(window); + } + window.client.sendInput(bytes); + return; + } + post({ type: "key-unhandled", windowId: window.windowId, event }); +} + /** Top visible absolute line index when following the live bottom. */ function followTop(window: ViewWindow): number { return window.historyNext + window.emulator.bufferLength() - window.gridRows; @@ -1233,17 +1360,27 @@ type HubItem = { active?: boolean; /** Glyph of the view window showing this session (the number column). */ openGlyph?: string | null; + /** The live session this row lists, for the window menu's "Open in new window". */ + sessionRow?: { control: ControlConnection; session: G2MirrorSession }; onSelect?: () => void; }; /** Vertical offset of a row's text line from the top of its selection box. */ const HUB_ROW_TEXT_INSET = 4; -/** Left edge of the list's selection boxes. */ -const HUB_LIST_LEFT = 12; -/** Right inset of the selection boxes, clear of the scrollbar. */ -const HUB_LIST_RIGHT = 20; -/** Left padding of unindented (heading and top-level) row text inside its selection box. */ -const HUB_TOP_LEVEL_TEXT_X = 6; +/** How far the first selection box starts above the list's first text line. */ +const HUB_LIST_LEAD = 2; +/** The list's scrollbar (Menu.drawScrollbar's bar), and the gap the selection boxes keep from it. */ +const HUB_SCROLLBAR_WIDTH = 3; +const HUB_SCROLLBAR_GAP = 10; +/** How far the scrollbar's track stops short of the rows' span at each end. */ +const HUB_SCROLLBAR_INSET = 2; +/** + * Left padding of unindented (heading and top-level) row text inside its + * selection box; the hub's title starts in the same column. + */ +const HUB_TOP_LEVEL_TEXT_X = HUB_TITLE_INSET_X; +/** A page of text's body, indented under its title. */ +const PAGE_BODY_INDENT = 6; /** The hub window's list, created on first use so openWindow stays free of paint dependencies. */ function hubMenu(window: HubWindow): Menu { @@ -1371,13 +1508,9 @@ function hubSessionItems(window: HubWindow): HubItem[] { label: sessionLabel(session), active: isSessionActive(control.config.id, session.socket), openGlyph: viewGlyphForSocket(control.config.id, session.socket), + sessionRow: { control, session }, onSelect: () => { - const windowId = viewWindowIdForSocket(control.config.id, session.socket); - if (windowId) { - post({ type: "focus-window", windowId }); - } else { - openViewWindowFor(control, session); - } + if (!focusSessionWindow(control, session)) showSessionInHub(window, control, session); }, }); } @@ -1587,10 +1720,91 @@ function viewWindowIdForSocket(connectionId: string, socket: string): string | n return null; } +/** Focus the window already showing a session; false if it has none. */ +function focusSessionWindow(control: ControlConnection, session: G2MirrorSession): boolean { + const windowId = viewWindowIdForSocket(control.config.id, session.socket); + if (!windowId) return false; + post({ type: "focus-window", windowId }); + return true; +} + function openViewWindowFor(control: ControlConnection, session: G2MirrorSession): void { openViewWindow(control, session.socket, sessionLabel(session)); } +/** + * Ask the shell to move a window to another height band, then run `apply` with + * the viewport it answers with: only the shell knows what a band comes to (the + * bottom switcher's height lives on the main thread), and a view's grid goes + * into its websocket handshake, so the size has to be right before it starts. + * Ignored if the window is already waiting on an answer (a repeated gesture). + */ +function changeWindowHeight(windowId: string, heightMode: WindowHeightMode, apply: (viewport: Viewport) => void): void { + if (pendingHeightChanges.has(windowId)) return; + pendingHeightChanges.set(windowId, apply); + post({ type: "set-height-mode", windowId, heightMode }); +} + +/** Make `incoming` what its window id shows, in place of `outgoing`. */ +function replaceWindowContent(outgoing: TerminalWindow, incoming: TerminalWindow): void { + incoming.foreground = outgoing.foreground; + incoming.focused = outgoing.focused; + incoming.lastSubmittedFingerprint = ""; + // Its pending timers and emulator callbacks must not paint over the surface. + outgoing.foreground = false; + windows.set(incoming.windowId, incoming); + updateHubAnimation(); + renderAndSubmit(incoming, 0); +} + +/** A session was selected in the list: show it in the hub's own window. */ +function showSessionInHub(hub: HubWindow, control: ControlConnection, session: G2MirrorSession): void { + const options = clientOptionsFor(control.config); + if (!options) return; + const label = sessionLabel(session); + // Tall like a session in its own window (see openViewWindow). + changeWindowHeight(hub.windowId, "max", (viewport) => { + const view = createViewWindow(hub.windowId, hub.surfaceId, label, viewport, { + connectionId: control.config.id, + socket: session.socket, + label, + glyph: "", + options, + }); + view.hub = hub; + if (hub.foreground) activeViewId = view.windowId; + replaceWindowContent(hub, view); + }); +} + +/** + * Back from a session in the hub's window to the list. The list keeps the order + * it had, with this session's row selected: viewing a session bumps its + * recency, and re-sorting on every return would shuffle the list while the user + * steps through it. `then` runs once the session's connection is gone. + */ +function returnToHub(view: ViewWindow, then?: () => void): void { + const hub = view.hub; + if (!hub) return; + changeWindowHeight(view.windowId, "min", (viewport) => { + stopViewConnection(view); + view.emulator.dispose(); + if (activeViewId === view.windowId) activeViewId = null; + hub.viewportWidth = viewport.width; + hub.viewportHeight = viewport.height; + hub.edges = viewport.edges; + hub.padding = viewport.padding; + hub.menu?.resize(viewport); + const items = hubItems(hub); + const row = items.findIndex( + (item) => item.sessionRow?.control.config.id === view.connectionId && item.sessionRow.session.socket === view.socket, + ); + hubMenu(hub).setItems(items, row >= 0 ? row : undefined); + replaceWindowContent(view, hub); + then?.(); + }); +} + /** * Lowest unused sidebar-icon character for a new view window (its terminal * icon shows ">N"). Glyphs free up when their window closes, since usage is @@ -1624,6 +1838,7 @@ function openViewWindow(control: ControlConnection, socket: string, label: strin focus: true, // Default to tall sessions; the app display setting can override this. heightMode: "max", + acceptsKeys: true, }); } @@ -1688,54 +1903,71 @@ function paintHub(window: HubWindow): GrayImage { if (window.mode === "add") { return paintAddConnection(window); } - const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); + const { viewportWidth: width, viewportHeight: height, padding } = window; + const image = new GrayImage(width, height, 0); const font = chromeFont(); const step = lineStep(font); - // No border box: the shell chrome (top bar + sidebar) already frames the app. - // Long statuses get a wrapped block and move the list below it. + // The header stays put inside the window's top padding, its title in line + // with the rows' text. Long statuses get a wrapped block and move the list + // below it. const title = window.mode === "connections" ? "Terminal - Connections" : "Terminal"; - image.drawText(font, HUB_TITLE_X, 10, title, 220); - const header = layoutHubHeader(font, title, hubStatusLine(window), window.viewportWidth, step); + const header = layoutHubHeader(font, title, hubStatusLine(window), { width, padding }, step); + image.drawText(font, header.titleX, header.titleY, title, 220); header.lines.forEach((line, index) => image.drawText(font, header.x, header.y + index * step, line, 170)); let listTop = header.listTop; if (window.mode === "sessions" && controls.size === 0) { - image.drawText(font, HUB_TITLE_X + 6, listTop, "Add a g2mirror:// connection to get started, see:", 150); - image.drawText(font, HUB_TITLE_X + 6, listTop + step, "https://github.com/jimrandomh/g2mirror", 190); + image.drawText(font, header.titleX, listTop, "Add a g2mirror:// connection to get started, see:", 150); + image.drawText(font, header.titleX, listTop + step, "https://github.com/jimrandomh/g2mirror", 190); listTop += 2 * step + 6; } const list = hubMenu(window); list.setItems(hubItems(window)); - // Selection boxes start above the text line; the menu fills the selected - // box only while this window has focus (an outline alone means the sidebar - // owns input), matching the shell convention. - const listHeight = window.viewportHeight - 6 - listTop; + // Selection boxes start at the left padding, above the text line; the menu + // fills the selected box only while this window has focus (an outline alone + // means the sidebar owns input), matching the shell convention. The list + // scrolls, so under the header it runs to the window's bottom edge with + // that edge's padding inside it, after the last row: rows scrolled past the + // end are cut off at the edge itself. The scrollbar hugs the right padding. + const boxTop = listTop - HUB_LIST_LEAD; + const scrollbarX = width - padding.right - HUB_SCROLLBAR_WIDTH; list.paint( image, - { x: HUB_LIST_LEFT, y: listTop - 2, width: window.viewportWidth - HUB_LIST_LEFT - HUB_LIST_RIGHT, height: listHeight }, + { + x: padding.left, + y: boxTop, + width: Math.max(0, scrollbarX - HUB_SCROLLBAR_GAP - padding.left), + height: Math.max(0, height - boxTop), + padBottom: padding.bottom, + }, window.focused, ); - list.drawScrollbar(image, window.viewportWidth - 10, listTop, listHeight - 4); + const trackTop = boxTop + HUB_SCROLLBAR_INSET; + list.drawScrollbar(image, scrollbarX, trackTop, Math.max(0, height - padding.bottom - HUB_SCROLLBAR_INSET - trackTop)); return image; } function paintAddConnection(window: HubWindow): GrayImage { - const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); + const { viewportWidth: width, viewportHeight: height, padding } = window; + const image = new GrayImage(width, height, 0); const font = chromeFont(); const step = lineStep(font); - image.drawText(font, 18, 10, "Add connection", 220); - const instructionsY = 20 + step; - image.drawText(font, 24, instructionsY, "Type the g2mirror://token@host string in the", 170); - image.drawText(font, 24, instructionsY + step, "phone app (or use voice input from the menu).", 170); + // A page of text: its title sits at the window's top and left padding, the + // body indented under it, and the hint line on the bottom padding. + image.drawText(font, padding.left, padding.top, "Add connection", 220); + const bodyX = padding.left + PAGE_BODY_INDENT; + const instructionsY = padding.top + 10 + step; + image.drawText(font, bodyX, instructionsY, "Type the g2mirror://token@host string in the", 170); + image.drawText(font, bodyX, instructionsY + step, "phone app (or use voice input from the menu).", 170); const draftY = instructionsY + 3 * step; const draft = terminalNewConnectionSetting.get(); - image.drawText(font, 24, draftY, truncateLabel(draft || "(empty)", 52), 220); + image.drawText(font, bodyX, draftY, truncateLabel(draft || "(empty)", 52), 220); if (window.addError) { - image.drawText(font, 24, draftY + step + 6, window.addError, 150); + image.drawText(font, bodyX, draftY + step + 6, window.addError, 150); } - image.drawText(font, 24, window.viewportHeight - font.lineHeight - 12, `click save ${GESTURE_DOUBLE_CLICK} cancel`, 110); + image.drawText(font, bodyX, height - padding.bottom - font.lineHeight, `click save ${GESTURE_DOUBLE_CLICK} cancel`, 110); return image; } diff --git a/app/apps/terminal/terminal-emulator.ts b/app/apps/terminal/terminal-emulator.ts index 914ff50f..aaa4aec6 100644 --- a/app/apps/terminal/terminal-emulator.ts +++ b/app/apps/terminal/terminal-emulator.ts @@ -82,4 +82,9 @@ export class TerminalEmulator { cursorCol(): number { return this.term.buffer.active.cursorX; } + + /** DECCKM: the session asked for application cursor keys (ESC O A rather than ESC [ A). */ + applicationCursorKeys(): boolean { + return this.term.modes.applicationCursorKeysMode; + } } diff --git a/app/apps/terminal/terminal-keys.ts b/app/apps/terminal/terminal-keys.ts new file mode 100644 index 00000000..a99cd107 --- /dev/null +++ b/app/apps/terminal/terminal-keys.ts @@ -0,0 +1,118 @@ +/** + * What a terminal emulator sends for a key from a hardware keyboard, by the + * classic xterm conventions: Ctrl chords become control characters, Alt + * prefixes ESC, and modified cursor and function keys carry the xterm + * modifier parameter (1 + shift + 2*alt + 4*ctrl). Follows the Glassly + * Terminal miniapp's encoder (terminal/keys.ts, MIT). + * No platform imports: this runs under node in the tests. + */ +import type { KeyEvent } from "../../g2/keyboard/keys"; + +const ESC = "\x1b"; + +/** Keys xterm encodes as `ESC [ ~`, with a modifier as `;m`. */ +const TILDE_KEYS: Record = { + Insert: 2, + Delete: 3, + PageUp: 5, + PageDown: 6, + F5: 15, + F6: 17, + F7: 18, + F8: 19, + F9: 20, + F10: 21, + F11: 23, + F12: 24, +}; + +/** Keys with a single-letter final byte: SS3 in application cursor mode, CSI otherwise. */ +const LETTER_KEYS: Record = { + ArrowUp: "A", + ArrowDown: "B", + ArrowRight: "C", + ArrowLeft: "D", + Home: "H", + End: "F", +}; + +/** F1-F4 are always SS3 (`ESC O P`), or CSI with a modifier. */ +const SS3_KEYS: Record = { F1: "P", F2: "Q", F3: "R", F4: "S" }; + +/** Ctrl with a punctuation or digit key, per xterm (^[ ^\ ^] ^^ ^_ ^? ^@). */ +const CONTROL_PUNCTUATION: Record = { + "[": "\x1b", + "\\": "\x1c", + "]": "\x1d", + "^": "\x1e", + "6": "\x1e", + "_": "\x1f", + "-": "\x1f", + "?": "\x7f", + "/": "\x7f", + "8": "\x7f", + "@": "\x00", + "2": "\x00", +}; + +/** + * The text to write to the terminal for one key event, or null when the key + * sends nothing: releases, bare modifiers, Meta chords, and keys a terminal + * has no bytes for (volume, media). `appCursor` is DECCKM, which the emulator + * tracks from the session's output. + */ +export function encodeTerminalKey(event: KeyEvent, appCursor: boolean): string | null { + if (event.phase !== "down") return null; + const { key, modifiers } = event; + if (modifiers.meta) return null; + const modifierParam = 1 + (modifiers.shift ? 1 : 0) + (modifiers.alt ? 2 : 0) + (modifiers.ctrl ? 4 : 0); + const modified = (prefix: string, final: string): string | null => + modifierParam > 1 ? `${ESC}[${prefix};${modifierParam}${final}` : null; + + switch (key) { + case "Enter": + return modifiers.alt ? `${ESC}\r` : "\r"; + case "Escape": + return ESC; + case "Tab": + return modifiers.shift ? `${ESC}[Z` : "\t"; + case "Backspace": + if (modifiers.alt) return `${ESC}\x7f`; + return modifiers.ctrl ? "\x08" : "\x7f"; + case " ": + return modifiers.ctrl ? "\x00" : modifiers.alt ? `${ESC} ` : " "; + } + + const letter = LETTER_KEYS[key]; + if (letter) return modified("1", letter) ?? (appCursor ? `${ESC}O${letter}` : `${ESC}[${letter}`); + const tilde = TILDE_KEYS[key]; + if (tilde) return modified(String(tilde), "~") ?? `${ESC}[${tilde}~`; + const ss3 = SS3_KEYS[key]; + if (ss3) return modified("1", ss3) ?? `${ESC}O${ss3}`; + + if (modifiers.ctrl) { + // From the unshifted key: ^A..^Z, then the punctuation set. + const base = key.length === 1 ? key.toLowerCase() : ""; + let char: string | undefined; + if (base >= "a" && base <= "z") char = String.fromCharCode(base.charCodeAt(0) - 96); + else char = CONTROL_PUNCTUATION[key]; + if (char === undefined) return null; + return modifiers.alt ? `${ESC}${char}` : char; + } + + // With Alt held the translator leaves `text` out (it is a chord, not + // typing); a terminal still wants ESC and the character. + const text = event.text ?? (modifiers.alt && key.length === 1 ? key : undefined); + if (text === undefined) return null; + return modifiers.alt ? `${ESC}${text}` : text; +} + +/** Shift+PageUp / Shift+PageDown page the emulator's own scrollback, as in xterm. */ +export function terminalScrollbackKey(event: KeyEvent): -1 | 1 | null { + if (event.phase !== "down") return null; + const { shift, ctrl, alt, meta } = event.modifiers; + if (!shift || ctrl || alt || meta) return null; + if (event.key === "PageUp") return -1; + if (event.key === "PageDown") return 1; + return null; +} diff --git a/app/apps/timer/timer-app.ts b/app/apps/timer/timer-app.ts index bd9f0293..94729fa5 100644 --- a/app/apps/timer/timer-app.ts +++ b/app/apps/timer/timer-app.ts @@ -40,6 +40,7 @@ import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { LIST_ROW_TEXT_INSET, lineStep, listRowHeight } from "../../ui/metrics"; import { createInProcessWindow, type InProcessAppOptions, type InProcessWindow } from "../../ui/shell/in-process-window"; import { shell, type TrayWidget } from "../../ui/shell/shell"; +import type { Viewport } from "../../ui/viewport"; import { WindowMenuLayer } from "../../ui/window-menu"; import { clamp } from "../../util/numeric-util"; import { @@ -85,16 +86,27 @@ import { export const TIMER_WINDOW_ID = "timer"; export const TIMER_SURFACE_ID = "window:timer"; -/** Width of the list column, as a share of the viewport, and its bounds. */ +/** + * Width of the list column (its rows and the scrollbar's gutter), as a share + * of the viewport's width inside its side padding, and its bounds. + */ const LIST_SHARE = 0.4; const LIST_MIN_WIDTH = 190; const LIST_MAX_WIDTH = 240; -const LIST_TOP = 6; /** Pixels between consecutive list rows' selection boxes. */ const LIST_ROW_GAP = 1; -const STAGE_X = 10; +/** + * Room the list column keeps right of its rows for the scrollbar, which + * hugs the column's right edge: the gap before it, and its own 3 columns. + */ +const LIST_SCROLLBAR_GAP = 5; +const LIST_SCROLLBAR_GUTTER = LIST_SCROLLBAR_GAP + 3; +/** Gap between the list's divider and its rows. */ +const LIST_DIVIDER_GAP = 7; /** Gap between the stage's right edge and the list's divider. */ -const STAGE_LIST_GAP = 14; +const STAGE_LIST_GAP = 18; +/** How far the stage's small-font content is indented from its title, and ends short of the stage's right edge. */ +const STAGE_BODY_INSET = 2; /** Brightness factor for the list while a picker owns the stage. */ const LIST_DIM = 0.4; /** Big-digit sizes tried largest first until the text fits the stage. */ @@ -198,8 +210,8 @@ export class TimersLayer implements Layer { isSelectable: (row) => row.kind !== "header", draw: (args) => this.drawListRow(args), }); - /** Per-paint inputs to drawListRow. */ - private listPaint = { dim: 1, now: 0 }; + /** Per-paint inputs to drawListRow, and the padding the last paint put above the list's first row. */ + private listPaint = { dim: 1, now: 0, padTop: 0 }; private mode: Mode = { kind: "list" }; /** Which of the ringing stage's two buttons is highlighted. */ private ringButton = 0; @@ -247,7 +259,9 @@ export class TimersLayer implements Layer { let index = rows.findIndex((row) => row.key === this.selectionKey); if (index < 0) { // The row went away (a dismissed timer, a deleted alarm): stay in place. - const firstVisibleRow = Math.floor(this.list.scrollTop / listRowHeight(smallFont())); + // Rows start below the list's top padding, which scrolls with them. + const rowsScrolled = Math.max(0, this.list.scrollTop - this.listPaint.padTop) / listRowHeight(smallFont()); + const firstVisibleRow = Math.floor(rowsScrolled); index = clamp(firstVisibleRow, 0, rows.length - 1); while (index < rows.length && rows[index]!.kind === "header") index++; if (index >= rows.length) index = rows.findIndex((row) => row.kind !== "header"); @@ -579,9 +593,7 @@ export class TimersLayer implements Layer { /** A mirror touch: on the list, select the row under it. */ hitTest(x: number, y: number, ctx: LayerContext): boolean { if (this.mode.kind !== "list") return false; - const { width } = ctx.stack.getBaseSize(); - const listX = width - listWidthFor(width); - if (x < listX) return false; + if (x < columnsFor(ctx.stack.getBaseSize()).listX) return false; const rows = this.buildRows(Date.now()); this.syncList(rows); const index = this.list.indexAt(y); @@ -874,18 +886,17 @@ export class TimersLayer implements Layer { paint(ctx: LayerContext): GrayImage { timerEngine.check(); const now = Date.now(); - const { width, height } = ctx.stack.getBaseSize(); + const viewport = ctx.stack.getBaseSize(); + const { width, height, padding } = viewport; const image = new GrayImage(width, height, 0); const rows = this.buildRows(now); const selectedIndex = this.reconcileSelection(rows); - const listWidth = listWidthFor(width); - const listX = width - listWidth; + const { dividerX, stage } = columnsFor(viewport); const picking = this.mode.kind !== "list"; - this.paintList(image, rows, selectedIndex, listX, listWidth, height, ctx.stack.isFocused(), picking ? LIST_DIM : 1, now); - image.drawLine(listX - 7, 8, listX - 7, height - 8, picking ? 20 : 40); + this.paintList(image, rows, selectedIndex, viewport, ctx.stack.isFocused(), picking ? LIST_DIM : 1, now); + image.drawLine(dividerX, padding.top, dividerX, height - padding.bottom, picking ? 20 : 40); - const stage = { x: STAGE_X, y: 0, width: listX - 7 - STAGE_LIST_GAP - STAGE_X, height }; switch (this.mode.kind) { case "dial": this.paintDial(image, stage, this.mode, now); @@ -906,21 +917,23 @@ export class TimersLayer implements Layer { image: GrayImage, rows: Row[], selectedIndex: number, - listX: number, - listWidth: number, - height: number, + viewport: Viewport, focused: boolean, dim: number, now: number, ): void { - const rowHeight = listRowHeight(smallFont()); - const visible = Math.max(1, Math.floor((height - 2 * LIST_TOP) / rowHeight)); - this.listPaint = { dim, now }; + const { height, padding } = viewport; + const { listX, rowsWidth, scrollbarX } = columnsFor(viewport); + this.listPaint = { dim, now, padTop: padding.top }; // While a picker owns the stage the list has no live selection, so no // highlight; drawListRow still brightens the selected row by key. this.list.setItems(rows, dim === 1 ? selectedIndex : null); - this.list.paint(image, { x: listX, y: LIST_TOP, width: listWidth - 12, height: visible * rowHeight - LIST_ROW_GAP }, focused); - this.list.drawScrollbar(image, listX + listWidth - 7, LIST_TOP, visible * rowHeight - 4); + // The list scrolls, so it runs to the window's top and bottom edges, + // with the padding suggested for them inside it (before the first row, + // after the last): rows scrolled past an end are cut off at the edge. + // The scrollbar stays put, so it keeps inside that padding. + this.list.paint(image, { x: listX, y: 0, width: rowsWidth, height, padTop: padding.top, padBottom: padding.bottom }, focused); + this.list.drawScrollbar(image, scrollbarX, padding.top, Math.max(0, height - padding.top - padding.bottom)); } private drawListRow({ image, item: row, x, y, width, height }: MenuDrawArgs): void { @@ -1137,7 +1150,13 @@ export class TimersLayer implements Layer { // --------------------------------------------------------------------------- // Stage layout helpers -type StageRect = { x: number; y: number; width: number; height: number }; +/** + * The stage's box: its title's left edge and top, and the bottom of its + * hints. `centerX` is what its centred content (the big digits, the picker + * fields) centres on: the middle of the stage's column, from the window's + * left edge to the divider, whatever padding the box keeps inside that. + */ +type StageRect = { x: number; y: number; width: number; height: number; centerX: number }; /** * Lays the stage out top to bottom: a title line, the big digits, then @@ -1149,13 +1168,28 @@ class StageBlock { private readonly hintsTop: number; constructor(private readonly rect: StageRect) { - this.cursorY = rect.y + 12; - this.hintsTop = rect.y + rect.height - 10 - lineStep(smallFont()); + this.cursorY = rect.y; + this.hintsTop = rect.y + rect.height - smallFont().lineHeight; + } + + /** The stage's small-font content: its left edge and width. */ + private get bodyX(): number { + return this.rect.x + STAGE_BODY_INSET; + } + + private get bodyWidth(): number { + return this.rect.width - 2 * STAGE_BODY_INSET; + } + + /** Where content `width` wide sits to be centred on the stage's column, kept inside the stage. */ + private centeredX(width: number): number { + const { x, width: stageWidth, centerX } = this.rect; + return clamp(Math.floor(centerX - width / 2), x, Math.max(x, x + stageWidth - width)); } title(image: GrayImage, text: string, value: number): void { const font = mediumFont(); - image.drawText(font, this.rect.x + 4, this.cursorY, truncateText(font, text, this.rect.width - 8), value); + image.drawText(font, this.rect.x, this.cursorY, truncateText(font, text, this.rect.width), value); this.cursorY += font.lineHeight + 10; } @@ -1163,9 +1197,9 @@ class StageBlock { digits(image: GrayImage, text: string, value: number, suffix = ""): void { const suffixFont = mediumFont(); const suffixWidth = suffix ? suffixFont.measureText(suffix) + 10 : 0; - const font = fittingDigitFont(text, this.rect.width - 8 - suffixWidth); + const font = fittingDigitFont(text, this.rect.width - suffixWidth); const textWidth = font.measureText(text); - const x = this.rect.x + Math.max(0, Math.floor((this.rect.width - textWidth - suffixWidth) / 2)); + const x = this.centeredX(textWidth + suffixWidth); image.drawText(font, x, this.cursorY, text, value); if (suffix) { image.drawText(suffixFont, x + textWidth + 10, this.cursorY + font.ascent - suffixFont.ascent, suffix, Math.round(value * 0.8)); @@ -1174,8 +1208,8 @@ class StageBlock { } progress(image: GrayImage, fraction: number, value: number): void { - const x = this.rect.x + 6; - const width = this.rect.width - 12; + const x = this.bodyX; + const width = this.bodyWidth; image.fillRoundedRect(x, this.cursorY, width, 6, 40, 3); const filled = Math.round(width * clamp(fraction, 0, 1)); if (filled > 0) image.fillRoundedRect(x, this.cursorY, Math.max(6, filled), 6, value, 3); @@ -1185,7 +1219,7 @@ class StageBlock { line(image: GrayImage, text: string, value: number): void { if (!text) return; const font = smallFont(); - image.drawText(font, this.rect.x + 6, this.cursorY, truncateText(font, text, this.rect.width - 12), value); + image.drawText(font, this.bodyX, this.cursorY, truncateText(font, text, this.bodyWidth), value); this.cursorY += lineStep(font); } @@ -1197,8 +1231,8 @@ class StageBlock { /** A three-column row (lap table). */ columns(image: GrayImage, font: UiFont, cells: string[], value: number): void { if (this.cursorY + font.lineHeight > this.hintsTop - 4) return; - const x = this.rect.x + 6; - const width = this.rect.width - 12; + const x = this.bodyX; + const width = this.bodyWidth; const columnWidth = Math.floor(width / cells.length); for (let index = 0; index < cells.length; index++) { const text = cells[index]!; @@ -1215,8 +1249,8 @@ class StageBlock { this.line(image, "Once", Math.round(value * 0.7)); return; } - const step = Math.min(26, Math.floor((this.rect.width - 12) / 7)); - const x = this.rect.x + 6; + const step = Math.min(26, Math.floor(this.bodyWidth / 7)); + const x = this.bodyX; for (let index = 0; index < 7; index++) { const on = (mask & DAY_BITS[index]!) !== 0; const letter = DAY_LETTERS[index]!; @@ -1236,7 +1270,7 @@ class StageBlock { const widths = values.map((value) => font.measureText(value) + 2 * padX); const sepWidths = separators.map((separator) => (separator ? sepFont.measureText(separator) + 8 : 6)); const total = widths.reduce((sum, width) => sum + width, 0) + sepWidths.reduce((sum, width) => sum + width, 0); - let x = this.rect.x + Math.max(0, Math.floor((this.rect.width - total) / 2)); + let x = this.centeredX(total); const boxHeight = font.lineHeight + 4; for (let index = 0; index < values.length; index++) { const width = widths[index]!; @@ -1267,10 +1301,10 @@ class StageBlock { const font = smallFont(); const gap = 12; const height = font.lineHeight + 14; - const width = Math.floor((this.rect.width - 12 - gap * (labels.length - 1)) / labels.length); + const width = Math.floor((this.bodyWidth - gap * (labels.length - 1)) / labels.length); const y = Math.max(this.cursorY + 4, this.hintsTop - 10 - height); for (let index = 0; index < labels.length; index++) { - const x = this.rect.x + 6 + index * (width + gap); + const x = this.bodyX + index * (width + gap); const active = index === selected; if (active) { image.fillRoundedRect(x, y, width, height, focused ? 40 : 15, 8); @@ -1285,12 +1319,35 @@ class StageBlock { } hints(image: GrayImage, pairs: Array<[string, string]>): void { - image.drawText(smallFont(), this.rect.x + 6, this.hintsTop, gestureHints(pairs), 110); + image.drawText(smallFont(), this.bodyX, this.hintsTop, gestureHints(pairs), 110); } } -function listWidthFor(viewportWidth: number): number { - return clamp(Math.round(viewportWidth * LIST_SHARE), LIST_MIN_WIDTH, LIST_MAX_WIDTH); +/** + * The screen's columns in a viewport. Fixed content keeps the padding + * suggested for the window's edges: the stage's box sits inside it on the + * left, top and bottom, and the list column (rows, then the scrollbar's + * gutter) ends at it on the right. The divider stands between the two. + */ +function columnsFor(viewport: Viewport): { listX: number; rowsWidth: number; scrollbarX: number; dividerX: number; stage: StageRect } { + const { width, height, padding } = viewport; + const listRight = width - padding.right; + const listWidth = clamp(Math.round((listRight - padding.left) * LIST_SHARE), LIST_MIN_WIDTH, LIST_MAX_WIDTH); + const listX = listRight - listWidth; + const dividerX = listX - LIST_DIVIDER_GAP; + return { + listX, + rowsWidth: listWidth - LIST_SCROLLBAR_GUTTER, + scrollbarX: listRight - LIST_SCROLLBAR_GUTTER + LIST_SCROLLBAR_GAP, + dividerX, + stage: { + x: padding.left, + y: padding.top, + width: Math.max(0, dividerX - STAGE_LIST_GAP - padding.left), + height: Math.max(0, height - padding.top - padding.bottom), + centerX: dividerX / 2, + }, + }; } function drawPauseMark(image: GrayImage, x: number, y: number, value: number): void { diff --git a/app/apps/transcribe/index.ts b/app/apps/transcribe/index.ts index d5e504c6..ccdcddf9 100644 --- a/app/apps/transcribe/index.ts +++ b/app/apps/transcribe/index.ts @@ -1,5 +1,32 @@ -import { type AppDefinition } from "../app-definition"; -import { createTranscribeAppWindow, TRANSCRIBE_SURFACE_ID, TRANSCRIBE_WINDOW_ID } from "./transcribe-app"; +import { type AppContext, type AppDefinition } from "../app-definition"; +import { + createTranscribeAppWindow, + createTranscribeReplayWindow, + TRANSCRIBE_SURFACE_ID, + TRANSCRIBE_WINDOW_ID, +} from "./transcribe-app"; + +// Replay windows are closeable and non-singleton; the serial keeps their windowIds unique. +let nextReplaySerial = 1; + +/** + * Open a recording (.mka) in Transcribe's replay mode, as a window of its + * own. Returns false where recordings can't be replayed. + */ +export function openRecordingInTranscribe(ctx: AppContext, path: string, name: string): boolean { + if (!ctx.actions.openVoiceReplay) return false; + const windowId = `transcribe:replay:${nextReplaySerial++}`; + void ctx + .launchInProcessApp(windowId, `window:${windowId}`, (options) => { + const window = createTranscribeReplayWindow(windowId, path, name, options); + if (!window) throw new Error("recordings can't be replayed here"); + return window; + }) + .catch((error) => { + ctx.appendLog(`transcribe replay window failed: ${error}`); + }); + return true; +} const transcribeApp: AppDefinition = { appId: "transcribe", diff --git a/app/apps/transcribe/replay-time.ts b/app/apps/transcribe/replay-time.ts new file mode 100644 index 00000000..29c6268c --- /dev/null +++ b/app/apps/transcribe/replay-time.ts @@ -0,0 +1,23 @@ +/** A position in a recording as m:ss, or h:mm:ss from an hour on (or when `withHours`). */ +export function formatReplayTime(ms: number, withHours = false): string { + const total = Math.max(0, Math.floor(ms / 1000)); + const hours = Math.floor(total / 3600); + const minutes = Math.floor((total % 3600) / 60); + const seconds = String(total % 60).padStart(2, "0"); + if (hours === 0 && !withHours) return `${minutes}:${seconds}`; + return `${hours}:${String(minutes).padStart(2, "0")}:${seconds}`; +} + +/** The time picker's fields, in display and click order. */ +export const TIME_FIELDS = ["hours", "minutes", "seconds"] as const; +export type TimeField = (typeof TIME_FIELDS)[number]; + +const FIELD_SECONDS: Record = { hours: 3600, minutes: 60, seconds: 1 }; + +/** + * Step a position (whole seconds) by `delta` of a field's unit, carrying + * into the neighboring fields, within [0, maxSeconds]. + */ +export function stepReplaySeconds(seconds: number, field: TimeField, delta: number, maxSeconds: number): number { + return Math.max(0, Math.min(maxSeconds, seconds + delta * FIELD_SECONDS[field])); +} diff --git a/app/apps/transcribe/time-picker.ts b/app/apps/transcribe/time-picker.ts new file mode 100644 index 00000000..3bb281e6 --- /dev/null +++ b/app/apps/transcribe/time-picker.ts @@ -0,0 +1,147 @@ +import { GrayImage } from "../../graphics/image"; +import { getDefaultMediumFont, getDefaultSmallFont } from "../../graphics/ui-fonts"; +import { GESTURE_CLICK, GESTURE_DOUBLE_CLICK, GESTURE_SCROLL, gestureHints, type InputEvent } from "../../ui/gestures"; +import type { Layer, LayerContext, PaintBelow } from "../../ui/layers"; +import { CONTEXT_MENU_DIM } from "../../ui/menu"; +import { centeredTextY } from "../../ui/metrics"; +import { formatReplayTime, stepReplaySeconds, TIME_FIELDS, type TimeField } from "./replay-time"; + +const PADDING = 12; +const FIELD_GAP = 6; +const FIELD_PAD_X = 6; +/** Fill and outline of the active field (the Timers and date pickers' field style). */ +const ACTIVE_FILL = 35; +const ACTIVE_STROKE = 130; + +export type TimePickerOptions = { + title: string; + /** Where the picker starts, and the furthest it goes, in ms. */ + initialMs: number; + maxMs: number; + onPick: (positionMs: number) => void; +}; + +/** + * A modal position picker for a recording: hours (when the recording has + * any), minutes and seconds, over the dimmed content beneath. Input follows + * the date picker's: scroll adjusts the active field (up is later, carrying + * into the fields beside it), click moves to the next field and on the last + * one picks, double-click steps back a field and on the first one cancels. + * A watch's swipes move between fields and adjust. + */ +export class TimePickerLayer implements Layer { + readonly acceptsDirectional = true; + readonly dimUnderneath = CONTEXT_MENU_DIM; + private readonly fields: readonly TimeField[]; + private readonly maxSeconds: number; + private seconds: number; + private field = 0; + + constructor(private readonly options: TimePickerOptions) { + this.maxSeconds = Math.max(0, Math.floor(options.maxMs / 1000)); + this.seconds = Math.max(0, Math.min(this.maxSeconds, Math.floor(options.initialMs / 1000))); + this.fields = this.maxSeconds >= 3600 ? TIME_FIELDS : TIME_FIELDS.slice(1); + } + + handleInput(event: InputEvent, ctx: LayerContext): void { + switch (event.type) { + case "scroll-up": + case "swipe-up": + this.adjust(1); + return; + case "scroll-down": + case "swipe-down": + this.adjust(-1); + return; + case "swipe-right": + this.field = Math.min(this.fields.length - 1, this.field + 1); + return; + case "swipe-left": + this.field = Math.max(0, this.field - 1); + return; + case "click": + if (this.field < this.fields.length - 1) { + this.field++; + } else { + ctx.stack.pop(); + this.options.onPick(this.seconds * 1000); + } + return; + case "double-click": + if (this.field > 0) this.field--; + else ctx.stack.pop(); + return; + default: + return; + } + } + + private adjust(delta: number): void { + this.seconds = stepReplaySeconds(this.seconds, this.fields[this.field]!, delta, this.maxSeconds); + } + + private hints(field: number): string { + return gestureHints([ + [GESTURE_SCROLL, "adjust"], + [GESTURE_CLICK, field < this.fields.length - 1 ? "next" : "jump"], + [GESTURE_DOUBLE_CLICK, field > 0 ? "back" : "cancel"], + ]); + } + + paint(ctx: LayerContext, paintBelow: PaintBelow): GrayImage { + const image = paintBelow(); + const small = getDefaultSmallFont(); + const medium = getDefaultMediumFont(); + const focused = ctx.stack.isFocused(); + const base = ctx.stack.getBaseSize(); + + const values = [ + String(Math.floor(this.seconds / 3600)), + String(Math.floor((this.seconds % 3600) / 60)).padStart(this.fields.length === 3 ? 2 : 1, "0"), + String(this.seconds % 60).padStart(2, "0"), + ].slice(TIME_FIELDS.length - this.fields.length); + // Sized for the widest value a field can show, so the dialog holds still while the time changes. + const fieldWidths = this.fields.map( + (field) => Math.max(medium.measureText("000"), small.measureText(field)) + 2 * FIELD_PAD_X, + ); + const fieldsWidth = fieldWidths.reduce((sum, width) => sum + width, 0) + FIELD_GAP * (fieldWidths.length - 1); + const boxHeight = medium.lineHeight + 6; + const length = `of ${formatReplayTime(this.maxSeconds * 1000)}`; + const hintsWidth = Math.max(...this.fields.map((_, index) => small.measureText(this.hints(index)))); + const width = Math.min( + base.width, + Math.max(fieldsWidth, hintsWidth, small.measureText(this.options.title), small.measureText(length)) + 2 * PADDING, + ); + const titleHeight = small.lineHeight + 12; + const bodyHeight = boxHeight + 2 + small.lineHeight + 10 + small.lineHeight; + const height = Math.min(base.height, 8 + titleHeight + bodyHeight + 12 + small.lineHeight + 10); + const x = Math.max(0, Math.floor((base.width - width) / 2)); + const y = Math.max(0, Math.floor((base.height - height) / 2)); + + // Fill 1, not 0: 0 is the transparent color key on the shell surface. + image.fillRoundedRect(x, y, width, height, 1); + image.drawRoundedRect(x, y, width, height, 72); + image.drawText(small, x + PADDING, y + 8, this.options.title, 220); + + const top = y + 8 + titleHeight; + let fieldX = x + PADDING; + for (let index = 0; index < this.fields.length; index++) { + const fieldWidth = fieldWidths[index]!; + const active = index === this.field; + if (active) { + if (focused) image.fillRoundedRect(fieldX, top, fieldWidth, boxHeight, ACTIVE_FILL, 6); + image.drawRoundedRect(fieldX, top, fieldWidth, boxHeight, ACTIVE_STROKE, 6); + } + const value = values[index]!; + image.drawText(medium, fieldX + Math.floor((fieldWidth - medium.measureText(value)) / 2), + centeredTextY(medium, top, boxHeight), value, active ? 250 : 170); + const caption = this.fields[index]!; + image.drawText(small, fieldX + Math.floor((fieldWidth - small.measureText(caption)) / 2), + top + boxHeight + 2, caption, active ? 190 : 110); + fieldX += fieldWidth + FIELD_GAP; + } + image.drawText(small, x + PADDING, top + bodyHeight - small.lineHeight, length, 190); + image.drawText(small, x + PADDING, y + height - 10 - small.lineHeight, this.hints(this.field), 110); + return image; + } +} diff --git a/app/apps/transcribe/transcribe-app.ts b/app/apps/transcribe/transcribe-app.ts index 900af357..1bd34659 100644 --- a/app/apps/transcribe/transcribe-app.ts +++ b/app/apps/transcribe/transcribe-app.ts @@ -1,5 +1,11 @@ -import { imageFromAsciiArt } from "../../graphics/image"; +import { imageFromAsciiArt, type GrayImage } from "../../graphics/image"; +import { voiceControlBridge } from "../../native/voice-control"; +import { enumSettingMenuItem, saveRecordingSetting, toggleSettingMenuItem } from "../../ui/dashboard-settings"; +import { type ContinuousCaptureOptions } from "../../ui/layers"; +import { withRecordingIcon } from "../../ui/listening-header"; +import { TimePickerLayer } from "./time-picker"; import { TranscribeLayer, transcriptTimestamp } from "./transcribe"; +import { transcribeMicCount, transcribeMicsSetting } from "./transcribe-settings"; import { createInProcessWindow, YieldAtRootLayer, @@ -13,8 +19,8 @@ export const TRANSCRIBE_SURFACE_ID = "window:transcribe"; const TRAY_ICON_ID = "transcribe"; -// 16x18 microphone glyph for the top-bar tray (also Translate's). -export const MIC_ICON = imageFromAsciiArt( +// 14x15 microphone glyph for the top-bar tray (also Translate's). +const MIC_ICON = imageFromAsciiArt( [ " #### ", " ###### ", @@ -34,10 +40,16 @@ export const MIC_ICON = imageFromAsciiArt( ], { "#": 220 }, ); +const MIC_RECORDING_ICON = withRecordingIcon(MIC_ICON); + +/** The listening apps' tray icon: a microphone, with the recording circle while their audio is saved. */ +export function micTrayIcon(recording: boolean): GrayImage { + return recording ? MIC_RECORDING_ICON : MIC_ICON; +} export type TranscribeAppOptions = InProcessAppOptions & { - /** Begin continuous mic capture (kept on while the window is open). */ - startContinuousVoiceCapture: (options?: { recordAs?: string }) => void; + /** Begin (or retarget) continuous mic capture, kept on while the window is open. */ + startContinuousVoiceCapture: (options?: ContinuousCaptureOptions) => void; stopContinuousVoiceCapture: () => void; }; @@ -50,6 +62,10 @@ export function createTranscribeAppWindow(options: TranscribeAppOptions): InProc // One timestamp per session names both the audio recording and a saved transcript. const stamp = transcriptTimestamp(); const layer = new TranscribeLayer(stamp); + // At launch, and again when the Microphones setting changes: a running + // capture moves over to the microphones now asked for. + const startCapture = () => + options.startContinuousVoiceCapture({ recordAs: `transcribe-${stamp}`, mics: transcribeMicCount() }); const app = createInProcessWindow({ appId: "transcribe", windowId: TRANSCRIBE_WINDOW_ID, @@ -59,18 +75,24 @@ export function createTranscribeAppWindow(options: TranscribeAppOptions): InProc closeable: true, actions: options.actions, baseLayer: new YieldAtRootLayer(layer), - menuItems: () => [{ - label: "Save", - onSelect: (ctx) => { - ctx.stack.pop(); - layer.saveTranscript(); + menuItems: () => [ + { + label: "Save", + onSelect: (ctx) => { + ctx.stack.pop(); + layer.saveTranscript(); + }, }, - }], + // The controller starts and stops the recording as the setting changes. + toggleSettingMenuItem(saveRecordingSetting), + enumSettingMenuItem(transcribeMicsSetting, { onChange: startCapture }), + ], submitFrame: options.submitFrame, setSurfaceVisible: options.setSurfaceVisible, removeSurface: options.removeSurface, onClosed: () => { layer.onRemoved(); + unsubscribeRecording(); options.stopContinuousVoiceCapture(); shell.setTrayIcon(TRAY_ICON_ID, null); options.onClosed(); @@ -79,7 +101,100 @@ export function createTranscribeAppWindow(options: TranscribeAppOptions): InProc // Wire async state changes to this window's renderer, rather than the // controller action from which the window-specific actions were derived. layer.start(app.requestRender, () => shell.isWindowVisible(TRANSCRIBE_WINDOW_ID)); - options.startContinuousVoiceCapture({ recordAs: `transcribe-${stamp}` }); - shell.setTrayIcon(TRAY_ICON_ID, MIC_ICON); + const unsubscribeRecording = voiceControlBridge.onRecordingChange(() => { + shell.setTrayIcon(TRAY_ICON_ID, micTrayIcon(voiceControlBridge.recording)); + app.requestRender(); + }); + startCapture(); + shell.setTrayIcon(TRAY_ICON_ID, micTrayIcon(voiceControlBridge.recording)); + return app; +} + +/** + * Transcribe in replay mode: a window of its own that transcribes a + * recording (a .mka file from Save Recording) in place of the microphones, + * in real time and through the same pipeline. It neither uses the mic nor + * shows the mic tray icon, so it runs beside a live Transcribe window. The + * header shows the position in the recording; a tap pauses and resumes; the + * menu jumps to a time. + */ +export function createTranscribeReplayWindow( + windowId: string, + path: string, + name: string, + options: InProcessAppOptions, +): InProcessWindow | null { + const replay = options.actions.openVoiceReplay?.(path) ?? null; + if (!replay) return null; + // Names a saved transcript after the recording it came from. + const layer = new TranscribeLayer(name.replace(/\.[^.]+$/, ""), replay, name); + const app = createInProcessWindow({ + appId: "transcribe", + windowId, + title: name, + iconLetter: "Tr", + icon: "mic", + closeable: true, + // Relaunching Transcribe after a restart would open the microphone, not this recording. + restoresApp: false, + // Like a playing video: something to watch, not to touch. + keepsScreenOn: () => replay.state === "playing", + actions: options.actions, + baseLayer: new YieldAtRootLayer(layer), + menuItems: () => [ + { + label: "Jump to time", + // The length isn't known until the recording has been opened. + disabled: () => replay.durationMs <= 0, + onSelect: (ctx) => { + ctx.stack.pop(); + ctx.stack.push( + new TimePickerLayer({ + title: "Jump to time", + initialMs: replay.positionMs, + maxMs: replay.durationMs, + onPick: (positionMs) => { + replay.jumpTo(positionMs); + app.requestRender(); + }, + }), + ); + }, + }, + { + label: replay.state === "paused" ? "Resume" : "Pause", + disabled: () => replay.state !== "playing" && replay.state !== "paused", + onSelect: (ctx) => { + ctx.stack.pop(); + replay.setPaused(replay.state === "playing"); + }, + }, + { + label: "Restart from 0:00", + onSelect: (ctx) => { + ctx.stack.pop(); + replay.jumpTo(0); + }, + }, + { + label: "Save", + onSelect: (ctx) => { + ctx.stack.pop(); + layer.saveTranscript(); + }, + }, + ], + submitFrame: options.submitFrame, + setSurfaceVisible: options.setSurfaceVisible, + removeSurface: options.removeSurface, + onClosed: () => { + layer.onRemoved(); + replay.close(); + options.onClosed(); + }, + }); + // Started first, so the layer picks its opening status up as it subscribes. + replay.start(); + layer.start(app.requestRender, () => shell.isWindowVisible(windowId)); return app; } diff --git a/app/apps/transcribe/transcribe-settings.ts b/app/apps/transcribe/transcribe-settings.ts new file mode 100644 index 00000000..f9cc68f6 --- /dev/null +++ b/app/apps/transcribe/transcribe-settings.ts @@ -0,0 +1,40 @@ +import { ConfigSettingEnum, glassesTypeSetting } from "../../ui/dashboard-settings"; +import { type MicCount } from "../../ui/layers"; +import { micControlSupported } from "../microphones/mic-control"; + +export type TranscribeMics = "1" | "2" | "4"; + +const MICS_LABELS: Record = { + "1": "1 (mixed)", + "2": "2 (one per temple)", + "4": "4 (two per temple)", +}; + +/** Whether the paired glasses can stream their microphones separately (G2, with the microphone channel in use). */ +export function separateMicsSupported(): boolean { + return glassesTypeSetting.get() === "g2" && micControlSupported(); +} + +/** + * How many of the glasses' microphones Transcribe captures. With more than + * one, the temples stream their own microphones (each temple on its own + * clock) instead of the glasses' mixed stream; a recording keeps every one, + * and what is transcribed is a mix made on the phone. + */ +export const transcribeMicsSetting = new ConfigSettingEnum({ + id: "transcribe-mics", + label: "Microphones", + storageKey: "transcribe.mics", + defaultValue: "1", + values: ["1", "2", "4"], + formatValue: (value) => MICS_LABELS[value], + isDisabled: (value) => value !== "1" && !separateMicsSupported(), + description: + "Which of the glasses' microphones to capture. 1 is the glasses' own mixed stream. 2 and 4 stream each temple's microphones separately (custom firmware), so a saved recording has every microphone on its own channel; the transcript then comes from a mix made on the phone.", +}); + +/** The setting as a capture option; 1 where the glasses can't stream their microphones separately. */ +export function transcribeMicCount(): MicCount { + if (!separateMicsSupported()) return 1; + return Number(transcribeMicsSetting.get()) as MicCount; +} diff --git a/app/apps/transcribe/transcribe.ts b/app/apps/transcribe/transcribe.ts index 2fd35a6c..78797709 100644 --- a/app/apps/transcribe/transcribe.ts +++ b/app/apps/transcribe/transcribe.ts @@ -1,17 +1,22 @@ import { GrayImage } from "../../graphics/image"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { lineStep } from "../../ui/metrics"; -import { MicLevelMeter, paintListeningHeader } from "../../ui/listening-header"; +import { MicLevelMeter, paintListeningHeader, RECORDING_FAILED_NOTICE } from "../../ui/listening-header"; import { writeTextToDownloads } from "../../native/file-access"; -import { voiceControlBridge } from "../../native/voice-control"; +import { voiceControlBridge, type VoiceEventSource, type VoiceReplay } from "../../native/voice-control"; import { Layer, type LayerContext } from "../../ui/layers"; import { type InputEvent } from "../../ui/gestures"; -import { TranscriptModel, TranscriptScroll, wrapTranscribeText } from "./transcript-model"; +import { formatReplayTime } from "./replay-time"; +import { TranscriptModel, TranscriptScroll, transcriptLayout, wrapTranscribeText } from "./transcript-model"; /** * Live transcription view. Continuous mic capture is owned by the app wrapper * (createTranscribeAppWindow); this layer accumulates the transcript, shows * it, and saves it to Downloads from the app menu. + * + * Given a replay, it transcribes that recording instead of the microphone: + * the header shows the position in the recording, a tap pauses and resumes, + * and each jump leaves its time as a line in the transcript. */ export class TranscribeLayer implements Layer { private status = "Starting microphone..."; @@ -24,49 +29,101 @@ export class TranscribeLayer implements Layer { private unsubscribeTranscript: (() => void) | null = null; private unsubscribePause: (() => void) | null = null; private unsubscribeStatus: (() => void) | null = null; + private unsubscribeReplay: (() => void) | null = null; + private readonly source: VoiceEventSource; - /** `stamp` names the saved transcript, matching the session's audio recording. */ - constructor(private readonly stamp: string = transcriptTimestamp()) {} + /** + * `stamp` names the saved transcript, matching the session's audio + * recording. `replay` is the recording to transcribe in place of the + * microphone; `replayName` is what to call it. + */ + constructor( + private readonly stamp: string = transcriptTimestamp(), + private readonly replay: VoiceReplay | null = null, + private readonly replayName = "", + ) { + this.source = replay ? replay.events : voiceControlBridge; + if (replay) this.status = "Opening the recording..."; + } - /** `isVisible` says whether the window is on screen (the level meter repaints only then). */ + /** `isVisible` says whether the window is on screen (the level meter and replay clock repaint only then). */ start(requestRender: () => void, isVisible: () => boolean): void { - this.meter.start(requestRender, isVisible); - this.unsubscribeTranscript = voiceControlBridge.onTranscript((event) => { + this.meter.start(requestRender, isVisible, this.source); + this.unsubscribeTranscript = this.source.onTranscript((event) => { this.transcript.accept(event); requestRender(); }); - this.unsubscribePause = voiceControlBridge.onSpeechPause(() => this.transcript.pause()); - this.unsubscribeStatus = voiceControlBridge.onStatus((state) => { + this.unsubscribePause = this.source.onSpeechPause(() => this.transcript.pause()); + // The current status arrives while subscribing, before the window has a + // surface to render to; the window paints it when it is first shown. + let subscribing = true; + this.unsubscribeStatus = this.source.onStatus((state) => { this.status = state.status; this.listening = state.listening; this.detail = state.detail; this.saveNotice = ""; - requestRender(); + if (!subscribing) requestRender(); }); + subscribing = false; + const replay = this.replay; + if (replay) { + let shownSecond = -1; + let shownState = replay.state; + this.unsubscribeReplay = replay.onChange((jumpedToMs) => { + if (jumpedToMs !== undefined) this.transcript.mark(`[${formatReplayTime(jumpedToMs)}]`); + // The clock ticks in whole seconds; repaint when what it shows changed. + const second = Math.floor(replay.positionMs / 1000); + if (jumpedToMs === undefined && second === shownSecond && replay.state === shownState) return; + shownSecond = second; + shownState = replay.state; + if (isVisible()) requestRender(); + }); + } + } + + /** The header's status for a replay: where it is in the recording, and anything worth saying beside that. */ + private replayStatus(replay: VoiceReplay): string { + if (replay.state === "failed" || (replay.state === "opening" && replay.durationMs === 0)) return this.status; + const withHours = replay.durationMs >= 3_600_000; + const clock = `${formatReplayTime(replay.positionMs, withHours)} / ${formatReplayTime(replay.durationMs, withHours)}`; + if (replay.state === "paused") return `${clock} · Paused`; + if (replay.state === "ended") return `${clock} · Finished`; + // Anything but plain listening is worth showing: the model loading, a provider reconnecting. + return this.listening ? clock : `${clock} · ${this.status}`; } paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); - const image = new GrayImage(width, height, 0); - const text = this.transcript.text || (this.listening ? "Listening..." : this.detail); - const wrapped = wrapTranscribeText((line) => font.measureText(line), text, width - 64); + const viewport = ctx.stack.getBaseSize(); + const image = new GrayImage(viewport.width, viewport.height, 0); - const bodyTop = paintListeningHeader(image, font, "Transcribe", this.saveNotice || this.status, this.listening ? this.meter : null); + const replay = this.replay; + const status = replay + ? this.replayStatus(replay) + : this.source.recordingFailed ? RECORDING_FAILED_NOTICE : this.status; + const playing = !replay || replay.state === "playing"; + const bodyTop = paintListeningHeader( + image, font, "Transcribe", this.saveNotice || status, this.listening && playing ? this.meter : null, viewport.padding, + this.source.recording, + ); const step = lineStep(font) + 2; - const bodyLines = Math.max(1, Math.floor((height - 6 - bodyTop - font.lineHeight) / step) + 1); - const firstLine = this.scroll.layout(wrapped.length, bodyLines); - for (let index = firstLine; index < Math.min(wrapped.length, firstLine + bodyLines); index++) { + const layout = transcriptLayout(viewport, bodyTop, font.lineHeight, step); + const placeholder = replay ? `Replaying ${this.replayName}` : "Listening..."; + const text = this.transcript.text || (this.listening ? placeholder : this.detail); + const wrapped = wrapTranscribeText((line) => font.measureText(line), text, layout.textWidth); + + const firstLine = this.scroll.layout(wrapped.length, layout.pageLines); + for (let index = firstLine; index < Math.min(wrapped.length, firstLine + layout.drawnLines); index++) { const y = bodyTop + (index - firstLine) * step; - image.drawText(font, 32, y, wrapped[index]!, 230); + image.drawText(font, layout.textX, y, wrapped[index]!, 230); } - if (wrapped.length > bodyLines) { - const trackHeight = height - bodyTop - 6; - const thumbHeight = Math.max(8, Math.round(trackHeight * bodyLines / wrapped.length)); - const thumbY = bodyTop + Math.round((trackHeight - thumbHeight) * firstLine / (wrapped.length - bodyLines)); - image.fillRect(width - 14, bodyTop, 2, trackHeight, 45); - image.fillRect(width - 14, thumbY, 2, thumbHeight, 140); + if (wrapped.length > layout.pageLines) { + const track = layout.scrollbar; + const thumbHeight = Math.max(8, Math.round(track.height * layout.pageLines / wrapped.length)); + const thumbY = track.y + Math.round((track.height - thumbHeight) * firstLine / (wrapped.length - layout.pageLines)); + image.fillRect(track.x, track.y, track.width, track.height, 45); + image.fillRect(track.x, thumbY, track.width, thumbHeight, 140); } return image; } @@ -77,6 +134,11 @@ export class TranscribeLayer implements Layer { ctx.actions.requestRender(); return; } + if (event.type === "click" && this.replay) { + this.replay.setPaused(this.replay.state === "playing"); + ctx.actions.requestRender(); + return; + } if (event.type === "double-click") { ctx.stack.pop(); } @@ -84,6 +146,8 @@ export class TranscribeLayer implements Layer { onRemoved(): void { this.meter.stop(); + this.unsubscribeReplay?.(); + this.unsubscribeReplay = null; this.unsubscribePause?.(); this.unsubscribePause = null; this.unsubscribeTranscript?.(); diff --git a/app/apps/transcribe/transcript-model.ts b/app/apps/transcribe/transcript-model.ts index 8b0e811a..05befc46 100644 --- a/app/apps/transcribe/transcript-model.ts +++ b/app/apps/transcribe/transcript-model.ts @@ -1,3 +1,5 @@ +import type { Viewport } from "../../ui/viewport"; + type TranscriptEvent = { text: string; isFinal: boolean; @@ -34,6 +36,18 @@ export class TranscriptModel { if (this.live) this.breakAfterLive = true; else if (this.finalized) this.separator = "\n"; } + + /** + * A line of its own (where a replay jumped to), ending whatever was in + * progress: what follows it starts a new paragraph. + */ + mark(label: string): void { + const before = this.text; + this.finalized = before ? `${before}\n${label}` : label; + this.live = ""; + this.separator = "\n"; + this.breakAfterLive = false; + } } /** An absolute history position, with an explicit follow-tail mode. */ @@ -54,6 +68,50 @@ export class TranscriptScroll { } } +/** The scrollbar, and the room the transcript's lines leave for it at their right. */ +const SCROLLBAR_WIDTH = 2; +const SCROLLBAR_GUTTER = 8; + +export type TranscriptLayout = { + /** The text column: its left, and the width its lines wrap to. */ + textX: number; + textWidth: number; + /** Lines the view scrolls by: as many as fit above the bottom padding. */ + pageLines: number; + /** Lines to draw from the first one shown: as many as fit above the window's bottom edge. */ + drawnLines: number; + /** The scrollbar's track, for a transcript longer than a page. */ + scrollbar: { x: number; y: number; width: number; height: number }; +}; + +/** + * Where a listening view (Transcribe, Translate) puts its transcript, under + * a fixed header that ends at `top`. The text column starts at the padding + * suggested for the window's left edge (viewport.ts), in line with the + * header's title, and stops short of the right edge's by the scrollbar's + * gutter; the scrollbar stands in that, against the padding. The lines + * scroll, so they run to the window's bottom edge: the view scrolls by the + * lines that fit above that edge's padding, which rests the transcript's + * last line clear of a border there, and while more lines follow it draws + * as many as fit above the edge itself. + */ +export function transcriptLayout(viewport: Viewport, top: number, lineHeight: number, step: number): TranscriptLayout { + const { width, height, padding } = viewport; + const linesAbove = (bottom: number) => Math.max(1, Math.floor((bottom - top - lineHeight) / step) + 1); + return { + textX: padding.left, + textWidth: Math.max(0, width - padding.left - padding.right - SCROLLBAR_GUTTER), + pageLines: linesAbove(height - padding.bottom), + drawnLines: linesAbove(height), + scrollbar: { + x: width - padding.right - SCROLLBAR_WIDTH, + y: top, + width: SCROLLBAR_WIDTH, + height: Math.max(0, height - padding.bottom - top), + }, + }; +} + export function wrapTranscribeText(measure: (text: string) => number, text: string, maxWidth: number): string[] { const lines: string[] = []; for (const paragraph of text.split("\n")) { diff --git a/app/apps/translate/translate-app.ts b/app/apps/translate/translate-app.ts index dd0800ab..455a0aaa 100644 --- a/app/apps/translate/translate-app.ts +++ b/app/apps/translate/translate-app.ts @@ -7,11 +7,12 @@ import { translateProviderSetting, translateShowOriginalSetting, } from "./translate-settings"; -import { MIC_ICON } from "../transcribe/transcribe-app"; +import { micTrayIcon } from "../transcribe/transcribe-app"; import { transcriptTimestamp } from "../transcribe/transcribe"; +import { voiceControlBridge } from "../../native/voice-control"; import { type ContinuousCaptureOptions } from "../../ui/layers"; import { openSettingsSubMenu } from "../../ui/dashboard/settings-panel"; -import { enumSettingMenuItem, toggleSettingMenuItem } from "../../ui/dashboard-settings"; +import { enumSettingMenuItem, saveRecordingSetting, toggleSettingMenuItem } from "../../ui/dashboard-settings"; import { createInProcessWindow, YieldAtRootLayer, @@ -44,6 +45,11 @@ export type TranslateAppOptions = InProcessAppOptions & { * provider (Translate settings), which a shared capture switches to. */ export function createTranslateAppWindow(options: TranslateAppOptions): InProcessWindow { + // One timestamp per session names both the audio recording and a saved transcript. + const stamp = transcriptTimestamp(); + // Whether the mic tray icon is up (capture was asked for). + let trayIconShown = false; + const syncTrayIcon = () => shell.setTrayIcon(TRAY_ICON_ID, trayIconShown ? micTrayIcon(voiceControlBridge.recording) : null); // Checks the setup and (re)starts capture with the chosen provider and // language: at launch, when either setting changes, and on a tap after a // problem. @@ -51,15 +57,18 @@ export function createTranslateAppWindow(options: TranslateAppOptions): InProces const provider = resolveTranslateProvider(); const problem = !provider ? NO_PROVIDER_PROBLEM : !resolveTranslationModel() ? NO_MODEL_PROBLEM : null; layer.setProblem(problem); - if (!provider || problem) { + trayIconShown = Boolean(provider) && !problem; + if (provider && !problem) { + options.startContinuousVoiceCapture({ + recordAs: `translate-${stamp}`, + transcription: { provider, language: resolveTranslateLanguage() }, + }); + } else { options.stopContinuousVoiceCapture(); - shell.setTrayIcon(TRAY_ICON_ID, null); - return; } - options.startContinuousVoiceCapture({ transcription: { provider, language: resolveTranslateLanguage() } }); - shell.setTrayIcon(TRAY_ICON_ID, MIC_ICON); + syncTrayIcon(); }; - const layer = new TranslateLayer(transcriptTimestamp(), startCapture); + const layer = new TranslateLayer(stamp, startCapture); const app = createInProcessWindow({ appId: "translate", windowId: TRANSLATE_WINDOW_ID, @@ -77,6 +86,8 @@ export function createTranslateAppWindow(options: TranslateAppOptions): InProces layer.saveTranscript(); }, }, + // The controller starts and stops the recording as the setting changes. + toggleSettingMenuItem(saveRecordingSetting), { label: "Translate settings", onSelect: (ctx) => { @@ -94,6 +105,7 @@ export function createTranslateAppWindow(options: TranslateAppOptions): InProces removeSurface: options.removeSurface, onClosed: () => { layer.onRemoved(); + unsubscribeRecording(); options.stopContinuousVoiceCapture(); shell.setTrayIcon(TRAY_ICON_ID, null); options.onClosed(); @@ -102,6 +114,10 @@ export function createTranslateAppWindow(options: TranslateAppOptions): InProces // Wire async state changes to this window's renderer, rather than the // controller action from which the window-specific actions were derived. layer.start(app.requestRender, () => shell.isWindowVisible(TRANSLATE_WINDOW_ID)); + const unsubscribeRecording = voiceControlBridge.onRecordingChange(() => { + syncTrayIcon(); + app.requestRender(); + }); startCapture(); return app; } diff --git a/app/apps/translate/translate.ts b/app/apps/translate/translate.ts index e747be2d..18d52592 100644 --- a/app/apps/translate/translate.ts +++ b/app/apps/translate/translate.ts @@ -1,13 +1,13 @@ import { GrayImage } from "../../graphics/image"; import { getDefaultSmallFont } from "../../graphics/ui-fonts"; import { lineStep } from "../../ui/metrics"; -import { MicLevelMeter, paintListeningHeader } from "../../ui/listening-header"; +import { MicLevelMeter, paintListeningHeader, RECORDING_FAILED_NOTICE } from "../../ui/listening-header"; import { writeTextToDownloads } from "../../native/file-access"; import { voiceControlBridge } from "../../native/voice-control"; import { Layer, type LayerContext } from "../../ui/layers"; import { type InputEvent } from "../../ui/gestures"; import { type LlmStreamHandle } from "../../assistant/llm-protocol"; -import { TranscriptScroll, wrapTranscribeText } from "../transcribe/transcript-model"; +import { TranscriptScroll, transcriptLayout, wrapTranscribeText } from "../transcribe/transcript-model"; import { TranslationModel, type TranslationJob, type TranslationLine } from "./translation-model"; import { resolveTranslationModel, streamTranslation } from "./translate-llm"; import { resolveTranslateLanguage, spokenLanguageName, translateShowOriginalSetting } from "./translate-settings"; @@ -72,14 +72,20 @@ export class TranslateLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); - const image = new GrayImage(width, height, 0); + const viewport = ctx.stack.getBaseSize(); + const image = new GrayImage(viewport.width, viewport.height, 0); const measure = (line: string) => font.measureText(line); - const maxWidth = width - 64; - const status = this.problem ? "Setup needed" : this.translationError || this.status; + const status = this.problem + ? "Setup needed" + : voiceControlBridge.recordingFailed ? RECORDING_FAILED_NOTICE : this.translationError || this.status; const meter = this.listening && !this.problem ? this.meter : null; - const bodyTop = paintListeningHeader(image, font, "Translate", this.saveNotice || status, meter); + const bodyTop = paintListeningHeader( + image, font, "Translate", this.saveNotice || status, meter, viewport.padding, voiceControlBridge.recording, + ); + const step = lineStep(font) + 2; + const layout = transcriptLayout(viewport, bodyTop, font.lineHeight, step); + const maxWidth = layout.textWidth; let lines: TranslationLine[]; if (this.problem) { @@ -92,20 +98,18 @@ export class TranslateLayer implements Layer { } } - const step = lineStep(font) + 2; - const bodyLines = Math.max(1, Math.floor((height - 6 - bodyTop - font.lineHeight) / step) + 1); - const firstLine = this.scroll.layout(lines.length, bodyLines); - for (let index = firstLine; index < Math.min(lines.length, firstLine + bodyLines); index++) { + const firstLine = this.scroll.layout(lines.length, layout.pageLines); + for (let index = firstLine; index < Math.min(lines.length, firstLine + layout.drawnLines); index++) { const y = bodyTop + (index - firstLine) * step; - image.drawText(font, 32, y, lines[index]!.text, lines[index]!.gray); + image.drawText(font, layout.textX, y, lines[index]!.text, lines[index]!.gray); } - if (lines.length > bodyLines) { - const trackHeight = height - bodyTop - 6; - const thumbHeight = Math.max(8, Math.round(trackHeight * bodyLines / lines.length)); - const thumbY = bodyTop + Math.round((trackHeight - thumbHeight) * firstLine / (lines.length - bodyLines)); - image.fillRect(width - 14, bodyTop, 2, trackHeight, 45); - image.fillRect(width - 14, thumbY, 2, thumbHeight, 140); + if (lines.length > layout.pageLines) { + const track = layout.scrollbar; + const thumbHeight = Math.max(8, Math.round(track.height * layout.pageLines / lines.length)); + const thumbY = track.y + Math.round((track.height - thumbHeight) * firstLine / (lines.length - layout.pageLines)); + image.fillRect(track.x, track.y, track.width, track.height, 45); + image.fillRect(track.x, thumbY, track.width, thumbHeight, 140); } return image; } diff --git a/app/apps/weather/weather.ts b/app/apps/weather/weather.ts index 156bcb55..78ed84ce 100644 --- a/app/apps/weather/weather.ts +++ b/app/apps/weather/weather.ts @@ -7,29 +7,75 @@ import { type Layer, type LayerContext } from "../../ui/layers"; import { Menu, type MenuDrawArgs } from "../../ui/menu-core"; import { centeredTextY, lineStep, tightRowHeight } from "../../ui/metrics"; import { distanceUnitSetting } from "../../ui/dashboard-settings"; +import type { Viewport } from "../../ui/viewport"; import { renderWeatherIcon } from "./weather-icons"; import { formatTemperature, widestTemperatureSample } from "./temperature-format"; -const PAGE_X = 18; -const HEADER_Y = 8; -const CURRENT_TOP = 34; -/** Minimum x of the description column right of the temperature. */ -const CURRENT_TEXT_X = 112; +/** + * How far the page's text (title, current conditions, forecast names) starts + * right of the forecast rows' selection boxes, which span the padding + * suggested for the window's side edges. + */ +const PAGE_TEXT_INSET = 7; +/** + * The page's fixed parts, down from the title line at the window's top + * padding: the temperature, the description column's first line, the rule + * above the forecast, the forecast's column headings, and its first row's text. + */ +const TEMPERATURE_OFFSET_Y = 34; +const CURRENT_TEXT_OFFSET_Y = 22; +const FORECAST_RULE_OFFSET_Y = 90; +const FORECAST_HEADER_OFFSET_Y = 97; +const FORECAST_OFFSET_Y = 116; +/** Minimum distance of the description column from the page text's left edge. */ +const CURRENT_TEXT_MIN_OFFSET_X = 94; /** The current-conditions icon, left of the temperature. */ const CURRENT_ICON_SIZE = 40; const CURRENT_ICON_GAP = 10; /** Gap between the temperature and the description column. */ const CURRENT_TEXT_GAP = 16; -const FORECAST_HEADER_Y = 105; -const FORECAST_TOP = 124; /** Forecast rows hold a 20px icon; grow with the font past that. */ const FORECAST_MIN_ROW_HEIGHT = 23; /** Gap between forecast columns. */ const FORECAST_COL_GAP = 14; -/** Left edge of the forecast rows' selection boxes. */ -const FORECAST_BOX_X = PAGE_X - 7; /** Pixels between consecutive forecast rows' selection boxes. */ const FORECAST_ROW_GAP = 2; +/** A full-page message: its indent from the page text, and the least it sits below the title line. */ +const MESSAGE_INDENT = 6; +const MESSAGE_MIN_OFFSET_Y = 44; + +/** + * Where the page's parts go in a viewport. The forecast rows' selection + * boxes are the outermost thing toward the window's sides, so they sit at + * the padding suggested there, and the page's text is placed from them. + */ +type PageLayout = { + width: number; + height: number; + /** The forecast rows' selection boxes. */ + boxX: number; + boxWidth: number; + /** The span of the page's text: the title starts at textX, the location name ends at textRight. */ + textX: number; + textRight: number; + /** The title line's top, at the window's top padding. */ + top: number; + /** The window's bottom padding, kept under a footer line and inside the forecast list. */ + padBottom: number; +}; + +function pageLayout({ width, height, padding }: Viewport): PageLayout { + return { + width, + height, + boxX: padding.left, + boxWidth: width - padding.left - padding.right, + textX: padding.left + PAGE_TEXT_INSET, + textRight: width - padding.right - PAGE_TEXT_INSET, + top: padding.top, + padBottom: padding.bottom, + }; +} /** Forecast column x offsets from the row box's left edge. */ type ForecastColumns = { name: number; temp: number; precip: number; summary: number }; @@ -54,26 +100,20 @@ export class WeatherLayer implements Layer { paint(ctx: LayerContext): GrayImage { const font = getDefaultSmallFont(); - const { width, height } = ctx.stack.getBaseSize(); - const image = new GrayImage(width, height, 0); + const page = pageLayout(ctx.stack.getBaseSize()); + const image = new GrayImage(page.width, page.height, 0); const weather = this.state(); - image.drawText(font, PAGE_X, HEADER_Y, "Weather", 225); + image.drawText(font, page.textX, page.top, "Weather", 225); if (weather.locationName) { - image.drawText( - font, - width - PAGE_X - font.measureText(truncateText(font, weather.locationName, 220)), - HEADER_Y, - truncateText(font, weather.locationName, 220), - 150, - ); + const locationName = truncateText(font, weather.locationName, 220); + image.drawText(font, page.textRight - font.measureText(locationName), page.top, locationName, 150); } if (weather.phase === "permission-required") { this.drawMessage( image, font, - width, - height, + page, "Allow approximate location on your phone to get local weather.", `${GESTURE_CLICK} request`, ); @@ -81,16 +121,16 @@ export class WeatherLayer implements Layer { } // A refresh with earlier data in hand keeps showing that data. if ((weather.phase === "locating" || weather.phase === "loading") && !weather.current) { - this.drawMessage(image, font, width, height, weather.status); + this.drawMessage(image, font, page, weather.status); return image; } if (weather.phase === "error") { - this.drawMessage(image, font, width, height, weather.status, `${GESTURE_CLICK} retry`); + this.drawMessage(image, font, page, weather.status, `${GESTURE_CLICK} retry`); return image; } - this.drawCurrent(image, weather, width); - this.drawForecast(image, weather.forecast, ctx, width, height); + this.drawCurrent(image, weather, page); + this.drawForecast(image, weather.forecast, ctx, page); return image; } @@ -111,31 +151,34 @@ export class WeatherLayer implements Layer { } } - private drawCurrent(image: GrayImage, weather: WeatherState, width: number): void { + private drawCurrent(image: GrayImage, weather: WeatherState, page: PageLayout): void { const current = weather.current; if (!current) return; const large = getDefaultLargeFont(); const medium = getDefaultMediumFont(); const small = getDefaultSmallFont(); const temperature = current.temperatureF === null ? "--°" : formatTemperature(current.temperatureF); - const temperatureY = CURRENT_TOP + 8; - let temperatureX = PAGE_X; + const temperatureY = page.top + TEMPERATURE_OFFSET_Y; + let temperatureX = page.textX; if (current.condition) { const icon = renderWeatherIcon(current.condition, current.isDaytime, CURRENT_ICON_SIZE); - if (icon) image.drawImage(icon, PAGE_X, temperatureY + (((large.lineHeight - icon.height) / 2) | 0)); + if (icon) image.drawImage(icon, page.textX, temperatureY + (((large.lineHeight - icon.height) / 2) | 0)); temperatureX += CURRENT_ICON_SIZE + CURRENT_ICON_GAP; } image.drawText(large, temperatureX, temperatureY, temperature, 245); - const textX = Math.max(CURRENT_TEXT_X, temperatureX + Math.ceil(large.measureText(temperature)) + CURRENT_TEXT_GAP); + const textX = Math.max( + page.textX + CURRENT_TEXT_MIN_OFFSET_X, + temperatureX + Math.ceil(large.measureText(temperature)) + CURRENT_TEXT_GAP, + ); // Description / details / source stack compactly from just below the // header line, so at large font sizes they stay clear of the forecast // table instead of running into it. - let cy = 30; + let cy = page.top + CURRENT_TEXT_OFFSET_Y; image.drawText( medium, textX, cy, - truncateText(medium, current.description || "Current conditions", width - textX - PAGE_X), + truncateText(medium, current.description || "Current conditions", page.textRight - textX), 220, ); cy += medium.lineHeight + 2; @@ -153,29 +196,22 @@ export class WeatherLayer implements Layer { const age = current.timestampMs ? formatAge(Date.now() - current.timestampMs) : ""; const updating = weather.phase === "locating" || weather.phase === "loading" ? " · updating" : ""; image.drawText(small, textX, cy, `${source}${age ? ` ${age}` : ""}${updating}`, 105); - image.drawLine(PAGE_X, FORECAST_HEADER_Y - 7, width - PAGE_X, FORECAST_HEADER_Y - 7, 40); + const ruleY = page.top + FORECAST_RULE_OFFSET_Y; + image.drawLine(page.textX, ruleY, page.textRight - 1, ruleY, 40); } private drawForecast( image: GrayImage, forecast: ForecastPeriod[], ctx: LayerContext, - width: number, - height: number, + page: PageLayout, ): void { const font = getDefaultSmallFont(); + const forecastTop = page.top + FORECAST_OFFSET_Y; if (!forecast.length) { - image.drawText(font, PAGE_X, FORECAST_TOP, "No upcoming forecast periods.", 160); + image.drawText(font, page.textX, forecastTop, "No upcoming forecast periods.", 160); return; } - const rowH = forecastRowHeight(font); - // The last row only needs its text line (not a full row pitch of - // clearance below), which usually fits one more row before the bottom. - // The menu only draws rows whose whole selection box fits, so the box - // holds that many rows, cut at the image's bottom edge. - const visibleRows = Math.max(1, 1 + Math.floor((height - FORECAST_TOP - (font.lineHeight + 4)) / rowH)); - const boxTop = FORECAST_TOP - 2; - const boxHeight = Math.min(visibleRows * rowH - FORECAST_ROW_GAP, height - boxTop); // Columns are sized to the widest period name so names ("Wednesday // Night") never truncate; the summary column absorbs what's left. @@ -183,24 +219,30 @@ export class WeatherLayer implements Layer { font.measureText("Upcoming"), ...forecast.map((period) => font.measureText(period.name)), ); - const tempX = PAGE_X + nameWidth + FORECAST_COL_GAP; + const tempX = page.textX + nameWidth + FORECAST_COL_GAP; const precipX = tempX + Math.max(font.measureText("Temp"), font.measureText(widestTemperatureSample())) + FORECAST_COL_GAP; const summaryX = precipX + Math.max(font.measureText("Rain"), font.measureText("100%")) + FORECAST_COL_GAP; - image.drawText(font, PAGE_X, FORECAST_HEADER_Y, "Upcoming", 150); - image.drawText(font, tempX, FORECAST_HEADER_Y, "Temp", 105); - image.drawText(font, precipX, FORECAST_HEADER_Y, "Rain", 105); + const headerY = page.top + FORECAST_HEADER_OFFSET_Y; + image.drawText(font, page.textX, headerY, "Upcoming", 150); + image.drawText(font, tempX, headerY, "Temp", 105); + image.drawText(font, precipX, headerY, "Rain", 105); this.columns = { - name: PAGE_X - FORECAST_BOX_X, - temp: tempX - FORECAST_BOX_X, - precip: precipX - FORECAST_BOX_X, - summary: summaryX - FORECAST_BOX_X, + name: page.textX - page.boxX, + temp: tempX - page.boxX, + precip: precipX - page.boxX, + summary: summaryX - page.boxX, }; this.forecastMenu.setItems(forecast); + // The rows scroll under the fixed column headings, down to the window's + // bottom edge, where a row cut off for scrolling meets the edge; that + // edge's padding goes inside the list, after its last row. + const boxTop = forecastTop - 2; + if (boxTop >= page.height) return; this.forecastMenu.paint( image, - { x: FORECAST_BOX_X, y: boxTop, width: width - 2 * FORECAST_BOX_X, height: boxHeight }, + { x: page.boxX, y: boxTop, width: page.boxWidth, height: page.height - boxTop, padBottom: page.padBottom }, ctx.stack.isFocused(), ); } @@ -213,7 +255,7 @@ export class WeatherLayer implements Layer { image.drawText(font, x + columns.name, textY, period.name, shade); image.drawText(font, x + columns.temp, textY, period.temperatureF === null ? "--" : formatTemperature(period.temperatureF), shade); image.drawText(font, x + columns.precip, textY, period.precipitationPercent === null ? "--" : `${Math.round(period.precipitationPercent)}%`, selected ? 220 : 155); - // The summary stops PAGE_X short of the viewport's right edge, as the name starts PAGE_X in from the left. + // The summary stops as far short of the selection box's right edge as the name starts in from its left. const summaryWidth = width - columns.summary - columns.name; image.drawText(font, x + columns.summary, textY, truncateText(font, period.shortForecast, summaryWidth), selected ? 220 : 165); } @@ -221,18 +263,18 @@ export class WeatherLayer implements Layer { private drawMessage( image: GrayImage, font: UiFont, - width: number, - height: number, + page: PageLayout, message: string, footer?: string, ): void { - const lines = wrapText(font, message, width - 2 * (PAGE_X + 6)); - const top = Math.max(52, Math.round((height - lines.length * 15) / 2) - 8); + const lines = wrapText(font, message, page.textRight - page.textX - 2 * MESSAGE_INDENT); + // Centered in the window, but never up into the title line. + const top = Math.max(page.top + MESSAGE_MIN_OFFSET_Y, Math.round((page.height - lines.length * 15) / 2) - 8); for (let index = 0; index < lines.length; index++) { - image.drawText(font, PAGE_X + 6, top + index * 15, lines[index]!, 185); + image.drawText(font, page.textX + MESSAGE_INDENT, top + index * 15, lines[index]!, 185); } if (footer) { - image.drawText(font, PAGE_X, height - 20, footer, 110); + image.drawText(font, page.textX, page.height - page.padBottom - font.lineHeight, footer, 110); } } } diff --git a/app/assistant/window-tools.ts b/app/assistant/window-tools.ts index 44350606..9724550a 100644 --- a/app/assistant/window-tools.ts +++ b/app/assistant/window-tools.ts @@ -5,11 +5,11 @@ * mirrors what the user can do from the launcher grid and the sidebar. * * The launchable set is the built-in launcher apps plus whatever EvenHub - * packages are installed right now, matching the launcher grid. Installs and - * uninstalls change that set at runtime, so the tools re-register (replacing - * themselves by name) whenever it changes to keep the id enums and - * descriptions current; register() fires the tools-changed broadcast that - * propagates the new specs to the assistant backends. + * packages are installed right now, matching the launcher grid. Installs, + * uninstalls and pairing different glasses change that set at runtime, so the + * tools re-register (replacing themselves by name) whenever it changes to keep + * the id enums and descriptions current; register() fires the tools-changed + * broadcast that propagates the new specs to the assistant backends. */ import { shell, type ShellWindow } from "../ui/shell/shell"; import type { AppDefinition } from "../apps/app-definition"; @@ -30,8 +30,8 @@ import { onAnySettingChanged } from "../ui/dashboard-settings"; import { toolRegistry, type ToolRegistry, type ToolResult } from "./tool-registry"; export type WindowToolsOptions = { - /** The built-in launcher apps; installed EvenHub apps are added dynamically. */ - apps: readonly AppDefinition[]; + /** The built-in launcher apps for the paired glasses; installed EvenHub apps are added dynamically. */ + apps: () => readonly AppDefinition[]; /** Launch (or focus) an app exactly as the launcher grid would. */ launchApp: (appId: string) => Promise | void; /** Repaint the shell surface so the sidebar reflects a focus change. */ @@ -47,9 +47,11 @@ export function registerWindowTools( if (registered) return; registered = true; registerTools(options, registry); - let fingerprint = getInstalledEvenHubFingerprint(); + const launchableFingerprint = () => + `${getInstalledEvenHubFingerprint()}\n${options.apps().map((app) => app.appId).join()}`; + let fingerprint = launchableFingerprint(); onAnySettingChanged(() => { - const current = getInstalledEvenHubFingerprint(); + const current = launchableFingerprint(); if (current === fingerprint) return; fingerprint = current; registerTools(options, registry); @@ -58,7 +60,7 @@ export function registerWindowTools( function registerTools(options: WindowToolsOptions, registry: ToolRegistry): void { const installedApps = getInstalledEvenHubApps(); - const apps = new Map(options.apps.map((app) => [app.appId, app.title])); + const apps = new Map(options.apps().map((app) => [app.appId, app.title])); for (const app of installedApps) { apps.set(installedEvenHubAppId(app.packageId), app.name); } diff --git a/app/g1/addresses.ts b/app/g1/addresses.ts new file mode 100644 index 00000000..c966a453 --- /dev/null +++ b/app/g1/addresses.ts @@ -0,0 +1,37 @@ +/** Keeping what's saved about a G1 current as an install changes its arms' addresses. */ +import { + loadDeviceAddresses, + loadPairedGlassesIdentity, + saveDeviceAddresses, + savePairedGlassesIdentity, +} from "../g2/device-addresses"; +import type { EvenAdvertisement } from "../g2/even-advertisement"; +import type { GlassesPairCandidate } from "../g2/pairing-candidates"; +import type { G1Side } from "./flash-plan"; + +export function saveG1Pair(pair: GlassesPairCandidate): void { + const stored = loadDeviceAddresses(); + saveDeviceAddresses({ left: pair.left!.address, right: pair.right!.address, ring: stored.ring }); + const identity = loadPairedGlassesIdentity(); + savePairedGlassesIdentity({ + serial: pair.serial ?? identity?.serial ?? "", + leftName: pair.left!.name, + rightName: pair.right!.name, + leftAddress: pair.left!.address, + rightAddress: pair.right!.address, + ringName: identity?.ringName ?? "", + ringAddress: stored.ring, + pairedAtMs: identity?.pairedAtMs ?? Date.now(), + }); +} + +/** Saved as soon as it's known: if anything stops the install after this, the next try and the session still find this arm. */ +export function saveG1Arm(side: G1Side, arm: EvenAdvertisement): void { + saveDeviceAddresses({ ...loadDeviceAddresses(), [side]: arm.address }); + const identity = loadPairedGlassesIdentity(); + if (identity) { + savePairedGlassesIdentity(side === "left" + ? { ...identity, leftName: arm.name, leftAddress: arm.address } + : { ...identity, rightName: arm.name, rightAddress: arm.address }); + } +} diff --git a/app/g1/arm-scanner.ts b/app/g1/arm-scanner.ts new file mode 100644 index 00000000..22b6782d --- /dev/null +++ b/app/g1/arm-scanner.ts @@ -0,0 +1,86 @@ +/** + * Finding a G1's arms by listening for them. That's how an install knows what each arm runs before connecting to it, + * and how it finds an arm again afterwards, when it advertises what it runs now (and, coming from g1v0 before 0.5.66, at + * a new address). + */ +import { classifyAdvertisement, type EvenAdvertisement } from "../g2/even-advertisement"; +import { DiscoveryAggregator, type GlassesPairCandidate } from "../g2/pairing-candidates"; +import { DeviceDiscoveryBridge } from "../native/device-discovery"; +import { pickG1Pair, sameG1Serial, type G1Side, type G1Wanted } from "./flash-plan"; + +/** A serial should tell which arm is ours, but an arm that is the only one of its side around is good enough after this. */ +const ACCEPT_ANY_SERIAL_AFTER_MS = 45_000; + +export class G1ArmScanner { + private discovery: DeviceDiscoveryBridge | null = null; + private finish: (() => void) | null = null; + + /** Resolves with the wanted pair once both arms have been heard, or null after [timeoutMs]. */ + waitForPair(wanted: G1Wanted, timeoutMs: number): Promise { + const aggregator = new DiscoveryAggregator(); + return this.listen(timeoutMs, (raw, done) => { + if (aggregator.ingest(raw)) { + const pair = pickG1Pair(aggregator.pairs(), wanted); + if (pair) done(pair); + } + }); + } + + /** Resolves when an arm of this side on g1v0 is heard, or null after [timeoutMs]. */ + waitForG1v0Arm(side: G1Side, serial: string | null | undefined, timeoutMs: number): Promise { + return this.waitForArm(side, serial, timeoutMs, (arm) => arm.g1Firmware !== "stock"); + } + + /** Resolves when an arm of this side is heard that [accept] takes, on any firmware, or null after [timeoutMs]. */ + waitForArm( + side: G1Side, + serial: string | null | undefined, + timeoutMs: number, + accept: (arm: EvenAdvertisement) => boolean, + ): Promise { + const startedAt = Date.now(); + const others = new Map(); + return this.listen(timeoutMs, (raw, done) => { + const arm = classifyAdvertisement(raw); + if (!arm || arm.role !== side || !arm.g1Firmware || !accept(arm)) return; + if (!serial || sameG1Serial(arm.serial, serial)) { + done(arm); + return; + } + others.set(arm.address, arm); + if (others.size === 1 && Date.now() - startedAt >= ACCEPT_ANY_SERIAL_AFTER_MS) done(arm); + }); + } + + stop(): void { + this.finish?.(); + } + + private listen(timeoutMs: number, onRaw: (raw: Parameters[0], done: (value: T) => void) => void): Promise { + return new Promise((resolve, reject) => { + this.discovery ??= new DeviceDiscoveryBridge(); + const discovery = this.discovery; + if (!discovery.bluetoothEnabled) { + reject(new Error("Bluetooth is off. Turn it on, then try again.")); + return; + } + let settled = false; + const settle = (value: T | null, error?: Error) => { + if (settled) return; + settled = true; + clearTimeout(timer); + this.finish = null; + discovery.stopScan(); + if (error) reject(error); + else resolve(value); + }; + const timer = setTimeout(() => settle(null), timeoutMs); + this.finish = () => settle(null); + const started = discovery.startScan({ + onAdvertisement: (raw) => onRaw(raw, (value) => settle(value)), + onScanFailed: (_code, message) => settle(null, new Error(`The Bluetooth scan failed: ${message}`)), + }); + if (!started) settle(null, new Error("Could not start the Bluetooth scan. Check that Bluetooth is on.")); + }); + } +} diff --git a/app/g1/even-firmware.ts b/app/g1/even-firmware.ts new file mode 100644 index 00000000..459c8ead --- /dev/null +++ b/app/g1/even-firmware.ts @@ -0,0 +1,21 @@ +/** + * Even's official G1 firmware, which an uninstall puts back: both images of one public release, the application core's + * and the network core's (the Bluetooth controller), as Even's own update installs them, so the two always match. + * From Even's CDN, checked against these SHA-256 sums (scouter_kit g1_firmware/stock_images.txt). Every public image + * says 0.0.0 in its MCUboot header, so the hashes are the only way to tell releases apart. + */ +export type EvenG1Release = { + version: string; + zipUrl: string; + zipSha256: string; + appSha256: string; + netCoreSha256: string; +}; + +export const EVEN_G1_RESTORE: EvenG1Release = { + version: "1.6.6", + zipUrl: "https://cdn.evenreal.co/firmware/dcfa510c090e476c10a6f6c348a22415.zip", + zipSha256: "748836f2d9d092b0783cbb7672fdccec4f730051cad27f095bbb156ac3e5d316", + appSha256: "ae032838e27037156da98e19de90df78f5406715751f3b38adf50498db3010c1", + netCoreSha256: "c277749be97a2763742db399afeb10ca6916059abd60d41bbc05c8892c002c77", +}; diff --git a/app/g1/firmware-builder.ts b/app/g1/firmware-builder.ts new file mode 100644 index 00000000..4134443c --- /dev/null +++ b/app/g1/firmware-builder.ts @@ -0,0 +1,73 @@ +/** + * Prepares the g1v0 image on the phone, as app/g2/firmware-builder.ts does for a G2: downloads Even's public firmware, + * checks it, and puts the parts this firmware embeds back into what the app ships. The result is byte for byte the + * image that was built, tested and signed, and it is checked to be. Also prepares Even's own images for an uninstall. + * It does not touch the glasses. + */ +import { knownFolders } from "@nativescript/core"; + +import { firmwareSha256, writeFirmwareFile } from "../native/firmware-files"; +import { decodeBase64 } from "../util/base64"; +import { fetchWithUserAgent } from "../util/http"; +import { EVEN_G1_RESTORE } from "./even-firmware"; +import { G1V0_IMAGE } from "./firmware/g1v0-image"; +import { G1V0_OWN_BYTES_BASE64 } from "./firmware/g1v0-own-bytes"; +import { assembleG1Image, decodeG1OwnBytes, extractEvenG1Images, G1FirmwareError, readZipEntry } from "./firmware-image"; + +export type G1BuildProgress = "downloading" | "verifying" | "assembling" | "writing"; + +export type BuiltG1Firmware = { path: string; bytes: number; version: string }; + +/** Even's release for an uninstall: the application core's image and the network core's. */ +export type BuiltEvenG1Firmware = { appPath: string; netCorePath: string; bytes: number; version: string }; + +function sha256(bytes: Uint8Array): string { + return firmwareSha256(bytes.slice().buffer); +} + +async function downloadStockZip(url: string): Promise { + let response: Response; + try { + response = await fetchWithUserAgent(url); + } catch (error) { + throw new G1FirmwareError(`Could not reach Even's firmware server: ${(error as Error)?.message ?? error}`); + } + if (!response.ok) throw new G1FirmwareError(`The firmware download failed (HTTP ${response.status}).`); + return new Uint8Array(await response.arrayBuffer()); +} + +export async function buildG1Firmware(onProgress?: (progress: G1BuildProgress) => void): Promise { + onProgress?.("downloading"); + const zip = await downloadStockZip(G1V0_IMAGE.stockZipUrl); + + onProgress?.("verifying"); + const zipHash = sha256(zip); + if (zipHash !== G1V0_IMAGE.stockZipSha256) { + throw new G1FirmwareError(`Even's firmware download failed verification.\nexpected ${G1V0_IMAGE.stockZipSha256}\ngot ${zipHash}`); + } + + onProgress?.("assembling"); + const own = decodeG1OwnBytes(G1V0_OWN_BYTES_BASE64, decodeBase64); + const image = assembleG1Image(G1V0_IMAGE, own, (name) => readZipEntry(zip, name), sha256); + + onProgress?.("writing"); + const path = `${knownFolders.documents().path}/g1v0_${G1V0_IMAGE.version}.bin`; + writeFirmwareFile(path, image.slice().buffer); + return { path, bytes: image.length, version: G1V0_IMAGE.version }; +} + +export async function buildEvenG1Firmware(onProgress?: (progress: G1BuildProgress) => void): Promise { + onProgress?.("downloading"); + const zip = await downloadStockZip(EVEN_G1_RESTORE.zipUrl); + + onProgress?.("verifying"); + const { app, netCore } = extractEvenG1Images(zip, EVEN_G1_RESTORE, sha256); + + onProgress?.("writing"); + const folder = knownFolders.documents().path; + const appPath = `${folder}/even_g1_${EVEN_G1_RESTORE.version}_app.bin`; + const netCorePath = `${folder}/even_g1_${EVEN_G1_RESTORE.version}_net.bin`; + writeFirmwareFile(appPath, app.slice().buffer); + writeFirmwareFile(netCorePath, netCore.slice().buffer); + return { appPath, netCorePath, bytes: app.length + netCore.length, version: EVEN_G1_RESTORE.version }; +} diff --git a/app/g1/firmware-image.ts b/app/g1/firmware-image.ts new file mode 100644 index 00000000..69350bb6 --- /dev/null +++ b/app/g1/firmware-image.ts @@ -0,0 +1,107 @@ +/** + * Rebuilding the g1v0 image from what the app ships and Even's public firmware download. No I/O, so tests can run it + * on real or made-up files. tools/g1_firmware_bundle.py is the other half. + */ +import { inflate, inflateRaw } from "pako"; + +import type { EvenG1Release } from "./even-firmware"; +import type { G1FirmwareImage } from "./firmware/g1v0-image"; + +export class G1FirmwareError extends Error {} + +/** One file from a zip; throws when it's absent or in a form a firmware zip doesn't use. */ +export function readZipEntry(zip: Uint8Array, name: string): Uint8Array { + const view = new DataView(zip.buffer, zip.byteOffset, zip.byteLength); + const END_OF_DIRECTORY = 0x06054b50; + const DIRECTORY_ENTRY = 0x02014b50; + const LOCAL_HEADER = 0x04034b50; + let end = zip.length - 22; + while (end >= 0 && view.getUint32(end, true) !== END_OF_DIRECTORY) end--; + if (end < 0) throw new G1FirmwareError("The firmware download is not a zip file."); + const count = view.getUint16(end + 10, true); + let at = view.getUint32(end + 16, true); + for (let i = 0; i < count; i++) { + if (at + 46 > zip.length || view.getUint32(at, true) !== DIRECTORY_ENTRY) break; + const method = view.getUint16(at + 10, true); + const packedSize = view.getUint32(at + 20, true); + const nameLength = view.getUint16(at + 28, true); + const extraLength = view.getUint16(at + 30, true); + const commentLength = view.getUint16(at + 32, true); + const headerAt = view.getUint32(at + 42, true); + const entryName = String.fromCharCode(...zip.subarray(at + 46, at + 46 + nameLength)); + if (entryName === name || entryName.endsWith(`/${name}`)) { + if (view.getUint32(headerAt, true) !== LOCAL_HEADER) throw new G1FirmwareError(`Bad zip entry for ${name}.`); + const dataAt = headerAt + 30 + view.getUint16(headerAt + 26, true) + view.getUint16(headerAt + 28, true); + const packed = zip.subarray(dataAt, dataAt + packedSize); + if (method === 0) return packed.slice(); + if (method === 8) return inflateRaw(packed); + throw new G1FirmwareError(`${name} uses zip method ${method}.`); + } + at += 46 + nameLength + extraLength + commentLength; + } + throw new G1FirmwareError(`The firmware download has no ${name}.`); +} + +/** + * The two images of Even's release from its download, each checked by its own SHA-256 as well as the zip's, so what + * goes to the arms is byte for byte what Even published. + */ +export function extractEvenG1Images( + zip: Uint8Array, + release: EvenG1Release, + sha256: (bytes: Uint8Array) => string, +): { app: Uint8Array; netCore: Uint8Array } { + const zipHash = sha256(zip); + if (zipHash !== release.zipSha256) { + throw new G1FirmwareError(`Even's firmware download failed verification.\nexpected ${release.zipSha256}\ngot ${zipHash}`); + } + const checked = (name: string, want: string) => { + const bytes = readZipEntry(zip, name); + const got = sha256(bytes); + if (got !== want) throw new G1FirmwareError(`${name} in Even's download failed verification.\nexpected ${want}\ngot ${got}`); + return bytes; + }; + return { + app: checked("app_update.bin", release.appSha256), + netCore: checked("net_core_app_update.bin", release.netCoreSha256), + }; +} + +export function decodeG1OwnBytes(base64: string, decode: (text: string) => Uint8Array): Uint8Array { + return inflate(decode(base64)); +} + +/** + * The finished image. [fileBytes] gives one of Even's unpacked files by name, [sha256] a lowercase hex digest. Each part + * and the result are checked, so a success is byte for byte the image that was built and signed. + */ +export function assembleG1Image( + manifest: G1FirmwareImage, + own: Uint8Array, + fileBytes: (name: string) => Uint8Array, + sha256: (bytes: Uint8Array) => string, +): Uint8Array { + const image = new Uint8Array(manifest.size); + let position = 0; + let ownAt = 0; + for (const part of [...manifest.parts].sort((a, b) => a.offset - b.offset)) { + const before = part.offset - position; + image.set(own.subarray(ownAt, ownAt + before), position); + ownAt += before; + const bytes = fileBytes(part.file).subarray(part.fileOffset, part.fileOffset + part.length); + if (bytes.length !== part.length || sha256(bytes) !== part.sha256) { + throw new G1FirmwareError(`${part.file} in Even's download is not the one this firmware was built with.`); + } + image.set(bytes, part.offset); + position = part.offset + part.length; + } + image.set(own.subarray(ownAt), position); + if (ownAt + (manifest.size - position) !== own.length) { + throw new G1FirmwareError("The firmware bundled with this app is damaged."); + } + const digest = sha256(image); + if (digest !== manifest.sha256) { + throw new G1FirmwareError(`The assembled firmware failed verification.\nexpected ${manifest.sha256}\ngot ${digest}`); + } + return image; +} diff --git a/app/g1/firmware/g1v0-image.ts b/app/g1/firmware/g1v0-image.ts new file mode 100644 index 00000000..07b3a1fd --- /dev/null +++ b/app/g1/firmware/g1v0-image.ts @@ -0,0 +1,41 @@ +// AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. +// What the app installs on a G1, and the parts of it that come from Even's own download. + +export type G1FirmwarePart = { offset: number; length: number; file: string; fileOffset: number; sha256: string }; + +export type G1FirmwareImage = { + version: string; + sha256: string; + size: number; + source: string; + stockVersion: string; + stockZipUrl: string; + stockZipSha256: string; + parts: G1FirmwarePart[]; +}; + +export const G1V0_IMAGE: G1FirmwareImage = { + "version": "0.5.66", + "sha256": "9861a5671ed2fab6a678feae1f22e57d0b41bbb5934d83b898c5108db3a474fd", + "size": 582992, + "source": "ceb74cce6945", + "stockVersion": "1.6.6", + "stockZipUrl": "https://cdn.evenreal.co/firmware/dcfa510c090e476c10a6f6c348a22415.zip", + "stockZipSha256": "748836f2d9d092b0783cbb7672fdccec4f730051cad27f095bbb156ac3e5d316", + "parts": [ + { + "offset": 271264, + "length": 226020, + "file": "net_core_app_update.bin", + "fileOffset": 0, + "sha256": "c277749be97a2763742db399afeb10ca6916059abd60d41bbc05c8892c002c77" + }, + { + "offset": 497312, + "length": 352, + "file": "app_update.bin", + "fileOffset": 531288, + "sha256": "92e73a6dd92da734bc21e8184d94d69e9a49e23056e378670b24334a305a953d" + } + ] +}; diff --git a/app/g1/firmware/g1v0-own-bytes.ts b/app/g1/firmware/g1v0-own-bytes.ts new file mode 100644 index 00000000..66afc7e8 --- /dev/null +++ b/app/g1/firmware/g1v0-own-bytes.ts @@ -0,0 +1,4 @@ +// AUTO-GENERATED by tools/g1_firmware_bundle.py -- do not edit by hand. +// The built g1v0 image without Even's parts (g1v0-image.ts), deflated. + +export const G1V0_OWN_BYTES_BASE64 = "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"; diff --git a/app/g1/flash-plan.ts b/app/g1/flash-plan.ts new file mode 100644 index 00000000..e6e61868 --- /dev/null +++ b/app/g1/flash-plan.ts @@ -0,0 +1,120 @@ +/** What installing firmware on a G1 has to decide. No I/O. */ +import type { GlassesPairCandidate } from "../g2/pairing-candidates"; +import { EVEN_G1_RESTORE } from "./even-firmware"; + +export type G1Side = "left" | "right"; + +/** Left first: a right arm on g1v0 next to a left arm on Even's firmware would leave the left eye dark. */ +export const G1_SIDES: readonly G1Side[] = ["left", "right"]; + +/** Going back, right first, for the same reason: halfway, the pair is as halfway through an install. */ +export const G1_UNINSTALL_SIDES: readonly G1Side[] = ["right", "left"]; + +export const G1_CASE_INSTRUCTIONS = + "Put the glasses in their charging case with the lid open, and plug the case in. Stay nearby, and leave Faceclaw open."; + +/** An arm bonds only once it knows it's in the case, and a full case only says so about every 5 minutes. */ +export const G1_CASE_DELAY_HINT = + "A fully charged arm can take up to 5 minutes to notice it's in the case, so this may take a while."; + +export const G1_INSTALL_NOTICE = + "This replaces the firmware on both arms, about two minutes each. Faceclaw can put Even's firmware back later, but as version " + + `${EVEN_G1_RESTORE.version}, which may not be the version you have now. Installing custom firmware is not covered by warranty.`; + +export const G1_UNINSTALL_NOTICE = + `This puts Even's official firmware ${EVEN_G1_RESTORE.version} back on both arms, Bluetooth controller included, a few minutes ` + + "each. It may not be the version they came with. Afterwards they work with Even's app again, and not with Faceclaw until you " + + "install its firmware again."; + +/** What the native flow says when it finishes (G1ArmFlashFlow). */ +export type G1FlashResult = { + flashed?: boolean; + firmware?: "g1v0" | "stock"; + /** A restore erased g1v0's asset store, where Even's fonts and pictures were. */ + wiped?: boolean; + version?: string; + safeMode?: boolean; + inCase?: boolean; + battery?: number | null; +}; + +export function parseG1FlashResult(detail: string): G1FlashResult { + try { + const parsed = JSON.parse(detail); + return parsed && typeof parsed === "object" ? (parsed as G1FlashResult) : {}; + } catch { + return {}; + } +} + +/** Dotted versions, component by component; a missing component counts as 0. */ +export function compareG1Versions(a: string, b: string): number { + const parts = (version: string) => version.split(".").map((part) => parseInt(part, 10) || 0); + const left = parts(a); + const right = parts(b); + for (let i = 0; i < Math.max(left.length, right.length); i++) { + const delta = (left[i] ?? 0) - (right[i] ?? 0); + if (delta !== 0) return delta; + } + return 0; +} + +export type G1Wanted = { serial?: string | null; left?: string; right?: string }; + +const serialOf = (serial: string | null | undefined) => (serial ?? "").trim().toUpperCase(); + +export function sameG1Serial(a: string | null | undefined, b: string | null | undefined): boolean { + return serialOf(a) !== "" && serialOf(a) === serialOf(b); +} + +/** + * The pair being installed on, among those heard, once both arms have been. Its serial decides, as a flash changes an arm's + * address; an address it was saved under also tells. Only with neither known does the only G1 around count: firmware + * must never go to someone else's glasses because the wanted ones weren't heard. + */ +export function pickG1Pair(pairs: readonly GlassesPairCandidate[], wanted: G1Wanted): GlassesPairCandidate | null { + const g1 = pairs.filter((pair) => pair.g1Firmware); + const complete = (pair: GlassesPairCandidate | undefined) => (pair?.left && pair.right ? pair : null); + const bySerial = g1.find((pair) => sameG1Serial(pair.serial, wanted.serial)); + if (bySerial) return complete(bySerial); + const byAddress = g1.find((pair) => + (!!wanted.left && pair.left?.address === wanted.left) || (!!wanted.right && pair.right?.address === wanted.right)); + if (byAddress) return complete(byAddress); + if (serialOf(wanted.serial) || wanted.left || wanted.right) return null; + return g1.length === 1 ? complete(g1[0]) : null; +} + +/** + * What a check of the two arms found: "stock", Even's firmware on an arm; "safe-mode", g1v0 restarted repeatedly and only + * updates work; "older", older than the app ships; "current", nothing to do. + */ +export type G1FirmwareState = "stock" | "safe-mode" | "older" | "current"; + +export function g1FirmwareState(arms: readonly G1FlashResult[], shipped: string): G1FirmwareState { + if (arms.some((arm) => arm.firmware === "stock")) return "stock"; + if (arms.some((arm) => arm.safeMode)) return "safe-mode"; + return arms.some((arm) => compareG1Versions(arm.version ?? "", shipped) < 0) ? "older" : "current"; +} + +/** + * What the arms' advertising alone says about their firmware, or null when an arm has to be asked: firmware before 0.5.66 + * doesn't advertise its version. + */ +export function g1StateFromAdvertising( + pair: Pick, + shipped: string, +): { state: G1FirmwareState; version: string } | null { + const arms = [pair.left, pair.right]; + if (arms.some((arm) => arm?.g1Firmware === "stock")) return { state: "stock", version: "" }; + if (arms.some((arm) => arm?.g1Firmware === "g1v0-safe")) return { state: "safe-mode", version: "" }; + const versions = arms.map((arm) => arm?.g1Version); + if (!versions[0] || !versions[1]) return null; + const lowest = compareG1Versions(versions[0], versions[1]) <= 0 ? versions[0] : versions[1]; + return { state: compareG1Versions(lowest, shipped) < 0 ? "older" : "current", version: lowest }; +} + +/** Each arm counts for half of the bar, in the order they're done. */ +export function g1FlashPercent(side: G1Side, bytesSent: number, bytesTotal: number, order: readonly G1Side[] = G1_SIDES): number { + const within = bytesTotal > 0 ? Math.min(1, bytesSent / bytesTotal) : 0; + return ((order.indexOf(side) + within) / 2) * 100; +} diff --git a/app/g1/pako.d.ts b/app/g1/pako.d.ts new file mode 100644 index 00000000..8fe2e2a1 --- /dev/null +++ b/app/g1/pako.d.ts @@ -0,0 +1,4 @@ +declare module "pako" { + export function inflate(data: Uint8Array): Uint8Array; + export function inflateRaw(data: Uint8Array): Uint8Array; +} diff --git a/app/g2/ancs-client.ts b/app/g2/ancs-client.ts index 0f11eedf..dc81813d 100644 --- a/app/g2/ancs-client.ts +++ b/app/g2/ancs-client.ts @@ -152,8 +152,10 @@ export class AncsClient { if (flags & 2) { const data = new Uint8Array(this.fragments); this.fragments = []; this.packetKind = -1 if (kind === 0) { - if (data.length !== 1 || data[0] > 2) { this.recover(); return true } + if (data.length !== 1 || data[0] > 3) { this.recover(); return true } if (data[0] === 2) { this.recover('Glasses reported a notification relay error. Retrying…'); return true } + // Only a G1's firmware looks for ANCS itself, so only it can say the phone isn't offering it. + if (data[0] === 3) { this.recover('iPhone is not sharing notifications with the glasses. Enable Share System Notifications in Settings → Bluetooth → right arm. Retrying…'); return true } if (data[0] === 0) { this.resetReceived = true; this.log('Glasses accepted notification relay START; awaiting subscription') } if (data[0] === 1) { if (this.timer !== null) clearTimeout(this.timer) diff --git a/app/g2/ble-proximity.ts b/app/g2/ble-proximity.ts index b3a6809c..e5374c62 100644 --- a/app/g2/ble-proximity.ts +++ b/app/g2/ble-proximity.ts @@ -27,7 +27,7 @@ * * It is **not** a measurement. A hand over the temple, a pocket, or a body * between phone and glasses moves the estimate by metres. The wearer therefore - * only ever sees a coarse zone (glyph + label), never a number in metres they + * only ever sees a coarse zone (a signal-strength glyph), never a number in metres they * might over-trust; the metres value exists purely to rank and bucket. * * This module is pure (no NativeScript imports) so it can run under node tests. @@ -75,19 +75,6 @@ export function zoneFromMeters(meters: number): ProximityZone { return "distant"; } -export function zoneLabel(zone: ProximityZone): string { - switch (zone) { - case "immediate": - return "In your hand"; - case "near": - return "Nearby"; - case "far": - return "Across the room"; - case "distant": - return "Far away"; - } -} - /** A glyph for the zone; SF Symbols have no Android equivalent, so plain text. */ export function zoneGlyph(zone: ProximityZone): string { switch (zone) { diff --git a/app/g2/brightness-curve.ts b/app/g2/brightness-curve.ts index 1695ae8d..4f215640 100644 --- a/app/g2/brightness-curve.ts +++ b/app/g2/brightness-curve.ts @@ -1,5 +1,18 @@ export const DEFAULT_BRIGHTNESS_CURVE = "0:0,0.2:7,1.5:33,5:100"; const PREVIOUS_DEFAULT_CURVE = "0:0,1:10,10:30,100:65,1000:100"; +/** + * The RayNeo iO's sensor reads real lux, far above the G2's behind-the-lens values, so the + * G2's curve would sit at maximum in any lit room. These knots put the default 20–100 range on + * the stock firmware's own scene levels: 29, 41, 41, 53, 65, 76, 94 and 100 percent at 3, 10, + * 200, 300, 600, 1000, 4000 and 5000 lux. + */ +export const RAYNEO_IO_BRIGHTNESS_CURVE = "0:0,3:11,10:26,200:26,300:41,600:56,1000:70,4000:93,5000:100"; + +/** + * An Even G1's OPT3007 also reads lux (centilux on the wire). These knots are the stock firmware's table: levels 0, 10, 25, + * 41 and 42 of 42 at 0, 50, 200, 1000 and 2000 lux (g1_firmware/docs/VM.md §6.7). + */ +export const G1_BRIGHTNESS_CURVE = "0:0,50:24,200:60,1000:98,2000:100"; /** Percent of the configured range; defaults (20–100) give 20/26/46/100. */ export function brightnessCurveError(value: string): string | null { diff --git a/app/g2/dashboard-controller.ts b/app/g2/dashboard-controller.ts index 3c257c87..e2acb67f 100644 --- a/app/g2/dashboard-controller.ts +++ b/app/g2/dashboard-controller.ts @@ -16,7 +16,6 @@ import { mediaControllerBridge } from "../native/media-controller"; import { nightscoutBridge } from "../native/nightscout-bridge"; import { weatherBridge } from "../native/weather"; import { ALL_NOTIFICATIONS, onAndroidNotificationPosted, onAndroidNotificationRemoved, readActiveNotifications } from "../native/notification-icons"; -import { shouldShowNotificationOnGlasses } from "../native/notification-sources"; import { watchNotificationListenerBinding } from "../native/notification-access"; import { openEvenAppSettings, readEvenAppNotificationState } from "../native/even-app-conflict"; import { defaultRingName, setGlassesRingLink } from "../native/ring-status"; @@ -26,6 +25,8 @@ import { GLANCE_TILT_MAX_MS, glanceTiltMaxMs } from "./glance-state"; import { getBooleanSetting, setBooleanSetting } from "../native/settings-store"; import { grayImageToPreviewSource } from "../native/gray-image-preview"; import { firmwareIncompatibilityMessage, hasCompatibleFirmware } from "./firmware-compat"; +import { keyboardService } from "./keyboard/service"; +import type { KeyEvent } from "./keyboard/keys"; import { hasExtractedEvenHubFonts } from "./firmware-builder"; import { isHaltedSessionPhase, resumeAutoReconnect, suppressAutoReconnect } from "./reconnect-policy"; import { WearRemote, type WearRemoteInputKind } from "./wear-remote"; @@ -57,9 +58,9 @@ import { type GlanceEvent } from "./glance-state"; import { isPreviewOnlyMode } from "../phone-ui/onboarding-state"; import { claimGlassesOnboardingAutoLaunch, ONBOARDING_APP_ID } from "../apps/onboarding/onboarding-progress"; import { beginRenderPass, endRenderPass } from "../util/render-freshness"; -import { voiceControlBridge } from "../native/voice-control"; +import { VoiceReplay, voiceControlBridge } from "../native/voice-control"; import { voiceActivity } from "../ui/shell/voice-activity"; -import { G2_LENS_HEIGHT, G2_LENS_WIDTH, GrayImage } from "../graphics/image"; +import { GrayImage } from "../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, type Plane } from "../graphics/plane"; import { prepareFrameDraws } from "../graphics/glyph-wire"; import { createLockScreenImage, LOCK_SCREEN_SURFACE_ID } from "./lock-screen"; @@ -78,10 +79,11 @@ import { ALL_APPS } from "../apps/all-apps"; import { type AppContext, type AppDefinition, type AppLaunchParams, type TextEditorHost } from "../apps/app-definition"; import { type InProcessAppOptions, type InProcessWindow } from "../ui/shell/in-process-window"; import { loadPersistedOpenApps, savePersistedOpenApps } from "../ui/shell/open-apps-persistence"; -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 { appViewportRect, isOnSwitcherEdge, screenHeight, screenWidth, sidebarStripVisible, windowEdges, type ScreenRect, type WindowHeightMode } from "../ui/shell/geometry"; +import { sameEdges } from "../ui/viewport"; +import { type ContinuousCaptureOptions, type LayerActions, type MicCount, 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, 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 { appSwitcherPositionSetting, glassesModelName, glassesTypeSetting, statusBarPositionSetting, statusBarVisibilitySetting, windowBorderSetting, assistantAllowProactiveSetting, assistantBackendSetting, assistantBridgeHostSetting, assistantBridgePortSetting, assistantBridgeTokenSetting, getBrightnessPreferences, displayLayoutSetting, navigateDisplayLayoutSetting, terminalDisplayLayoutSetting, elevenLabsApiKeySetting, getStringSettingById, openAiApiKeySetting, nightscoutApiTokenSetting, firmwareDebugFlagsSetting, whisperServerApiKeySetting, whisperServerLanguageSetting, whisperServerModelSetting, whisperServerUrlSetting, lockScreenEnabledSetting, nightscoutSiteUrlSetting, onAnySettingChanged, previewColorSetting, effectiveRingConnectionMode, type RingConnectionMode, saveRecordingSetting, sonioxApiKeySetting, screenTimeoutSetting, screenTimeoutSettingToMs, shouldPopUpNewNotification, suspendEvenHubWhenScreenOffSetting, voiceProviderSetting, wakeWordActionSetting, type ConfigSettingString } from "../ui/dashboard-settings"; import { isIgnoringBatteryOptimizations, requestIgnoreBatteryOptimizations } from "../native/battery-optimization"; import { getInstalledEvenHubAppById, @@ -101,6 +103,8 @@ import { createNotificationsAppWindow, NOTIFICATIONS_SURFACE_ID, NOTIFICATIONS_W import { isInstalledPackagePresent } from "../apps/evenhub/updates"; import { wearerVerificationOptions } from "../apps/microphones/speakers"; import { micSession } from "../apps/microphones/mic-session"; +import { micArrayCaptureConfig, micControlSupported } from "../apps/microphones/mic-control"; +import { encodeMicControl } from "../apps/microphones/mic-protocol"; import { chargingPreviewMessage, glassesDisplayAsleep, @@ -114,8 +118,6 @@ type ConnectionPhase = "disconnected" | "connecting" | "connected" | "charging" export type DashboardSnapshot = { phase: ConnectionPhase; - /** Last-known battery levels: the glasses, their charging case, the R1 ring and a Wear OS watch. */ - batteries: ReturnType; status: string; displayPreview: ImageSource | null; /** @@ -158,7 +160,7 @@ export type DashboardSnapshot = { previewMode: boolean; /** * The foreground glasses window's EvenHub phone UI, when it can be opened - * (the action bar's app-icon button); null otherwise. + * (the app-icon button under the mirror); null otherwise. */ evenHubPhoneUi: PhoneUiButton | null; }; @@ -198,25 +200,27 @@ const LOW_BATTERY_PERCENT = 5; const EVEN_APP_DETECTED_MESSAGE = "The Even Realities app appears to be running. If Faceclaw has trouble connecting, open its app settings and force stop it."; -// The launcher grid's app list; also fixes the app ids apps.launch accepts. -const LAUNCHABLE_APPS = ALL_APPS.filter((app) => app.showInLauncher !== false); +// The launcher grid's app list for the paired glasses; also fixes the app ids apps.launch accepts. +const launchableApps = () => ALL_APPS.filter((app) => app.showInLauncher !== false && app.isSupported?.() !== false); /** - * The global settings window viewport sizes depend on: the display mode's - * size (a band's position only moves windows), whether the app switcher + * The global settings window viewport sizes depend on: the paired glasses' + * screen, the display mode's size (a band's position only moves windows), whether the app switcher * takes width beside windows, height below them or neither (a popup), and * the chrome rows each window loses to it: below them, whether the status - * bar joins the row (dropping the top bar); with a popup, whether the - * status bar keeps rows of its own and the window frame (where the status - * bar goes only moves windows). + * bar joins the row (dropping the top bar, for the window frame's top row + * if it has a frame); with a popup, whether the status bar keeps rows of its + * own and the window frame (where the status bar goes only moves windows). */ function viewportSizesKey(): string { const position = appSwitcherPositionSetting.get(); - const switcher = position === "bottom" ? `row|${statusBarPositionSetting.get()}` - : position === "popup" ? `popup|${statusBarVisibilitySetting.get()}|${windowBorderSetting.get()}` + const statusBar = statusBarPositionSetting.get(); + const framed = windowBorderSetting.get() === "all"; + const switcher = position === "bottom" ? `row|${statusBar}|${statusBar === "bottom" && framed}` + : position === "popup" ? `popup|${statusBarVisibilitySetting.get()}|${framed}` : "strip"; const layout = displayLayoutSetting.get(); - return `${layout.startsWith("band-") ? "band" : layout}|${switcher}`; + return `${screenWidth()}x${screenHeight()}|${layout.startsWith("band-") ? "band" : layout}|${switcher}`; } /** The global settings that move window surfaces without resizing them. */ @@ -225,7 +229,7 @@ function windowPlacementKey(): string { } function createInitialDisplayPreview(): ImageSource | null { - return grayImageToPreviewSource(new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0)); + return grayImageToPreviewSource(new GrayImage(screenWidth(), screenHeight(), 0)); } /** Echo the controller's appendLog() trace to the console. */ @@ -414,6 +418,7 @@ class DashboardController { startContinuousVoiceCapture: (client: string, options?: ContinuousCaptureOptions) => this.startContinuousVoiceCapture(client, options), stopContinuousVoiceCapture: (client: string) => this.stopContinuousVoiceCapture(client), + openVoiceReplay: (path: string) => this.openVoiceReplay(path), playBuzzerSequence: (payload: Uint8Array) => this.playBuzzerSequence(payload), }; this.sharedActions = sharedActions; @@ -426,11 +431,11 @@ class DashboardController { registerRoamTools((appId) => this.launchApp(appId)); // apps.* tools mirror the launcher grid and sidebar (launch, focus, close). registerWindowTools({ - apps: LAUNCHABLE_APPS, + apps: launchableApps, launchApp: (appId) => this.launchApp(appId), requestShellRender: () => this.requestShellRender(), }); - // The action bar's EvenHub phone-UI button hides while that UI is showing. + // The main page's EvenHub phone-UI button hides while that UI is showing. onPhoneShownChanged(() => this.emit()); shell.configure({ actions: { @@ -453,13 +458,15 @@ class DashboardController { this.emit(); }, openNotificationsWindow: () => - this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow), + this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, + (options) => createNotificationsAppWindow(options, (section) => this.openSettings(section))), onSwitcherBarHeightChanged: () => this.applySwitcherBarHeight(), onScreenStateChanged: (on) => { // Any wake of the regular UI replaces a showing Glanceboard. if (on) this.glance.dismiss(); this.handleScreenStateChanged(on); if (on) this.requestShellRender(); + if (on) keyboardService.retryNow(); this.emit(); }, }); @@ -481,14 +488,18 @@ class DashboardController { this.pushFirmwareDebugFlags(); this.pushBrightness(); this.syncEvenHubScreenOffSetting(); + this.syncVoiceWake(); // Display mode size first: a reflow repositions every surface too, so // the band-position check after it then has nothing left to do. - this.applyDisplayModeIfChanged(); + const resized = this.applyDisplayModeIfChanged(); this.applyVerticalPositionIfChanged(); - this.applyAppLayoutsIfChanged(); + const appsResized = this.applyAppLayoutsIfChanged(); + // Either reflow hands windows their new edges along with their size. + if (!resized && !appsResized) this.applyWindowEdgesIfChanged(); this.syncAssistantBridgeIfChanged(); this.syncLockScreenSettingIfChanged(); this.applyGlanceAngleIfChanged(); + this.syncContinuousRecording(); // 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 // the Java side). @@ -509,8 +520,31 @@ class DashboardController { assistantAvailable: () => shell.isAssistantAvailable(), assistant: text => shell.sendToAssistant(text), }); + // A keyboard paired through the glasses (CFW keyboard bridge). The + // service decides what each key means (app/g2/keyboard/key-router.ts); + // this is how it reaches the display and the input pipeline. + keyboardService.setHost({ + ready: () => this.phase === "connected", + locked: () => this.glassesLocked, + wake: () => { + void this.handleInputEvent({ + kind: "display-wake", + containerName: "", + eventType: OsEventTypeList.DOUBLE_CLICK_EVENT, + eventSource: EventSourceType.TOUCH_EVENT_FORM_DUMMY_NULL, + systemExitReasonCode: 0, + frameId: 0, + }).catch((error) => this.appendLog(`keyboard wake failed: ${this.formatError(error)}`)); + }, + gesture: (gesture, origin) => this.injectSyntheticRingInput(gesture, origin), + log: (line) => this.appendLog(line), + // A keyboard that is switched off would otherwise keep the glasses' + // radio looking for it around the clock. One still connected when the + // display sleeps stays connected, and its next key wakes the display. + shouldReconnect: () => this.phase === "connected" && shell.isScreenOn(), + }); this.wearRemote = new WearRemote({ - apps: LAUNCHABLE_APPS, + apps: launchableApps, injectInput: (kind) => this.injectSyntheticRingInput(kind, "watch"), launchApp: (appId) => this.launchApp(appId), connect: () => this.connect(), @@ -580,9 +614,9 @@ class DashboardController { * that support resizing receive the new viewport. Other worker windows are * closed and launched again at the new size. */ - private applyDisplayModeIfChanged(): void { + private applyDisplayModeIfChanged(): boolean { const sizes = viewportSizesKey(); - if (sizes === this.lastViewportSizes) return; + if (sizes === this.lastViewportSizes) return false; this.lastViewportSizes = sizes; // The reflow below reconfigures every surface, covering any move too. this.lastWindowPlacement = windowPlacementKey(); @@ -614,6 +648,22 @@ class DashboardController { })().catch((error) => { this.appendLog(`display mode change failed: ${this.formatError(error)}`); }); + return true; + } + + /** + * A setting changed what some windows' edges touch (geometry.ts + * windowEdges: a border line, or blank space) without resizing them, as + * the Border setting does under a top status bar: those windows lay out + * again with the padding their new edges suggest. Their surfaces stay as + * they are. + */ + private applyWindowEdgesIfChanged(): void { + for (const window of Array.from(shell.getWindows())) { + const laidOut = window.layoutSize?.(); + if (!laidOut || !window.relayout || sameEdges(laidOut.edges, windowEdges(window.appId))) continue; + window.relayout(); + } } /** @@ -623,14 +673,28 @@ class DashboardController { * are. Windows that can't resize keep the surface they have, the switcher * covering any of it that it now overlaps, rather than being relaunched * for it. + * + * A window is judged by its own size as well as its surface's rect: other + * paths (connect, a launch) configure surfaces from the geometry without + * resizing windows, so a window laid out before the row's height was known + * (restored at startup, at the default height) can sit behind a surface + * that already matches, and its frames would not fit it. */ private applySwitcherBarHeight(): void { void (async () => { for (const window of Array.from(shell.getWindows())) { - const rect = JSON.stringify(appViewportRect(window.heightMode, window.appId)); - if (!window.relayout || this.windowSurfaceRects.get(window.surfaceId) === rect) continue; - window.relayout(); - await this.configureWindowSurface(window.surfaceId, this.isForegroundWindow(window.windowId), window.heightMode); + if (!window.relayout) continue; + const rect = appViewportRect(window.heightMode, window.appId); + const size = window.layoutSize?.(); + const resized = !!size && (size.width !== rect.width || size.height !== rect.height); + if (!resized && this.windowSurfaceRects.get(window.surfaceId) === JSON.stringify(rect)) continue; + try { + window.relayout(); + await this.configureWindowSurface(window.surfaceId, this.isForegroundWindow(window.windowId), window.heightMode); + } catch (error) { + // The rest still need to follow the row. + this.appendLog(`switcher height change failed for ${window.windowId}: ${this.formatError(error)}`); + } } shell.foregroundWindow()?.requestRender(); this.requestShellRender(); @@ -648,10 +712,10 @@ class DashboardController { }; } - private applyAppLayoutsIfChanged(): void { + private applyAppLayoutsIfChanged(): boolean { const layouts = this.appLayouts(); const changed = Object.keys(layouts).filter((appId) => layouts[appId] !== this.lastAppLayouts[appId]); - if (!changed.length) return; + if (!changed.length) return false; this.lastAppLayouts = layouts; void (async () => { for (const window of Array.from(shell.getWindows())) { @@ -662,6 +726,7 @@ class DashboardController { shell.foregroundWindow()?.requestRender(); this.requestShellRender(); })().catch((error) => this.appendLog(`app layout change failed: ${this.formatError(error)}`)); + return true; } private applyVerticalPositionIfChanged(): void { @@ -821,8 +886,8 @@ class DashboardController { await communicator.configureSurface(LOCK_SCREEN_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: 1000, transparency: "opaque", }); @@ -930,6 +995,24 @@ class DashboardController { return applied; } + /** What the communicator was last told about the glasses' own wake word (null: not yet). */ + private voiceWakeSent: boolean | null = null; + + /** + * The glasses' own wake word follows the wake action: on a RayNeo iO, its + * "Hey RayNeo" switch (G2 glasses use the wake lease, syncFaceclawWakeLease). + */ + private syncVoiceWake(communicator = this.communicator): void { + if (!communicator) return; + const enabled = wakeWordActionSetting.get() !== "off"; + if (this.voiceWakeSent === enabled) return; + this.voiceWakeSent = enabled; + void communicator.setVoiceWakeEnabled(enabled).catch((error) => { + this.voiceWakeSent = null; + this.appendLog(`wake word sync failed: ${this.formatError(error)}`); + }); + } + private syncEvenHubScreenOffSetting(): void { void this.syncFaceclawWakeLease().catch((error) => { this.appendLog(`wake takeover lease sync failed: ${this.formatError(error)}`); @@ -1047,9 +1130,11 @@ class DashboardController { /** * A Direct-mode session may have unpaired the R1 from the glasses (see - * GlassesSessionRing.releaseRingFromGlassesLocked). The first session in - * another mode asks the glasses to connect to it again; the ring's own - * glasses targets were cleared, so it accepts them. Called on connect. + * GlassesSessionRing.releaseRingFromGlassesLocked), and a RayNeo iO + * session (always Direct) may have cleared the ring's glasses targets. + * The first G2 session in another mode asks the glasses to connect to it + * again; the ring's own glasses targets were cleared, so it accepts them. + * Called on connect. */ private handRingBackToGlassesIfNeeded(): void { if (this.ringModeAtConnect === "direct" || !getBooleanSetting(RING_TAKEN_FROM_GLASSES_KEY, false)) return; @@ -1170,11 +1255,10 @@ class DashboardController { alarmReliabilityMessage: this.alarmReliabilityMessage, previewMode: this.isPreviewDisplayActive(), evenHubPhoneUi: phoneUiButton(), - batteries: shell.getBatteryLevels(), }; } - /** Overlay an EvenHub app's phone UI (the action bar's app-icon button). */ + /** Overlay an EvenHub app's phone UI (the app-icon button under the mirror). */ showEvenHubPhoneUi(windowId: string): void { showEvenHubPhoneUi(windowId); } @@ -1237,6 +1321,7 @@ class DashboardController { silentMode: this.silentMode, screenOn: shell.isScreenOn(), battery: this.lastHeadsetBattery, + glassesModel: glassesModelName(), caseBattery: batteries.case, caseCharging: batteries.caseCharging, foregroundTitle: shell.getForegroundApp()?.title ?? null, @@ -1409,12 +1494,12 @@ class DashboardController { // is in place before any real render can reach the compositor. this.previewTarget = target; try { - await target.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); + await target.configureCompositorScreen(screenWidth(), screenHeight()); await target.configureSurface(SHELL_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: SHELL_SURFACE_Z_ORDER, transparency: "color-key", }); @@ -1497,17 +1582,21 @@ class DashboardController { this.refreshEvenAppStatus(); this.setPhase("connecting"); this.setStatus("Connecting to the glasses..."); - // "Only via glasses" (the default) means the phone never opens its own - // link to the ring: the glasses relay its gestures to us anyway. An empty - // address disables every direct-ring code path in the communicator. - const ringMode = ringConnectionModeSetting.get(); + // "Only via glasses" (the G2's default) means the phone never opens its + // own link to the ring: the glasses relay its gestures to us anyway. An + // empty address disables every direct-ring code path in the communicator. + // A RayNeo iO (one link, its address in both arm slots) can't relay a + // ring, so with one the phone always takes the ring directly. + const ringMode = effectiveRingConnectionMode(); this.ringModeAtConnect = ringMode; + const glassesType = glassesTypeSetting.get(); const ringAddress = ringMode !== "glasses" ? addresses.ring : ""; // Direct mode may unpair the ring from the glasses; remember to hand it // back once a later session runs in another mode. if (ringMode === "direct" && ringAddress) setBooleanSetting(RING_TAKEN_FROM_GLASSES_KEY, true); - this.appendLog( - `Using configured arms: R=${addresses.right} L=${addresses.left}${ringAddress ? ` ring=${ringAddress}` : ""}`, + this.appendLog((glassesType === "rayneo-io" + ? `Using configured RayNeo iO: ${addresses.right}` + : `Using configured arms: R=${addresses.right} L=${addresses.left}`) + (ringAddress ? ` ring=${ringAddress}` : ""), ); let communicator: FaceclawCommunicatorBridge | null = null; @@ -1529,6 +1618,7 @@ class DashboardController { // sync needs the phone role, which the session borrows briefly for // each pull (GlassesSessionRing.beginRingHealthWindowLocked). ringRole: ringMode === "direct" ? "glasses" : "phone", + glassesType, }); this.communicator = communicator; // Size the compositor before anything else is awaited: windows opened @@ -1536,8 +1626,11 @@ class DashboardController { // configure their surfaces through this.communicator, and the Java call // queue is FIFO, so enqueuing the screen size first guarantees it lands // ahead of them. Mirrors ensurePreviewDisplay. - await communicator.configureCompositorScreen(G2_LENS_WIDTH, G2_LENS_HEIGHT); + // The paired glasses' screen: the G2's 640x480 or the RayNeo iO's 540x220. + await communicator.configureCompositorScreen(screenWidth(), screenHeight()); await communicator.configureBrightness(getBrightnessPreferences()); + this.voiceWakeSent = null; + this.syncVoiceWake(communicator); this.offState = communicator.onStateChange((state) => { if (state.phase !== "connected") resetRingInputFilter(); if (isHaltedSessionPhase(state.phase)) { @@ -1706,6 +1799,7 @@ class DashboardController { this.appendLog(`wake takeover lease sync failed: ${this.formatError(error)}`); }); this.ensureWearStateTracking(); + this.syncKeyboardLink(); } // The shared session halts on incompatible firmware by itself // ("incompatible-firmware" phase); this only explains why. @@ -1731,8 +1825,8 @@ class DashboardController { await communicator.configureSurface(SHELL_SURFACE_ID, { x: 0, y: 0, - width: G2_LENS_WIDTH, - height: G2_LENS_HEIGHT, + width: screenWidth(), + height: screenHeight(), zOrder: SHELL_SURFACE_Z_ORDER, transparency: "color-key", }); @@ -2040,8 +2134,8 @@ class DashboardController { return; } const at = mirrorToPanelFraction(this.displayPreviewCrop, nx, ny); - const x = Math.round(Math.min(1, Math.max(0, at.nx)) * G2_LENS_WIDTH); - const y = Math.round(Math.min(1, Math.max(0, at.ny)) * G2_LENS_HEIGHT); + const x = Math.round(Math.min(1, Math.max(0, at.nx)) * screenWidth()); + const y = Math.round(Math.min(1, Math.max(0, at.ny)) * screenHeight()); const foreground = shell.foregroundWindow(); const stripShown = sidebarStripVisible(shell.getFocus(), foreground?.appId); this.appendLog(`mirror tap at ${x},${y}`); @@ -2139,12 +2233,14 @@ class DashboardController { private startContinuousVoiceCapture(client: string, options: ContinuousCaptureOptions = {}): void { this.continuousClients.set(client, options); + this.syncContinuousRecording(); this.retargetContinuousCapture(); this.ensureContinuousCapture(true); } private stopContinuousVoiceCapture(client: string): void { if (!this.continuousClients.delete(client)) return; + this.syncContinuousRecording(); if (this.continuousClients.size > 0) { // The window that needed its own provider may be the one that left. this.retargetContinuousCapture(); @@ -2170,6 +2266,18 @@ class DashboardController { void this.beginVoiceCapture("continuous").finally(() => this.syncContinuousClaim()); } + /** + * Record to the first client's requested name while Save Recording is on + * (it is toggled from those windows' menus, so this also runs when a + * setting changes). + */ + private syncContinuousRecording(): void { + const name = saveRecordingSetting.get() + ? Array.from(this.continuousClients.values(), (options) => options.recordAs).find(Boolean) ?? "" + : ""; + voiceControlBridge.recordTo(name); + } + /** Move a running continuous capture onto the provider its windows now call for. */ private retargetContinuousCapture(): void { voiceControlBridge.retargetContinuousCapture(this.voiceCaptureOptions(this.communicator)); @@ -2183,6 +2291,30 @@ class DashboardController { return undefined; } + /** + * How many of the glasses' microphones the continuous-capture windows call + * for (the most any asks for), where the glasses can stream them + * separately: G2 with the microphone channel in use. Otherwise 1, the + * mixed stream. + */ + private continuousMics(): MicCount { + if (glassesTypeSetting.get() !== "g2" || !micControlSupported()) return 1; + let mics: MicCount = 1; + for (const options of this.continuousClients.values()) { + if ((options.mics ?? 1) > mics) mics = options.mics!; + } + return mics; + } + + /** + * A recording as a capture of its own (see VoiceReplay), transcribed with + * the provider and processing settings a microphone capture would get. + * "My voice only" is left out: a recording is of whoever spoke. + */ + private openVoiceReplay(path: string): VoiceReplay { + return new VoiceReplay(path, () => ({ ...this.voiceCaptureOptions(null), speakerVerification: undefined })); + } + /** * Continuous capture's claim on the mic (the Microphones app and EvenHub * mic apps stand down while it is held) follows whether the capture really @@ -2208,9 +2340,26 @@ class DashboardController { // Otherwise only Whisper server is told a language (its own setting). const choice = this.transcriptionChoice(); const provider = choice?.provider ?? voiceProviderSetting.get(); + // Separate microphones only come from connected glasses. + const mics = communicator ? this.continuousMics() : 1; + const micConfig = mics === 1 ? null : micArrayCaptureConfig(mics); return { communicator: communicator?.getNativeCommunicator() ?? null, usePhoneMic: communicator === null, + micArray: micConfig ? { configure: encodeMicControl("configure", micConfig) } : null, + // Stored in a recording of the capture (see Save Recording). + captureInfo: { + glasses: communicator ? glassesModelName() : null, + mics, + micConfig: micConfig && { + source: micConfig.source, + channelMask: micConfig.channelMask, + codec: micConfig.codec, + format: micConfig.format, + sampleRateHz: micConfig.sampleRateHz, + directionDetection: micConfig.beamform, + }, + }, provider, language: choice ? choice.language : provider === "whisper-server" ? whisperServerLanguageSetting.get() : "", elevenLabsApiKey: elevenLabsApiKeySetting.get(), @@ -2219,7 +2368,6 @@ class DashboardController { whisperServerUrl: whisperServerUrlSetting.get(), whisperServerModel: whisperServerModelSetting.get(), whisperServerApiKey: whisperServerApiKeySetting.get(), - saveRecording: saveVoiceRecordingsSetting.get(), // "My voice only" (Microphones app): verify command utterances // against the enrolled wearer voice-print; non-matching speakers' // finals are suppressed by the bridge. @@ -2530,6 +2678,23 @@ class DashboardController { applyGlanceAngle(); } + /** + * Tell the keyboard bridge whether the session can host a keyboard: a G2 + * on firmware with the bridge, connected and in use. While the glasses + * charge in their case the link stays up but nobody is typing, so the + * firmware is told to let the keyboard go. + */ + private syncKeyboardLink(): void { + const up = + this.phase === "connected" && + this.customFirmwareConfirmed && + glassesTypeSetting.get() === "g2"; + // Charging, or a disconnect the user asked for: the link is still up, so + // the DISABLE gets out ahead of everything the teardown sends. + if (up) keyboardService.linkReady(); + else keyboardService.linkLost(this.phase === "charging" || this.phase === "disconnecting"); + } + /** * The Glanceboard event a sleep-time input means, or null when the shell * should see the input as usual. A display-wake carries the head-tilt @@ -2636,11 +2801,7 @@ class DashboardController { setSurfaceVisible: (surfaceId, visible) => this.setWindowSurfaceVisible(surfaceId, visible), removeSurface: (surfaceId) => this.removeWindowSurface(surfaceId), requestShellRender: () => this.requestShellRender(), - openSettings: (section) => { - void this.launchApp("settings", { section }).catch((error) => { - this.appendLog(`settings launch failed: ${this.formatError(error)}`); - }); - }, + openSettings: (section) => this.openSettings(section), startTextSettingEdit: (settingId) => { const setting = getStringSettingById(settingId); if (setting) { @@ -2650,6 +2811,7 @@ class DashboardController { } }, endTextSettingEdit: () => this.endTextSettingEdit(), + unhandledKey: (event) => keyboardService.handleUnhandledKey(event as KeyEvent), }); this.appHosts.set(appId, host); return host; @@ -2683,10 +2845,11 @@ class DashboardController { if (!this.openAppsRestored || this.suppressOpenAppsPersist) return; const open: string[] = []; for (const window of shell.getWindows()) { - if (window.appId === "launcher") continue; + if (window.appId === "launcher" || window.restoresApp === false) continue; if (!open.includes(window.appId)) open.push(window.appId); } - savePersistedOpenApps({ open, foreground: shell.foregroundWindow()?.appId ?? null }); + const foreground = shell.foregroundWindow(); + savePersistedOpenApps({ open, foreground: foreground && foreground.restoresApp !== false ? foreground.appId : null }); } /** @@ -2724,6 +2887,13 @@ class DashboardController { this.requestShellRender(); } + /** Open or focus the Settings app, optionally on a section (by label). */ + private openSettings(section?: string): void { + void this.launchApp("settings", { section }).catch((error) => { + this.appendLog(`settings launch failed: ${this.formatError(error)}`); + }); + } + /** * Launch an app by id: the launcher grid, assistant tools, window-menu * Settings item, and open-apps restore all come through here. Apps with an @@ -2940,7 +3110,7 @@ class DashboardController { // The tray shows the notification at once; its popup waits out a short // delay, so one withdrawn right away (see NotificationPopupDelay) never shows. const notification = readActiveNotifications(ALL_NOTIFICATIONS).find((item) => item.key === notificationKey); - if (notification && shouldShowNotificationOnGlasses(notification.packageName)) { + if (notification && shouldPopUpNewNotification(notification.packageName)) { this.notificationPopups.post(notificationKey, notificationPopupDelayMs(notification)); } this.requestShellRender(); @@ -2962,7 +3132,7 @@ class DashboardController { private popUpAndroidNotification(notificationKey: string): void { try { const notification = readActiveNotifications(ALL_NOTIFICATIONS).find((item) => item.key === notificationKey); - if (!notification || !shouldShowNotificationOnGlasses(notification.packageName)) return; + if (!notification || !shouldPopUpNewNotification(notification.packageName)) return; // New notifications open a shell modal over the app viewport; if the // screen was off, wake for it and go back to sleep when it is closed. // Waking while already on would steal focus, so only wake from sleep. @@ -3007,6 +3177,7 @@ class DashboardController { private setPhase(phase: ConnectionPhase): void { if (this.phase === phase) return; this.phase = phase; + this.syncKeyboardLink(); if (phase !== "connected" && phase !== "charging") { shell.setBatteryLevels({ ring: null, ringCharging: null }); } diff --git a/app/g2/even-advertisement.ts b/app/g2/even-advertisement.ts index 84a9c3c0..341cd286 100644 --- a/app/g2/even-advertisement.ts +++ b/app/g2/even-advertisement.ts @@ -30,7 +30,10 @@ export { bytesToHex, hexToBytes }; /** Even Realities' manufacturer-data company identifier (`"ER"` read little-endian). */ export const EVEN_COMPANY_IDENTIFIER = 0x5245; -export type EvenDeviceRole = "left" | "right" | "ring"; +export type EvenDeviceRole = "left" | "right" | "ring" | "rayneo-io"; + +/** The firmware an Even G1 arm advertises: Even's, or Faceclaw's g1v0 (in safe mode: only updates work). */ +export type G1Firmware = "stock" | "g1v0" | "g1v0-safe"; /** True when the manufacturer data opens with Even's `"ER"` marker. */ export function hasEvenManufacturerSignature(mfg: Uint8Array): boolean { @@ -71,6 +74,61 @@ export function extractG2AdvertisementFlag(mfg: Uint8Array): number | null { return mfg[22]!; } +/** + * ## Even G1 arm + * + * On Even's firmware the name is `Even G1___` and the manufacturer data `[01 right | 02 left]` + + * the ASCII serial, zero-padded (the first two bytes read as a "company id" that differs per arm). On g1v0 the name + * is `G1CFW__` with the same digits and address as stock's, and the scan response holds company 0xFFFF, a + * format byte (2), a flags byte (bit 3: safe mode), the firmware's version in three bytes, and the pair ID in ASCII: + * the frame serial, the same on both arms. Before 0.5.66: `G1v0_L` or `G1v0_R` (`G1v0S_…` in safe mode), format 1, no + * version. + */ +export function g1FromName(name: string | null | undefined): { side: "left" | "right"; firmware: G1Firmware } | null { + if (!name) return null; + const custom = /^G1CFW_([LR])_[0-9A-F]{6}$/i.exec(name.trim()); + if (custom) return { side: custom[1]!.toUpperCase() === "L" ? "left" : "right", firmware: "g1v0" }; + const g1v0 = /^G1V0(S?)_([LR])$/i.exec(name.trim()); + if (g1v0) { + return { + side: g1v0[2]!.toUpperCase() === "L" ? "left" : "right", + firmware: g1v0[1] ? "g1v0-safe" : "g1v0", + }; + } + if (!/^EVEN G1_/i.test(name.trim())) return null; + const side = g2SideFromName(name); + return side ? { side, firmware: "stock" } : null; +} + +/** What g1v0's pair record says beyond the serial; null when there is no record of a format that says it. */ +export function parseG1Record(mfg: Uint8Array): { version: string; safeMode: boolean } | null { + if (mfg.length < 7 || mfg[0] !== 0xff || mfg[1] !== 0xff || mfg[2] !== 2) return null; + return { version: `${mfg[4]}.${mfg[5]}.${mfg[6]}`, safeMode: (mfg[3]! & 8) !== 0 }; +} + +/** The pair's serial from an arm's manufacturer data, on either firmware; null when absent. */ +export function extractG1Serial(mfg: Uint8Array, firmware: G1Firmware): string | null { + const record = mfg.length >= 4 && mfg[0] === 0xff && mfg[1] === 0xff; + const start = firmware === "stock" ? 1 : record && mfg[2] === 2 ? 7 : record && mfg[2] === 1 ? 4 : -1; + if (start < 0 || mfg.length <= start) return null; + let serial = ""; + for (let i = start; i < mfg.length; i++) { + const byte = mfg[i]!; + if (byte === 0) break; + if (byte < 0x20 || byte > 0x7e) return null; + serial += String.fromCharCode(byte); + } + return serial.length ? serial : null; +} + +/** RayNeo iO manufacturer data (company 0x5716, little-endian first): `[07][MAC x6]...`, outside pairing mode. */ +export const RAYNEO_COMPANY_IDENTIFIER = 0x5716; + +export function extractRayNeoMac(mfg: Uint8Array): string | null { + if (mfg.length < 9 || mfg[0] !== 0x16 || mfg[1] !== 0x57 || mfg[2] !== 0x07) return null; + return Array.from(mfg.subarray(3, 9), (byte) => byte.toString(16).padStart(2, "0").toUpperCase()).join(":"); +} + /** * Which side a G2 temple advertisement belongs to, from the local name. * Null when the name carries neither or both markers. @@ -210,6 +268,10 @@ export type EvenAdvertisement = { manufacturerData: string; /** Why an otherwise Even-looking advertisement could not be fully parsed. */ note: string | null; + /** Set on an Even G1 arm (role left or right): its firmware. */ + g1Firmware?: G1Firmware; + /** The version g1v0 advertises (0.5.66+); absent when it doesn't say. */ + g1Version?: string; }; /** @@ -230,8 +292,58 @@ export function classifyAdvertisement(raw: RawAdvertisement): EvenAdvertisement const hasSignature = hasEvenManufacturerSignature(mfg); const looksLikeRing = /^EVEN R1([_ ]|$)/.test(upper); const looksLikeG2 = upper.includes("G2"); + const rayneoMac = extractRayNeoMac(mfg); + const looksLikeRayNeo = upper.startsWith("RAYNEO") || rayneoMac !== null; - if (!looksLikeRing && !looksLikeG2 && !hasSignature) return null; + const g1 = g1FromName(name); + if (g1) { + const serial = extractG1Serial(mfg, g1.firmware); + const record = g1.firmware === "stock" ? null : parseG1Record(mfg); + return { + address: normalizeMacAddress(raw.address), + name, + role: g1.side, + serial, + embeddedMac: null, + embeddedMacMismatch: false, + flag: null, + ringSerialSuffix: null, + rssi: raw.rssi, + txPower: raw.txPower, + connectable: raw.connectable, + bonded: raw.bonded, + source: raw.source, + seenAtMs: raw.seenAtMs, + manufacturerData: raw.manufacturerData ?? "", + note: serial ? null : "no serial in the advertisement (it may still be arriving)", + g1Firmware: record?.safeMode ? "g1v0-safe" : g1.firmware, + ...(record ? { g1Version: record.version } : {}), + }; + } + + if (!looksLikeRing && !looksLikeG2 && !hasSignature && !looksLikeRayNeo) return null; + + if (looksLikeRayNeo && !hasSignature) { + const address = normalizeMacAddress(raw.address); + return { + address, + name, + role: "rayneo-io", + serial: null, + embeddedMac: rayneoMac, + embeddedMacMismatch: !!rayneoMac && rayneoMac !== address, + flag: null, + ringSerialSuffix: null, + rssi: raw.rssi, + txPower: raw.txPower, + connectable: raw.connectable, + bonded: raw.bonded, + source: raw.source, + seenAtMs: raw.seenAtMs, + manufacturerData: raw.manufacturerData ?? "", + note: null, + }; + } const base = { address: normalizeMacAddress(raw.address), diff --git a/app/g2/firmware-compat.ts b/app/g2/firmware-compat.ts index 71ee5c91..869053db 100644 --- a/app/g2/firmware-compat.ts +++ b/app/g2/firmware-compat.ts @@ -26,7 +26,7 @@ export type FirmwareInfo = { }; /** The Faceclaw firmware revision this build of the app needs. */ -export const REQUIRED_FACECLAW_FIRMWARE_VERSION = 38; +export const REQUIRED_FACECLAW_FIRMWARE_VERSION = 39; const FACECLAW_PREFIX = "Faceclaw/"; const LEGACY_PREFIX = "EVENCFW"; @@ -117,6 +117,11 @@ export function firmwareIncompatibilityMessage(info: FirmwareInfo): string | nul const versionsText = `L=${info.leftVersion || "unknown"} R=${info.rightVersion || "unknown"}`; const required = `Faceclaw firmware revision ${REQUIRED_FACECLAW_FIRMWARE_VERSION}`; + // A G1's session names what the arms run instead of a revision (GlassesSessionG1.kt). + if (extension.kind === "none" && reportedVersions.some((version) => /^(g1v0|Even's firmware)/.test(version))) { + return `These G1 glasses run ${versionsText}. This version of Faceclaw needs the firmware it comes with: install it to continue.`; + } + switch (extension.kind) { case "faceclaw": if (extension.version >= REQUIRED_FACECLAW_FIRMWARE_VERSION) return null; diff --git a/app/g2/firmware/cfw-patches.ts b/app/g2/firmware/cfw-patches.ts index 86f17ae6..e8f45b4d 100644 --- a/app/g2/firmware/cfw-patches.ts +++ b/app/g2/firmware/cfw-patches.ts @@ -19,12 +19,42 @@ export type FirmwarePatchSet = { export const CFW_PATCH_SET: FirmwarePatchSet = { "base": "g2_2.3.0.24.bin", "baseSha256": "187ccf2bcc5c17a212106e8a376745511e8289c4232b634a7ea94b9bf25a0979", - "outputSha256": "4aac023f49ec6965186d9106e328a516f20a2915ab400d561f662f984023a432", + "outputSha256": "e43be9d04031d261574f96d45cb1e0edd67bfb39f0213f323ff82d8560ae454d", "patches": [ + { + "offset": 1379947, + "old": "0ef009fa", + "new": "0af3b8fb", + "desc": "DM callback allocation: retain keyboard lifecycle on queue exhaustion" + }, + { + "offset": 1380027, + "old": "0ef0e1f9", + "new": "0af316fb", + "desc": "ATT callback allocation: expose lost keyboard events as relay gaps" + }, + { + "offset": 2649417, + "old": "0a681279", + "new": "d4f167fb", + "desc": "SMP Pairing I/O capability: KeyboardDisplay only for owned keyboard" + }, + { + "offset": 2651811, + "old": "0a681279", + "new": "d3f1bafe", + "desc": "SMP Pairing I/O capability: KeyboardDisplay only for owned keyboard" + }, + { + "offset": 1385975, + "old": "38b584b0", + "new": "08f3d4be", + "desc": "BLE app dispatcher: isolate explicitly enabled keyboard connection" + }, { "offset": 1045797, "old": "38b584b0", - "new": "5cf371bb", + "new": "5df31bb9", "desc": "ring receiver entry: timestamped unfiltered reports under framebuffer lease" }, { @@ -36,49 +66,49 @@ export const CFW_PATCH_SET: FirmwarePatchSet = { { "offset": 1437923, "old": "fef788ff", - "new": "fdf2a2f8", + "new": "fdf24cfe", "desc": "cfw_ancs_event" }, { "offset": 1437951, "old": "fef7e8fb", - "new": "fcf2d0fd", + "new": "fdf27afb", "desc": "cfw_ancs_open" }, { "offset": 1437969, "old": "fef7e7fb", - "new": "fcf2ebfd", + "new": "fdf295fb", "desc": "cfw_ancs_close" }, { "offset": 1388387, "old": "39694d00", - "new": "25597d00", + "new": "79647d00", "desc": "connection-bound ANCS EUS write callback" }, { "offset": 971497, "old": "fff717f8", - "new": "6ef3a1fc", + "new": "6ff34bfa", "desc": "bl faceclaw_input_bridge_received (ring relay and ordered private transport before worker pool)" }, { "offset": 971845, "old": "fef769ff", - "new": "6ef3f3fb", + "new": "6ff39df9", "desc": "bl faceclaw_input_bridge_received (ring relay and ordered private transport before worker pool)" }, { "offset": 979579, "old": "fdf74ef8", - "new": "6cf3d8fc", + "new": "6df382fa", "desc": "bl faceclaw_input_bridge_received (ring relay and ordered private transport before worker pool)" }, { "offset": 1428895, "old": "f8f76cfd", - "new": "fbf250fe", + "new": "fbf2acfa", "desc": "bl cfw_receive_packet (private SID-f0 probe before TPL reassembly)" }, { @@ -102,7 +132,7 @@ export const CFW_PATCH_SET: FirmwarePatchSet = { { "offset": 1058287, "old": "fff754fb", - "new": "59f342fb", + "new": "5af3ecf8", "desc": "bl ble_classify_link (only a <= 11.25 ms / latency-0 link is 'already fast')" }, { @@ -114,145 +144,145 @@ export const CFW_PATCH_SET: FirmwarePatchSet = { { "offset": 1248487, "old": "d4f712fb", - "new": "29f344fd", + "new": "29f396f8", "desc": "bl settings_send_wrapper (append caps field 100)" }, { "offset": 1246183, "old": "f5f7e2f8", - "new": "29f3e8fe", + "new": "29f394fa", "desc": "bl settings_decode_wrapper (Faceclaw lease field 101)" }, { "offset": 975219, "old": "02f083fc", - "new": "6bf34aff", + "new": "6bf3f6fa", "desc": "bl faceclaw_display_start @ 0x467d68 (fail-open wake takeover)" }, { "offset": 975411, "old": "02f023fc", - "new": "6bf3b8ff", + "new": "6bf364fb", "desc": "bl faceclaw_display_start_headup @ 0x467e28 (fail-open wake takeover)" }, { "offset": 975103, "old": "07f085fb", - "new": "6df3a6fc", + "new": "6ef350fa", "desc": "bl headup_gate (idle input gate: tap/long/release -> field-102 events, stock result kept)" }, { "offset": 830549, "old": "19f03efb", - "new": "90f37bfe", + "new": "91f325fc", "desc": "bl gesture_ring_press_mode (ring touch-down 14, head up 12 / down 15; stock dispatch preserved)" }, { "offset": 830795, "old": "1ff071ff", - "new": "90f334fe", + "new": "91f3defb", "desc": "bl gesture_press (owned event 9 before stock menu gate)" }, { "offset": 830887, "old": "1ff043ff", - "new": "90f32efe", + "new": "91f3d8fb", "desc": "bl gesture_short_long (Faceclaw lease gates event 11 vs stock Menu path)" }, { "offset": 831763, "old": "1ff08dfd", - "new": "90f364fc", + "new": "91f30efa", "desc": "bl gesture_release (owned event 10 before stock menu gate)" }, { "offset": 1570209, "old": "7fb50600", - "new": "dbf2d5b8", + "new": "daf227bc", "desc": "even_ai_display_ctrl entry -> conditional Faceclaw lease trampoline" }, { "offset": 1051545, "old": "f6f787f9", - "new": "55f3c9f8", + "new": "54f31dfe", "desc": "bl display_copy_hook @ 0x47a78e (640x480 direct framebuffer)" }, { "offset": 1051861, "old": "f6f7e9f8", - "new": "55f32bf8", + "new": "54f37ffd", "desc": "bl display_copy_hook @ 0x47a8ca (640x480 direct framebuffer)" }, { "offset": 1262237, "old": "d9f7d0fd", - "new": "25f3bffd", + "new": "25f3c3f9", "desc": "bl faceclaw_send_wear_event @ 0x4ade92 (outside onboarding)" }, { "offset": 1262337, "old": "d9f79efd", - "new": "25f38dfd", + "new": "25f391f9", "desc": "bl faceclaw_send_wear_event @ 0x4adef6 (outside onboarding)" }, { "offset": 1309405, "old": "67f02dff", - "new": "19f35bfe", + "new": "19f35ffa", "desc": "bl compass_decode_capture (sample-matched GAF diagnostics)" }, { "offset": 1307865, "old": "fff7c9fb", - "new": "1af3ddf9", + "new": "19f3e1fd", "desc": "bl compass_report_event (stock UI + heading with diagnostics over BLE)" }, { "offset": 1300937, "old": "00210170", - "new": "1bf3bbfe", + "new": "1bf3bffa", "desc": "bl compass_preserve_accuracy (retain magnetic calibration under Faceclaw framebuffer lease)" }, { "offset": 4537963, "old": "", - "new": "b0b581ea00039b0701d0034637e0c2b110f0030315d000f1010ca2f1010e0023cc5c9e45c45403f1010404d0634413f003032346f4d121440319121b102a14d302e00346102a10d3d1f800c0d1f804e0cc688d68103adc609d60c3f804e043f810cb0f2a01f11001eed8042a07d300bf51f8045b043a032a43f8045bf8d8002a08bfb0bd0139013b11f8015f013a03f8015ff9d1b0bd00bf884218bf002a00d1704710b50b1a38bf431a934207d288420ad281ea00039b0726d0034669e0fff79fffbde81040704781ea000300eb020c9b0701eb020e42d15fea8c732bd0a0f1010c00bf8b1813f801ec8418531e04f801ec04d0624412f003021a46f2d101eb030e00eb030c17e0830736d0a2f1010c00f1010e002300bfcc5c9c45c45403f1010404d0734413f003032346f4d1121b2144031922e01346042b0ed3aef10402acf1040152f80449043b032b41f80449f8d802f1040e01f1040c1a4653b1aef10101acf1010300bf11f80149013a03f80149f9d1bde8104070470346042a06d351f8044b043a032a43f8044bf8d8002af0d00139013b00bf11f8014f013a03f8014ff9d1e6e700bf80b5002a18bf10f0030301d186460ce000f1010c864600bf013a0ef8011b04d01cf003030cf1010cf6d1102a11d35ffa81fc4ff001330cfb03fc00bf103acef80cc0cef808c0cef804c04ef810cb0f2af4d8042a0bd35ffa81fc4ff001330cfb03fc00bf043a032a4ef804cbfad8002a08bf80bdaef10103013a03f8011ffbd180bd00bf2de9f04fc7b04ff29c5bc2f2290b4ff6ff754ff47d7400274ff0010847f67f7a7f261191cde90f3007e000bf48f2a351c0f24501bff32f8f8847dbf80090bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14068b0f57d7f00f096804ff47d7006f004fd002800f0cb814ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ef66c61ccf2ff010160446080f80e80a0f8c4a180f8c361058445848584c584058545858585c585058645868586c586058745878587c5875be8001f49457ff452afbff35f8f4be8000121b15be8001f4945f8d047e74ff47d7800274ff0010a47f67f797f2607e000bf48f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f098804ff47d7006f042fc002800f009814ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ef66c61ccf2ff010160c0f8048080f80ea0a0f8c49180f8c361058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa1427ff451afbff35f8f00bf4be8000121b15be8001fa142f8d045e7d0f8948242f6f76ac0f2440ab8f1000fbff35f8f4ad00af19a0240464ff0ff314ff0ff379047002840f090811198002861d010980778a7f1170002285bd811980c2840f07d81109c6078a178084300f07781e0780138022800f27281a279e379667a42ea0322237a207942ea034242ea0663a27ae67a6179192f42ea062200f0de81172f40f0f481002a40f05981fe2800f0b086812800f0a386002840f0b68651ea030040f04c8100f000bf04460020d047e8b104f5257151e8008fb8f1000f0cd1bff35f8f00bf41e80002002a00f0e58051e8008fb8f1000ff5d00021bff32f8f0029bff35f8f00f0d480804692e74ff0ff372ae147f6df40c0f24f00cdf83880804700274ff47d784ff0010947f67f744ff07f0a1397adf8507007e000bf48f2a351c0f24501bff32f8f8847dbf80060bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f09f804ff47d7006f0f8fa002800f097804ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ef66c61ccf2ff010160c0f8048080f80e90a0f8c44180f8c3a1058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb1427ff451afbff35f8f00bf4be8000159b15be8001fb142f8d045e70af5a9718847bce6012120e70020109f42f6f76addf83880c0f2440a9fb1119989b1397801f07f02b2f10b0418bf0124b2f11c0618bf01268a2924dc0b2926d01c2924d03ce00f9012a803f045ff4ff0ff3701249df85100002812a818bf4ff0ff3704f05ff8054644b99df8500028b94af21f30c0f247004c3080470f98002818bf056114e09c2901d08b2918d168b14af21f31c0f247010746884797f8681121b997f824133846109f49b14ff0ff370af5807140468847384647b0bde8f08f0f9012a8344003f007ff387800f07f061e2e05d11199384607f094fe0746b9e71d2e00f07e0018bf1a2819d1dbf800100322cff680720a40b2f1005fbff35f8f12d10a684ef66c63ccf2ff039a420bd14a68b2f57d7f04bf002281f8a12303e0a6f115010129e1d90f2e2cdd142e40f31082152e00f05d83162e00f069831f2e40f02c841198012840f0fc8438781f2840f0f88445f64d55c0f24605a847012841f0828140f24c71c0f2010105f5e2777944e02029220023b8470746002818bf4ff0ff3766e7092e00f3fe80052e00f03e82072e40f0028400274ff0010947f67f764ff07f080d943ae000294ff0ff3708bf002b7ff47caf1328bff479af102a4ff0000138bf01211228b2fa82f218bf510901297ff46caf00f01ebd182f4ff0ff3708bf00297ff463af002b7ff460af352800f30884002800f0f684012800f00285312840f0f484082abff451af00f003bd48f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f05a864ff47d7006f035f9002800f052864ff60c41cff6ff7142182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ef66c61ccf2ff0101604ff47d71416080f80e90a0f8c46180f8c381058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa1427ff451afbff35f8f4be80001002900f0c6855be8001fa142f6d044e70a2e00f00a820b2e40f00483dbf800500320cff680702840b0f1005fbff35f8f41f05e8028684ef66c61ccf2ff01884241f0568068680027b0f57d7f7ff446aed5f8900342f68d49c0f244090028a5f8a07318bfc8470021a5f8d013c5f8cc13c5f86c1185f86a1185f86811d5f87001c5f8641185f86911c5f87011c5f82013a5f88c1320b148f2a351c0f245018847d5f89802002818bf03f0deff0026c5f89862d5f8880320b148f2a351c0f245018847c5f88863a5f88c63686ca5f8486040b1c847686c09f166018847002804bf002068644bf63940c0f251008047dbf800700320cff680703840b0f1005fbff35f8f48d138684ef66c61ccf2ff01884241d17868b0f57d7f3dd197f87b014ff00008c7f8848100b387f87b8197f8750149f259620138b0fa80f04109c0f2590240f20b1090474ef6e37610f1800fd8bf6ff07f00c0f25a067e28a8bf7e2087f8c401b04706f1bc008047d7f8880187f8748142f6f76addf83880c0f2440a50b1c847d7f8880109f166018847002804bf0020c7f88801dbf800000321cff680710140b1f1005fbff35f8f40f03b8701684ef66c62ccf2ff02914240f033874168b1f57d7f40f02e8790f8cc11002900f0238706f0cbfb00f025bf102e00f05581112e40f01f821198022840f0ef823878112840f0eb827878002840f0e78245f64d50c0f24600804701284ff000077ff465ad40f20830c0f210003790ff208df8d80044f25220c0f20100359040f2c960c0f24800cde93877804798b148f27e30c2f2070000880122c1b264298df8d72008d80721b0f5807f38bf03218df8d7108df8d80040f2d260adf8e000052037ae8df8e200f01d35a90522fff713f94ff22507c0f247070120092132460c23b847074600f0b9be11980d944ff47d7800244ff0010a47f67f797f2602282cbf7878ff200c9006e048f2a351c0f24501bff32f8f8847dbf80070bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f09f814ff47d7005f027ff002800f084844ff60c41cff6ff7142182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ef66c61ccf2ff010160c0f8048080f80ea0a0f8c49180f8c361058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb9427ff452afbff35f8f4be80001002900f00c815be8001fb942f6d045e711980228c0f0cd8100f06ffe002800f0c8817e78002e00f08d83022e00f2c18140f0b585014611980628c0f03185109fb878fa783b797f7940ea022043ea072232283790389280f09a85322000f09dbd1199781c013907f05afb0746fff729bc1199384606f07ffb0746fff722bc119801380228c0f095817878b9784ff0ff3740ea0120b0f5007f3ff613ac0321119a01eb400191427ff40cac002700288df8dc708df8dd708df8de708df8df708df8e0708df8e1708df8e2708df8e3708df8e4708df8e5708df8e6708df8e7708df8e8708df8e9708df8ea708df8eb708df8ec708df8ed708df8ee708df8ef708df8f0708df8f1708df8f2708df8f3708df8f4708df8f5708df8f6708df8f7708df8f8708df8f9708df8fa708df8fb708df8fc708df8fd708df8fe708df8ff708df800718df801718df802718df803718df804718df805718df806718df807718df808718df809718df80a718df80b718df80c718df80d718df80e718df80f718df810718df811718df812718df813718df814718df815718df816718df817718df818718df819718df81a718df81b713ff488ab109937aa03314ff0010c4b78012b00f2f7800f7847ea0323db08d65c07f007070cfa07f7374240f0eb80d65c013847ea060701f10201d754e7d10d9404f04afe002800f06d844ff47d7800244ff0010a47f67f797f2608e31d2e60d11199781c013907f071ff0746fff752bb90f8481042f6f76addf83880109fdde90c64c0f2440a61b1416c39b142f68d42c0f244020546084690472846002180f848100121119a032a1ad3ceb9b878082800f23a854bf63941c0f25101963188470027fff727bb362800f00681462800f00081572840f0ec80002e7ff449abfbe0119a052ac0f0d580012e40f0d280b8783e46411e06294ff000073ff60babf17803293ff607ab3279002a3ff403ab4bf63943c0f2510303f59a7398470027fff7f9ba1a2818bf1c2e6cd104f0d5fd002868d000f00bfd814608f0fef9b9f1000f4ff0ff3718bf00283ff4e4aa834647f63400c2f20700d0f81806d9f894131b2ea0eb0100c9f89c0300f0a2831a2e40f0c383109900254f1c11994ff4f072a1f1010a4ff4a071cde93d5037a84ff420764ff48058cde90950cde901214846394652465b46cde937853f95cde90755cde90555cde90355009608f0fefc002840f09883d9f89c033946cde93e0537a80a90012009904ff4a07002904ff4f0700190484652465b464ff42077cde937853d95cde90755cde90555cde90355009708f0dbfc61e54ff0ff37fff784ba0c294ff0ff377ff4adaab3f5005f5dd3fff7a8ba481e1f284ff0ff373ff6a2aac1f51630834251d9fff79cba002b7ff497aa421f18bf0122b0f1350318bf01231a40b0f1590318bf01231a40b0f1470318bf0123134208bf012937d0b0f1370218bf0122b0f1c10318bf01231a4208bf02292bd09f284ff0ff377ff473aa042924d0fff76fba022e40f044814bf63940c0f2510080470027fff736ba022abff461aa13e0002a7ff45daaa0f1fd0102290cd397287ff456aa08e06ff0780002427ff450aa02e0402abff44caa45f64d50c0f24600804710990128c9784ff0010008bf022008424ff000073ff43baacdf838804ff47d7847f67f797f2406e048f2a351c0f24501bff32f8f8847dbf80060bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f096804ff47d7005f019fc002800f030814ff60c41cff6ff7142182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ef66c61ccf2ff0101600121c0f804808173a0f8c49180f8c341058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb1427ff452afbff35f8f4be8000121b15be8001fb142f8d047e74af21f35c0f247050446a84794f86801ddf83880109f00287ff46ba994f82403214600287ff465a93878172812d0d1f8840320b904f05ff9c4f8840360b342f68d41c0f24401a1f140024ff47a719047214608bb01f226300e4639460c22fef700fd0f98002186f825030120bff35f8f86f824034ff4f07001904ff4207005f5106600900020002200230027b04700283ff431a984f8247305f14c0080474ff0ff37fff728b9119a072ac0f05581032e40f05281b878fa783e4640ea022039797f79b57901284ff0010698bf304644f62062904228bf10464bf63942c0f2510202f5e272642928bf6421904747f63400c2f207000068002800f0d98247ea0521012988bf0e4642f68d41c0f24401a1f14002314690470027fff7bfb8002780f8477145f64d50c0f24600804701287ff4b4a843f2a310c0f2560080470746fff7acb8ddf838804ff0ff37fff7d4b800201199dde90d48022910992cbf4978ff21002800f0a48202294ff000072cd0012926d000297ff491a84cf67e21caf2101187778783cbf8041087818760058445848584c584058545858585c585058645868586c586058745878587c58780f8407080f8d17380f8d073c0f8cc73fff76db801218173fff769b88773fff766b842f6f76addf83880109fdde90c6400210020c0f2440a21e548f2a351c0f24501bff32f8f8847dbf80070bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57d7f00f0e0804ff47d7005f06efa002800f039814ff60c41cff6ff7142182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ef66c61ccf2ff010160c0f8048080f80ea0a0f8c49180f8c361058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb9427ff452afbff35f8f4be8000100294dd05be8001fb942f7d046e780461198a14603284ff0000738d3301fb0fa80f04009084032d01198109a4cf6cd410338ccf6cc419578a0fb0101b5eb910f88bf8d082e46302d28bf302608f14a00d11c06eb8602fef75ffb002788f8486088f849709db1d8f8440038b9404600f0a7fa0028c8f8440000f07c8142f68d41c0f24401a1f1400201219047002742f6f76addf83880c0f2440a4c46fef758bfd0f870110027002900f0b0804ff400624ff0ff3c0df1dc0e04e033681a44b2f5403f50d28e18b568b7eb552ff5d1ec081ef8044005f0070324fa03f3db071ebf41f82570c6f808c0f760e6e71198032840f0c48010994ff4f077487889785a4640ea012600200890cde90600cde90400cde902004ff4a0700190484631464ff42073009707f06aff002800f01e814ff0ff37a3e01198012840f0a08009f57970bff35f8f50e8001f013140e80012002af8d113a94846012207f08afffff7d2b94ff0ff3752e04ff0000c4ff400634ff0000ec0f820c305e077463344b3f5403fbe4642d2cf18ba68ce580132f4d1f418220c022a2fd80a19956801352bd115682e443e6012681444220c022a23d80a19956801351fd115682e443e6012681444220c022a17d80a199568013513d115682e443e6012681444220c022a0bd80a199568013507d115682e443e6012681444b4f5403fcfd3bef1000fc7f804c00cbfc0f82033cef80430b7e7002742f6f76adde90d48c0f2440afef79abeb0f5fa6f084603d94ff4fa60379008460121054680f8471145f64d50c0f24600804701281bd143f2a318c0f25608a8f188008047022e074608bf002f01d057b90de04bf2110237a9c0f24b020220904728b10746c047002085f8470100e0002742f6f76addf83880c0f2440afef762be90f8cd11002918bf05f0a4fcdbf800000321cff680710140b1f1005fbff35f8f24d101684ef66c62ccf2ff0291421dd14168b1f57d7f19d1d0f8d813b1b14ff00041bff35f8fc0f8d4134af21f30c0f2470000f510674ff4f07001904ff4207600200021002200230096b84795f84701002785f8477158b145f64d50c0f246008047012804d143f2a310c0f256008047d5f8400195f84661c5f83c7185f84671a5f8447150b1c847d5f8400109f166018847002804bf0020c5f840010120a87356b14af27366c0f246060021002200230027b047fef7f6bd0027fef7f3bd701ca9f88c03002783e74bf639400027c0f2510088f84870804783e600bf2de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010a47f67f7b4ff07f0807e000bf48f2a351c0f24501bff32f8f8847d5f80090bff35f8f2868bff35f8f01466ff39601b1f1005f07d10168a14204d14168b1f57d7f00f095804ff47d7004f0e8ff002800f08d804ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ff47d710460416080f80ea0a0f8c4b180f8c381068446848684c684068546858685c685068646868686c686068746878687c68755e8001f49457ff45aafbff35f8f45e8000129b155e8001f4945f8d04fe7002001b0bde8f08f70b500284dd001684ef66c62ccf2ff02914218bf70bd90f8481090f849504bf6394c8d42c0f2510c2ad205eb8501014491f84d2091f84e4091f84ae091f84b3091f84c1042ea0424012c4ff0010298bf14466e1c054680f84960b9b164294eea032028bf6421012888bf024644f62060824228bf02460cf5e2731046984706e0002180f84810bde870406047e047686c38b142f64d42c0f244022146bde87040104770bd02464ff64b70cff6ff7042f6653c7844c0f2440c00210023604700bf2de9f04fcdb04ff29c57c2f229073c6840f2030b20464ef66c696ff39600cff6807bccf2ff09b0f1005fbff35f8f40f0e9812068484540f0e5816068b0f57d7f40f0e08194f8710347f64c65c2f2070504f5497628b347f61800c2f20700016d4bf67c52c0f2720291421ad1406cc0b1d4f87c032968401a012802db03f05cff78b93046b8460df02bf950b142f69570c0f25b0080474746002084f8720384f8710394f8700368b1d4f880032968401a012802db03f040ff20b9002084f8700384f86a013078bff35f8f70b194f86fa3ac46baf1000f00961cd094f8250394f83e13091a18bf012115e094f87103002840f0888194f87003002840f08381d4f88403002800f07e8142f68d41c0f24401884777e1012194f8270394f83133059094f8280394f83d23069094f8265394f82a0394f82b9394f82ce394f82db394f82e8394f82f63934235d194f8302394f83c339a422fd194f83b2396422bd194f83a23904527d194f83923934523d194f8382396451fd194f8372391451bd194f83623904217d194f8292394f835339a4211d194f83423069b93420cd194f83323059b934207d194f83223954203d111b994f82583a9e00023012284f8403384f8433384f8443384f8453384f8463384f8473384f8483384f8493384f84a3384f84b3384f84c3384f84d3384f84e3384f84f3384f8503384f8513384f8523384f8533384f8543384f8553384f8563384f8573384f8583384f8593384f85a3384f85b3384f85c3384f85d3384f85e3384f85f3384f8603384f8613384f8623384f8633384f8643384f8653384f8663384f8673384f8683384f8693384f86a3384f86b3384f86c3384f86d3384f86e3384f83f2384f8415384f84203dcf8002047f61803170a84f8432384f84473170c120e84f846230822c2f2070384f8457384f86f231a6d4bf67c57c0f2720704f22631ba4204f2323a1bd15a6ccab140f6b803c2f200031a689ab1182d00f02984172d40f03584fe2804f2473c0d4600f05684002840f0608400980df0acf8294602e0022084f8400350460c22fdf71fff94f8258394f86fa384f83e8345f64d50c0f246008047811eb1fa81f14fea511b012808bf4ff0020bbaf1000f5ad004f23f3007a9049040f261400631c0f2470003910aa9023100254ff00309a0f5b84000240291019015e000bf029807a91a468df828908df82980fdf7e9fe47f00802019ff0200aa90023b8470334e0b25045b1462fd2aaeb0400c7b20420032f28bf4f468df81c0005983a468df81d0006988df81fb08df81e0004988df8204050fa84f103988df821a08df822508df823508df82450fdf7bbfeb81dc345c3b24ff00306c2d14ef60b670120f02107aac0f24707c9e7bff35f8f00994ff29c574ef66c6940f2030b0020c2f22907ccf2ff09cff6807b08703d68bff35f8f05ea0b00b0f1005f59d12868484556d16868b0f57d7f52d105f575700021bff35f8f50e8006f40e80012002af9d147f64c60bff35f8fc2f207000468b6f1004f0fd0b84603f073fd58b1002e00f04d8195f8ec03320a002800f0e38195f8ed13ece195f8ec03e8b147f61800c2f207000068b8b145f60960c2f207000478002040f261430a9007900aa907aac0f247032046984707990a9a43f69b53c0f24e0320469847002085f8ee0385f8ec03d5f8d80320b142f68d41c0f244018847d7f800a0bff35f8f0aea0b00b0f1005f40f00481daf80000484540f0ff80daf80400b0f57d7f40f0f9809af8700338b100208af86801caf864014db0bde8f08f9af86801002800f0d780daf86441002c00f0d28040f6b800c2f20000056807a802f066f9002d00f0d781284621464ff416324e464ff6ff770695fdf7fbfd002547f67f744ff07f0806e048f2a351c0f24501bff32f8f88474ff29c50c2f22900d0f80090bff35f8f0068bff35f8f00ea0b01b1f1005f07d10168b14204d14168b1f57d7f00f0b8804ff47d7004f028fc002802f00c814ff60c41cff6ff7100bf42182e3182f8f45382f8f55382f8f65382f8f75382f8f85382f8f95382f8fa5382f8fb5382f8fc5382f8fd5382f8fe5382f8ff5382f8005482f8015482f8025482f8035482f8045482f8055482f8065482f8075482f8085482f8095482f80a5482f80b5482f80c5482f80d5482f80e5482f80f5482f8105482f8115482f8125482f8135482f8145482f8155482f8165482f8175482f8185482f8195482f81a5482f81b5482f81c5482f81d5482f81e5482f81f5482f8205482f82154a0d14ff47d71416001214ff29c5206608173a0f8c44180f8c381078447848784c784078547858785c785078647868786c786078747878787c787c2f2290252e8001f49457ff453afbff35f8f42e8000121b352e8001f4945f8d048e79af86a0170b1daf86c0140b147f64c61c2f207010968401a002802f3848000208af86a0140f6a120c0f2470080474db0bde8f08f95f8ec03002840f0db80e3e6817b002942f05780027f0021002a8df8281000f028824ff29c550aaac2f22905535c002b00f0928253185f78002f00f050829f78002f00f04e82df78002f00f04c821f79002f00f04a825f79002f00f048829f79002f00f04682df79002f00f044821f7a002f00f042825f7a002f00f040829f7a002f00f03e82df7a002f00f03c821f7b002f00f03a825f7b002f00f038829f7b002f00f03682df7b002f00f034821f7c002f00f032825f7c002f00f030829f7c002f00f02e82df7c002f00f02c821f7d002f00f02a825f7d002f00f028829f7d002f00f02682df7d002f00f024821f7e002f00f022825f7e002f00f020829f7e002f00f01e82df7e002f00f01c821f7f002f00f01a825f7f002f00f018829f7f002f00f01682db7f002b00f01482203160297ff47baf33e20120a5f8ec0340f20220a5f8f0030220002185f8ef03c5f8e01302f00103c6f300208b42c6f34b2206d123b395f8f233f7b2bb421fd00ce05bb995f8ef13a5f8ea2385f8f013022185f8f113c5f8dc4311e095f8ef3385f8f03385f8f163a5f8ea23c5f8dc4331b9012185f8ee13c6f34951a5f8e813002804bf002185f8ee1385f8ed0385f8f26395f8ee1341b395f8680160b1d5f8e403bff35f8fb5f8e8136ff39f20884216d195f8ee13c1b195f8ef6340e000208af86801caf864018af86a0101208af8690140f6a120c0f24700804701f06dbf002085f8ee03c5f8dc43d5f8dc13b5f8ea0395f8f163611a814220d28902b1fbf0f04ff4406395f8f01300fb00f2a3eb40005043000d721a00fb02f34ff60c47002b4ff40073cff6ff7748bf07f5fa7310fb0230c21700eb925001eb9026002147f61800c2f207000068e0b1d5f8e003f4b2a0421ad0002040f261430a9007900aa907aac0f247032046984707990a9a43f69b53c0f24e0320469847c5f8e04395f8ee1302e00020c5f8e003d5f8d80385f8ef6311b14ff47a7108e095f8f113f2b28a424ff0280108bf4ff47a7142f68d42c0f24402403a904795f8ee034746c8b13868bff35f8f00ea0b01b1f1005f41f0f8860168494541f0f4864168b1f57d7f41f0ef86002180f86811c0f864114db0bde8f08f95f8ed0300287ff453adf0b20228ddd140f6b800c2f2000001680029d6d001684ff416322139002301f8403f403a01f81f3c01f81e3c01f81d3c01f81c3c01f81b3c01f81a3c01f8193c01f8183c01f8173c01f8163c01f8153c01f8143c01f8133c01f8123c01f8113c01f8103c01f80f3c01f80e3c01f80d3c01f80c3c01f80b3c01f80a3c01f8093c01f8083c01f8073c01f8063c01f8053c01f8043c01f8033c01f8023c01f8013c4b708b70cb700b714b718b71cb710b724b728b72cb720b734b738b73cb730b744b748b74cb740b754b758b75cb750b764b768b76cb760b774b778b77cb7781f820309cd100684ef217310a904ff416300b900aa8c0f247018847474661e700980d460cf0f2fd10b302304ff0030008bf022084f840032946fff7dcbb84f87003dcf800204ef660231a44c4f88023b8b100980d460cf0b7ff0cf08bff294660b9fff7c8bb4ff29c55c2f2290595e00cf080ff002829463ff4bdab0320fff7b8bb002084f86a01fff7b5bb18684a4600eb0b20704400eb084000eb06616046fdf7ccfa0ee04eea0b2141ea084141ea066361464a460cf07ffd00281cbf032084f8400309f1080084f86f032946fff792bb01313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2921d84ff0520353541dd00a4445235e29537018d04f235d29937014d052235c29d37010d044235b2913710cd045235a29537108d052235929937104d020235829d37141f0c48200218df887100121427f002a00f0c28000220aab9f5c002f00f0a0809f187e78002e5ed0be78002e5dd0fe78002e5cd03e79002e5bd07e79002e5ad0be79002e59d0fe79002e58d03e7a002e57d07e7a002e56d0be7a002e55d0fe7a002e54d03e7b002e53d07e7b002e52d0be7b002e51d0fe7b002e50d03e7c002e4fd07e7c002e4ed0be7c002e4dd0fe7c002e4cd03e7d002e4bd07e7d002e4ad0be7d002e49d0fe7d002e48d03e7e002e47d07e7e002e46d0be7e002e45d0fe7e002e44d03e7f002e43d07e7f002e42d0be7f002e41d0ff7f002f40d02032602a7ff49aaf54e001323ae0023238e0033236e0043234e0053232e0063230e007322ee008322ce009322ae00a3228e00b3226e00c3224e00d3222e00e3220e00f321ee010321ce011321ae0123218e0133216e0143214e0153212e0163210e017320ee018320ce019320ae01a3208e01b3206e01c3204e01d3202e01e3200e01f325f2a15d84ff053079f5411d013444b275e2a5f700cd049275d2a9f7008d050275c2adf7004d020275b2a1f7140f0f08100228df887200131827f002a00f0be8000210aaa535c002b00f0a08053185f78002f5ed09f78002f5dd0df78002f5cd01f79002f5bd05f79002f5ad09f79002f59d0df79002f58d01f7a002f57d05f7a002f56d09f7a002f55d0df7a002f54d01f7b002f53d05f7b002f52d09f7b002f51d0df7b002f50d01f7c002f4fd05f7c002f4ed09f7c002f4dd0df7c002f4cd01f7d002f4bd05f7d002f4ad09f7d002f49d0df7d002f48d01f7e002f47d05f7e002f46d09f7e002f45d0df7e002f44d01f7f002f43d05f7f002f42d09f7f002f41d0db7f002b40d0203160297ff49aaf50e001313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2911d84ff0440353540dd00a4455235e29537008d050235d29937004d020235c29d37040f0098100218df8871001216a6846f23f53c5f28803b3eb520f40f08b80d20700f08d8000210aaa535c002b00f0858153185f78002f00f0f9809f78002f00f0f980df78002f00f0f9801f79002f00f0f9805f79002f00f0f9809f79002f00f0f980df79002f00f0f9801f7a002f00f0fc805f7a002f00f0fc809f7a002f00f0fc80df7a002f00f0fc801f7b002f00f0fc805f7b002f00f0fc809f7b002f00f0fc80df7b002f00f0fc801f7c002f00f0fc805f7c002f00f0fc809f7c002f00f0fc80df7c002f00f0fc801f7d002f00f0fc805f7d002f00f0fc809f7d002f00f0fc80df7d002f00f0fc801f7e002f00f0fc805f7e002f00f0fc809f7e002f00f0fc80df7e002f00f0fc801f7f002f00f00d815f7f002f00f00b819f7f002f00f00981db7f002b00f00781203160297ff47baf1de14cf67e22caf210126a60002940f0198100210aaa535c002b00f0dc8053185f78002f61d09f78002f60d0df78002f5fd01f79002f5ed05f79002f5fd09f79002f60d0df79002f61d01f7a002f62d05f7a002f63d09f7a002f64d0df7a002f68d01f7b002f69d05f7b002f6ad09f7b002f6bd0df7b002f6cd01f7c002f6dd05f7c002f6ed09f7c002f6fd0df7c002f70d01f7d002f71d05f7d002f72d09f7d002f73d0df7d002f74d01f7e002f75d05f7e002f76d09f7e002f77d0df7e002f78d01f7f002f79d05f7f002f7ad09f7f002f7bd0db7f002b7cd0203160297ff49aaface000211171f6e6013173e0023171e003316fe004316de0013184e0053169e0023180e0063165e003317ce0073161e0043178e008315de0053174e0093159e0063170e00a3155e007316ce000225a710fe60b314ee0083165e00c314ae0093161e00d3146e00a315de00e3142e00b3159e00f313ee00c3155e010313ae00d3151e0113136e00e314de0123132e00f3149e013312ee0103145e014312ae0113141e0153126e012313de0163122e0133139e017311ee0143135e018311ae0153131e0193116e016312de01a3112e0173129e01b310ee0183125e01c310ae0193121e01d3106e01a311de01e3102e01b3119e01f315f2931d84ff04f0353542dd00a444b235e29537028d020235d29937024d00021d17024e01c3104e01d3102e01e3100e01f315f2918d84ff04103535414d00a444c235e2953700fd05d2993700cd04f235c29d37008d043235b29137104d020235a29537140f0828700218df8871000220aafb95c002900f0a080bb18597800295ed0997800295dd0d97800295cd0197900295bd0597900295ad09979002959d0d979002958d0197a002957d0597a002956d0997a002955d0d97a002954d0197b002953d0597b002952d0997b002951d0d97b002950d0197c00294fd0597c00294ed0997c00294dd0d97c00294cd0197d00294bd0597d00294ad0997d002949d0d97d002948d0197e002947d0597e002946d0997e002945d0d97e002944d0197f002943d0597f002942d0997f002941d0d97f002940d02032602a7ff49aaf42e001323ae0023238e0033236e0043234e0053232e0063230e007322ee008322ce009322ae00a3228e00b3226e00c3224e00d3222e00e3220e00f321ee010321ce011321ae0123218e0133216e0143214e0153212e0163210e017320ee018320ce019320ae01a3208e01b3206e01c3204e01d3202e01e3200e01f325f2a03d84ff07701b95403d100218df8871002e0b91800224a7004694ff0000917f80910002900f0c48007eb09025178002962d09178002962d0d178002962d01179002962d05179002962d09179002962d0d179002962d0117a002962d0517a002962d0917a002962d0d17a002962d0117b002962d0517b002962d0917b002962d0d17b002962d0117c002962d0517c002962d0917c002962d0d17c002962d0117d002962d0517d002962d0917d002962d0d17d002962d0117e002962d0517e002962d0917e002962d0d17e002962d0117f002962d0517f002962d0917f002962d0d17f002962d009f12009b9f1600f7ff496af4ff060095be009f1010958e009f1020955e009f1030952e009f104094fe009f105094ce009f1060949e009f1070946e009f1080943e009f1090940e009f10a093de009f10b093ae009f10c0937e009f10d0934e009f10e0931e009f10f092ee009f110092be009f1110928e009f1120925e009f1130922e009f114091fe009f115091ce009f1160919e009f1170916e009f1180913e009f1190910e009f11a090de009f11b090ae009f11c0907e009f11d0904e009f11e0901e009f11f0901250a2c1ed364214ff47a7242f2107305eb85077f00b4fbf7f60a2e11d305fb01f7b4fbf7f60a2e0bd305fb02f7b4fbf7f60a2e05d35d43b4fbf5f7092fe7d800e03d464946b9f15f0f98bf5f21c1f1000e05911eeb090b54d0b4fbf5f30aa903f1300201f809204cf6cd41ccf6cc410a2da5fb017248d31bf1010742d003fb154cd608bcfbf6f80aa901eb090448f21f5108f13002c5f2eb116270642da5fb013235d31bf102032cd008fb16c65309b6fbf3f244f6d35102f13007c1f26201a770b5f57a7fa5fb011724d31bf1030118d002fb1361ba0941f25977b1fbf2f3cdf2b717a5fb077603f13007e77003fb121442f2107109f104098d424fea5635a8d20ae0ddf8149007e009f1010904e009f1020901e009f1030900240aab03f80940195d002900f0a0801f19797800295ed0b97800295dd0f97800295cd0397900295bd0797900295ad0b979002959d0f979002958d0397a002957d0797a002956d0b97a002955d0f97a002954d0397b002953d0797b002952d0b97b002951d0f97b002950d0397c00294fd0797c00294ed0b97c00294dd0f97c00294cd0397d00294bd0797d00294ad0b97d002949d0f97d002948d0397e002947d0797e002946d0b97e002945d0f97e002944d0397f002943d0797f002942d0b97f002941d0f97f002940d02034602c7ff49aaf50e001343ae0023438e0033436e0043434e0053432e0063430e007342ee008342ce009342ae00a3428e00b3426e00c3424e00d3422e00e3420e00f341ee010341ce011341ae0123418e0133416e0143414e0153412e0163410e017340ee018340ce019340ae01a3408e01b3406e01c3404e01d3402e01e3400e01f345f2c11d84ff0750119550dd0191973225e2c4a7008d020225d2c8a7004d070225c2cca7040f09d8000218df8871044694ff0000e13f80e10002900f0c78003eb0e056978002962d0a978002962d0e978002962d02979002962d06979002962d0a979002962d0e979002962d0297a002962d0697a002962d0a97a002962d0e97a002962d0297b002962d0697b002962d0a97b002962d0e97b002965d0297c002965d0697c002965d0a97c002965d0e97c002965d0297d002965d0697d002965d0a97d002965d0e97d002965d0297e002965d0697e002965d0a97e002965d0e97e002965d0297f002965d0697f002965d0a97f002965d0e97f002965d00ef1200ebef1600f7ff496af4ff0600e5ee00ef1010e5be00ef1020e58e00ef1030e55e00ef1040e52e00ef1050e4fe00ef1060e4ce00ef1070e49e00ef1080e46e00ef1090e43e00ef10a0e40e00ef10b0e3de00ef10c0e3ae00ef10d0e37e00ef10e0e34e000220a7162e70ef10f0e2ee00ef1100e2be00ef1110e28e00ef1120e25e00ef1130e22e00ef1140e1fe00ef1150e1ce00ef1160e19e00ef1170e16e00ef1180e13e00ef1190e10e00ef11a0e0de00ef11b0e0ae00ef11c0e07e00ef11d0e04e00ef11e0e01e00ef11f0e01250a2c1ed364214ff47a7242f2107305eb85077f00b4fbf7f60a2e11d305fb01f7b4fbf7f60a2e0bd305fb02f7b4fbf7f60a2e05d35d43b4fbf5f7092fe7d800e03d46f446bef15f0f98bf4ff05f0cccf1000842f2107b18eb0e0952d0b4fbf5f20aa902f1300301f80e304cf6cd41ccf6cc410a2da5fb016345d319f1010640d002fb1546db08b6fbf3f20aa901eb0e0448f21f5102f13007c5f2eb116770642da5fb011732d319f102012ad002fb13637a09b3fbf2f6b5f57a7f06f13001a17044f6d351c1f26201a5fb011721d319f1030116d006fb1231ba0941f25976b1fbf2f3cdf2b716a5fb066703f13006e67003fb12140ef1040e5d454fea5735aad209e0e64607e00ef1010e04e00ef1020e01e00ef1030e00240df1280b0bf80e401bf80410002900f0a1800beb0405697800295ed0a97800295dd0e97800295cd0297900295bd0697900295ad0a979002959d0e979002958d0297a002957d0697a002956d0a97a002955d0e97a002954d0297b002953d0697b002952d0a97b002951d0e97b002950d0297c00294fd0697c00294ed0a97c00294dd0e97c00294cd0297d00294bd0697d00294ad0a97d002949d0e97d002948d0297e002947d0697e002946d0a97e002945d0e97e002944d0297f002943d0697f002942d0a97f002941d0e97f002940d02034602c7ff498af5ee001343ae0023438e0033436e0043434e0053432e0063430e007342ee008342ce009342ae00a3428e00b3426e00c3424e00d3422e00e3420e00f341ee010341ce011341ae0123418e0133416e0143414e0153412e0163410e017340ee018340ce019340ae01a3408e01b3406e01c3404e01d3402e01e3400e01f345f2c1fd84ff075010bf804101ad00beb040173225e2c4a7014d020225d2c8a7010d074225c2cca700cd031225b2c0a7108d030225a2c4a7104d02022592c8a7140f0898200218df88710d0f8cc734ff000091bf80910002900f0c4800beb09046178002962d0a178002962d0e178002962d02179002962d06179002962d0a179002962d0e179002962d0217a002962d0617a002962d0a17a002962d0e17a002962d0217b002962d0617b002962d0a17b002962d0e17b002962d0217c002962d0617c002962d0a17c002962d0e17c002962d0217d002962d0617d002962d0a17d002962d0e17d002962d0217e002962d0617e002962d0a17e002962d0e17e002962d0217f002962d0617f002962d0a17f002962d0e17f002962d009f12009b9f1600f7ff496af4ff060095be009f1010958e009f1020955e009f1030952e009f104094fe009f105094ce009f1060949e009f1070946e009f1080943e009f1090940e009f10a093de009f10b093ae009f10c0937e009f10d0934e009f10e0931e009f10f092ee009f110092be009f1110928e009f1120925e009f1130922e009f114091fe009f115091ce009f1160919e009f1170916e009f1180913e009f1190910e009f11a090de009f11b090ae009f11c0907e009f11d0904e009f11e0901e009f11f0901240a2f1ed364214ff47a7242f2107304eb84067600b7fbf6f50a2d11d304fb01f6b7fbf6f50a2d0bd304fb02f6b7fbf6f50a2d05d35c43b7fbf4f6092ee7d800e03446c846b9f15f0f98bf4ff05f08c8f1000e42f2107c1eeb09054dd0b7fbf4f14cf6cd4001f13002ccf6cc400bf809200a2ca4fb002341d36a1c3dd001fb1476d908b6fbf1f348f21f5003f130020beb0907c5f2eb107a70642ca4fb000230d3a81c29d003fb11615309b1fbf3f6b4f57a7f06f13000b87044f6d350c1f26200a4fb000220d3e81c16d006fb1310910941f25973b0fbf1f2cdf2b713a4fb033502f13003fb7002fb110709f1040964454fea5534afd209e0c14607e009f1010904e009f1020901e009f10309069d40f6b8060022c2f200060bf809201bf80200002800f0a1800beb0200417800295ed0817800295dd0c17800295cd0017900295bd0417900295ad08179002959d0c179002958d0017a002957d0417a002956d0817a002955d0c17a002954d0017b002953d0417b002952d0817b002951d0c17b002950d0017c00294fd0417c00294ed0817c00294dd0c17c00294cd0017d00294bd0417d00294ad0817d002949d0c17d002948d0017e002947d0417e002946d0817e002945d0c17e002944d0017f002943d0417f002942d0817f002941d0c07f002840d02032602a7ff498af49e001323ae0023238e0033236e0043234e0053232e0063230e007322ee008322ce009322ae00a3228e00b3226e00c3224e00d3222e00e3220e00f321ee010321ce011321ae0123218e0133216e0143214e0153212e0163210e017320ee018320ce019320ae01a3208e01b3206e01c3204e01d3202e01e3200e01f325f2a0ad84ff075000bf8020005d00beb020073215e2a41705dd100208df887000aaf42f2941845f29c14284602213a46c2f22008c2f213040bf0a3fd00208df8280038460bf01bff28460e213a460bf098fd4ff6a420cff6ff703058a0426ad14ff6b020cff6ff703058b0f54d2f62d14ff6b420cff6ff703058a0425bd145f610634ff0000ec2f213034cf6394408f1040c00274ff0ff3263454cd8186830f003051bd0984528bf0c2846d3a8eb03018d424ff0ff3142d8bd42394688bf2946c00703eb05001cbf0f46ae44013c00f10403e1d12fe000218170a1e70421b7f5807f21d300223d46b5f5007f17d3b5f5806f16d3b5f5006f15d30901b2eb153f4fea1515f0d10fe00022ca7176e500219171fff77db800211172fef73bbd490002e0890000e0c900634504d1484207ea0002714603e04ff0ff324ff0ff3147f64c60c2f20700d0f8840008f1080342f6941c9842c2f2270c4dd142f610674ff0000bc2f2200746f6b9700cf1040e00244ff0ff384ff0ff3977453cd83e6836f0030515d0bc4528bf0c2e36d3aceb07039d4234d82346a54288bf2b46f6071cbf1c46ab447b19013803f10407e4d122e00420b4f5807f17d34ff000082546b5f5007f0cd3b5f5806f0bd3b5f5006f0ad30001b8eb153f4fea1515f0d104e0400002e0800000e0c000774504d1404204ea0008d94603e04ff0ff384ff0ff394ff6882040f6b807cff6ff70c2f200073b580cf10800834264d14ff69423cff6ff73fb58b3f5333f5cd14ff69823cff6ff73fb58834255d14ff29c5043f21063c2f229004ff0000bc2f2270342f6f935a0f1040ca0f1080e0024634542d81e6836f003071ad09e454ff0ff30059028bf0c2e3ad3aeeb030087424ff0ff3034d82046a74288bf3846f6071cbf0446bb44d819013d00f10403dfd123e00427b4f5807f17d34ff0000e2546b5f5007f0cd3b5f5806f0bd3b5f5006f0ad33f01beeb153f4fea1515f0d104e07f0002e0bf0000e0ff00634505d17b4204ea03000590584602e04ff0ff300590064666208df8280072208df8290065208df82a008df82b002f208df82c006d204b238df82d0061208df8313069238df82e0078208df83230422356278df82f0020208df833303a238df8377047270aac8df830008df834308df835004c238df838708df83a00002720468df836308df839308df83b700bf0dafe069de05d002800f0a080e019417800295ed0817800295dd0c17800295cd0017900295bd0417900295ad08179002959d0c179002958d0017a002957d0417a002956d0817a002955d0c17a002954d0017b002953d0417b002952d0817b002951d0c17b002950d0017c00294fd0417c00294ed0817c00294dd0c17c00294cd0017d00294bd0417d00294ad0817d002949d0c17d002948d0017e002947d0417e002946d0817e002945d0c17e002944d0017f002943d0417f002942d0817f002941d0c07f002840d02037602f7ff49aaf64e001373ae0023738e0033736e0043734e0053732e0063730e007372ee008372ce009372ae00a3728e00b3726e00c3724e00d3722e00e3720e00f371ee010371ce011371ae0123718e0133716e0143714e0153712e0163710e017370ee018370ce019370ae01a3708e01b3706e01c3704e01d3702e01e3700e01f375f2f25d84ff02000e05521d0e01945215e2f41701cd076215d2f817018d065215c2fc17014d06e215b2f017110d048215a2f41710cd07521592f817108d06221582fc17104d02021572f017240f0f88000208df887002046494642460bf005fe0020215c002900f0a08021184a78002a5ed08a78002a5dd0ca78002a5cd00a79002a5bd04a79002a5ad08a79002a59d0ca79002a58d00a7a002a57d04a7a002a56d08a7a002a55d0ca7a002a54d00a7b002a53d04a7b002a52d08a7b002a51d0ca7b002a50d00a7c002a4fd04a7c002a4ed08a7c002a4dd0ca7c002a4cd00a7d002a4bd04a7d002a4ad08a7d002a49d0ca7d002a48d00a7e002a47d04a7e002a46d08a7e002a45d0ca7e002a44d00a7f002a43d04a7f002a42d08a7f002a41d0c97f002940d0203060287ff49aaf5be001303ae0023038e0033036e0043034e0053032e0063030e007302ee008302ce009302ae00a3028e00b3026e00c3024e00d3022e00e3020e00f301ee010301ce011301ae0123018e0133016e0143014e0153012e0163010e017300ee018300ce019300ae01a3008e01b3006e01c3004e01d3002e01e3000e01f305f281cd84ff02001215418d021184f225e284a7013d074225d288a700fd068225c28ca700bd065225b280a7107d072225a284a7103d0202259288a7128d100208df887000aac059a204631460bf038fd28461a2122460bf069fa00208af86801caf8640106984ef217310a904ff416300b900aa8c0f24701884701208af86a0107a800f031f9caf814004db0bde8f08f0020c871d6e70021417207e72de9f04f81b0009041f204024cf65560cef20002ccf2ac50c2f8ac0f4ef6fc50cef2000001684ef66c6641f08071016052f8040c4ff29c57ccf2ff06c2f229074ff6ff7440f0010000254ff0010847f67f794ff07f0a42f8040c06e048f2a351c0f24501bff32f8f8847d7f800b0bff35f8f3868bff35f8f01466ff39601b1f1005f07d10168b14204d14168b1f57d7f00f094804ff47d7002f0aafa002800f0ca804ff60c41cff6ff7100bf42182e3182f8f45382f8f55382f8f65382f8f75382f8f85382f8f95382f8fa5382f8fb5382f8fc5382f8fd5382f8fe5382f8ff5382f8005482f8015482f8025482f8035482f8045482f8055482f8065482f8075482f8085482f8095482f80a5482f80b5482f80c5482f80d5482f80e5482f80f5482f8105482f8115482f8125482f8135482f8145482f8155482f8165482f8175482f8185482f8195482f81a5482f81b5482f81c5482f81d5482f81e5482f81f5482f8205482f82154a0d14ff47d710660416080f80e80a0f8c49180f8c3a1048444848484c484048544858485c485048644868486c486048744878487c48757e8001f59457ff45aafbff35f8f47e8000121b157e8001f5945f8d04fe78169d1bb47f64c6245f6e466c2f20702cff6f8761368314617689f420ed117689f420bd117689f4208d117689f4203d1002901f10401efd19f421ed041f20401cef200010b6817681168b9420ed11168b9420bd11168b94208d11168b94203d1002e06f10406efd1b94206d041f20401cef200010968c91a816141f20400cef2000000680099086001b0bde8f08f00bf2de9f04f83b041f20401cef200014ef66c674ff29c5609680068ccf2ff07c2f229064ff6ff744ff000084ff0010947f67f7a4ff07f0b0291019006e048f2a351c0f24501bff32f8f88473568bff35f8f3068bff35f8f01466ff39601b1f1005f07d10168b94204d14168b1f57d7f00f093804ff47d7002f095f9002800f0e7804ff60c41cff6ff7142182e3182f8f48382f8f58382f8f68382f8f78382f8f88382f8f98382f8fa8382f8fb8382f8fc8382f8fd8382f8fe8382f8ff8382f8008482f8018482f8028482f8038482f8048482f8058482f8068482f8078482f8088482f8098482f80a8482f80b8482f80c8482f80d8482f80e8482f80f8482f8108482f8118482f8128482f8138482f8148482f8158482f8168482f8178482f8188482f8198482f81a8482f81b8482f81c8482f81d8482f81e8482f81f8482f8208482f82184a0d14ff47d710760416080f80e90a0f8c4a180f8c3b1048444848484c484048544858485c485048644868486c486048744878487c48756e8001fa9427ff45cafbff35f8f46e8000121b156e8001fa942f8d051e7816961b144f6d350c1f26200a1fb0001880901284ff0010088bf88094ce047f64c6245f6e466c2f20702cff6f8761368314600bf17689f420ed117689f420bd117689f4208d117689f4203d1002901f10401efd19f422ed041f20401cef200010b6817681168b9420ed11168b9420bd11168b94208d11168b94203d1002e06f10406efd1b94216d041f20401cef20001096844f6d357ca1ac1f26207a2fb07768261b00901284ff0010088bfb009994208bffa2000e0fa20dde90121891ab1fbf0f003b0bde8f08f2ab1a2fb0103002b1cbf0020704702fb01f0ffe7b0b54ff2a054c2f229040146206846f23f52c5f28802b2eb500f40f258304df681124cf67e25c2f20000c0f24802caf2101518bf25609047002804bf691c2160b0bd00bf0846ffe7014640f258304df69f22c2f20000c0f248021047002855d1002953d0082a51d30b78aa2b4ed18b79f02b4bd12de9f04182b045f64d550b2ac0f2460547d3c878a2f10803834242d14878212841d1087901283ed1487901283bd1c879c8bb0c4614f8080f10f03c0f33d18818884610f8021c10f8010c164641ea0027a2f10a0081b220460af032f9874222d1a847811eb1fa81f14f09012808bf0227002f4ad0207887f00301084247d0012039464246334600f07ff90446002898f8080018bf06243be04ff27143c0f24c0318470b2400e00a24a847811eb1fa81f14e09012808bf02261eb3304600f090f8f8b10546407ce0b10027284631463246032300970af0acf9686840b14bf69b71c0f25d0188476868fff774ff6f602868af75002818bffff76dff00202860a8602882204602b0bde8f0810624f9e700243842f6d0404631463a463b4600f056f9002818bf0446ece70b291dd3c278a1f10803934218d10278aa2a13d14278212a10d10279012a0dd14279012a0ad18279f02a07d1c2792ab9024612f8083f13f03c0f03d00a2070470b20704710b5084410f8023c10f8010c43ea0024a1f10a0081b210460af09cf8201a18bf0a2010bd002808bf7047b0b582b00446407cd0b100252046032300950af042f9606840b14bf69b71c0f25d0188476068fff70aff65602068a575002818bffff703ff00202060a060208202b0bde8b040704700bf2de9f04f81b04ef66c654ff29c56ccf2ff05c2f229064ff6ff7700244ff0010b47f67f784ff07f09009006e048f2a351c0f24501bff32f8f8847d6f800a0bff35f8f3068bff35f8f01466ff39601b1f1005f07d10168a94204d14168b1f57d7f00f095804ff47d7001f038ff002800f08d804ff60c41cff6ff7100bf42182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ff47d710560416080f80eb0a0f8c48180f8c391078447848784c784078547858785c785078647868786c786078747878787c78756e8001f51457ff45aafbff35f8f46e8000129b156e8001f5145f8d04fe700200099002801eb410100eb011118bf01f51b7001b0bde8f08f00bfb0b5c4b0dc08202c03d94ff0ff3044b0b0bd0df107048df807008df80810a01c11461a461d46fbf72ff8a81c4af6610582b2c0f24605f02021460023a84744b0b0bd00bf2de9f04f89b0064618469a4617468946fff700ff002800f09983044696f908000796b0f1ff3f00f003050add264616f8110f00283fd12068002818bffff7e4fd2de3207c10b3607c00b34ff000082046394652460323cdf800800af003f8606848b14bf69b71c0f25d0188476068fff7cbfdc4f80480206884f81680002818bffff7c2fd00202060a06020822068002818bffff7b9fd4ff480710020218207992060a0608978a081092004f11106e174a174257560760799a07c8978884240f0d382217da94240f0cf82411ca9f10b00627e01961e2828bf1e209042a17488bf6076a9f10200039787b20a2f4ff00005c0f0db82092241f2210809200497cdf808a017e02068049f002818bffff77cfda089002d00f10100069d26602674a660a08118bf0625059e06eb0b0082b2ba4280f0bb82217c80b20429064600f28080079b461c9a5c4b1c0129237405dd022906d0032968d1e28106e021b9627503e0238943ea02222281be4280f09e82042966d0079a831c925d8f1c0129277406dd049fff290bd003290bd11e464ce000291cbf278947ea0222049f228102e0627500e0e281bb4280f08082022935d8079ac61cd25ccb1c0129237405dd022933d0fe2905d1627506e021b9238943ea0222228100e0e281be4280f0678202292fd0079a031d925d41f00407fc2927740add049ffd290cd0fe2903d0278947ea0222049f228105e0049f0029bed1e28100e06275bb4280f0498209b11e4610e0461d0798c25c05202074e189208941ea0221e18128b1fff7c4fc0028206000f06682b4f808906089a9eb00011ffa81fbb1b27a1a5a45b8bf93465fea0b420ad022681044079a11441ffa8bf2faf7ebfe6089b4f80890584481b2494560817ff454afd4f800a0607dbaf1000f05964ff000060df1230108bf8a460f288df8236006d8217d00f00302511ab1fa81f14e0900074ff0000706d4217e607e814238bf20760fe000bf606840b14bf69b71c0f25d0188476068fff798fc6760607e20760120e0820695a6b1607da67d400715d4002e4ff0000500f089811ffa89f100294ff6ff7300f00a8101295cd10020cfe000bf607d400750d4002577e14ff48030fff74ffc002e824600f06f81a07d002800f06b81baf1000f00f067816668002e00f0fb8020890428c0f05f8121680a1812f8043c002b40f0588112f8033c002b40f0538112f8023cff2b40f04e8112f8012cff2a40f049814ff4803531607060c6f80ca03561002800f0648107464bf69b70c0f25d0000f5857230460021904740b9316931b170688d420d46ebd187420d46e8d15546002728e14ff48030fff700fc054622e14ff6fe7000ea0900ac4642426ff001000aeb0007be78ff7883ea06231eb25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead53686ea430383ea07231fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead737023087ea430308ead6371618023687ea430395d10230002765465feac97232d01af8000083ea002002b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead33282ea4003e0899ab2824273d15046ddf808a05346faf7a1fe00286bd10026012378e03820fff741fb002862d00646077047708770c770077147718771c771077247728772c772077347738773c773077447748774c774077547758775c775077647768776c776077747778777c77780f8287080f8297080f82a7080f82b7080f82c7080f82d7080f82e7080f82f7080f8307080f8317080f8327080f8337080f8347080f8357080f8367080f837704ff2dd50cff6ff70784430624ff22960cff6ff70784470624bf69b70c0f25d0045f6e46200f13c0730460f21c0f27c0238230025b84738b33046fff703fb2f46554600e05546606840b14bf69b71c0f25d0188476068fff7f5fa6760ddf808a000260323a77503991ffa89f720465246009709f015fd002d294605463ff460ad0846fff7dffa5be50027666077e6c5f580390027b5f5803f55463760f7607ff649aed0e700252046394652460323009509f0f6fc606840b14bf69b71c0f25d0188476068fff7befa65602068a575002818bffff7b7fa0020307000202060a06020820a2551e00798007a40064dd5207c00b301980078e0b103990025204652460323009509f0ccfc606840b14bf69b71c0f25d0188476068fff794fa65602068a575002818bffff78dfa00202060a06020820b252068002818bffff783fa00202060a060208220e001980078e0b103990025204652460323009509f0a1fc606840b14bf69b71c0f25d0188476068fff769fa65602068a575002818bffff762fa00202060a06020820625284609b0bde8f08f00bf2de9f041f0284bd100294ff00b0000f07f80022a7cd345f64d50c0f246000e4617468047811eb1fa81f14c09012808bf0224002c4ff00a006ad07578e91ec9b2fe2938bfbde8f081307833463946032860d002282dd001281cbf0a20bde8f081ac4204bf0020bde8f0814808842884bf0b20bde8f081881e03f1020887b240463946fff7bffa002869d006462846fff715fb21462a46fff7e9fa3046bde8f08145f64d57c0f2460707f5e27cbde8f0416047ac421cbf0020bde8f081a1f1210010f1160f48d36ff0480048432330c0b2242841d81a4612f8020f40f00207032f4bd19b796340032b47d10b2904d0032804bf0b20bde8f081881e4ef60b6783b2c0f247070120f021b847002818bf0620bde8f081ac422dd1a1f10c0010f1030f1ad31a4612f8020f042815d158796040032811d1d879a0f1310717f1300f0bd39b79984208d9a1f10807c01a874284bf0b20bde8f081cfe70b20bde8f081b07a204207d04046394622462b46bde8f041fff79abb0020bde8f0810a20bde8f08140f20d00c0f2000042f6653c7844c0f2440c012100220023604700bf80b582b04ff4f0704af61f4e01904ff4207cc0f2470e0020002100220023cdf800c0f04702b080bd4ff29c51c2f229010968bff35f8f0a466ff39602b2f1005f19d10a684ef66c63ccf2ff039a4212d14a68b2f57d7f0ed1d1f86c1159b147f64c62c2f207021268891a012903db0178042938bf7047002101707047b0b541f23154c0f252041d46a0474ff29c51c2f229010968bff35f8f0a466ff39602b2f1005f0cd10a684ef66c63ccf2ff039a4205d14a68b2f57d7f18bf002100e00021421c18bf002900d1b0bd95f84d20002afad091f84721002a08bfb0bd46f25863c2f206031a68132aeed8c2ebc20403eb04135b6801ebc2014ff40042c1f8e431a1f8ea212a7a01f5f271002a0fbf802248f20112ca808122ab7c33b1ab7d23b1022342f002028b71ca7195f820303bb195f8243023b1032342f004028b71ca7195f846304bb195f8443042f008020b7195f84530ca714b71b0bd48f27342c2f207021378002b14bf9378ff230b711378002b14bf5278ff224a71b0bdf0b589b048f66502c0f24b020c46054690474ff29c51c2f229010e68bff35f8f31466ff39601b1f1005f0cd131684ef66c62ccf2ff02914205d17168b1f57d7f08bf092d01d009b0f0bde1082c29fad896f847110029f6d045f64d51c0f2460107468847014638460129ecd1ff22079244f6435246f258610020cff60172c2f20601089006920b685a1e132a4fd8c3ebc30501eb05111a1fa1f5de7191f85451ad0618d4d51c42d091f8e450ad0616d4951c3cd091f87450ad0613d4551c36d00d79ad0610d4043aa1f5e071151da3f10403e3d12be05a1e01f5a87104e09a1ee03101e0da1e703106ebc203096893f9eb21b2f1ff3f1adc03f5f2731e688e4215d11e798df81b605e798df81c609b798df81e200a0a8df820108df821200a0c090e8df81d308df822208df823100f228df8012010228df80220522208218df80420b4f5804f4ff080028df800108df8061038bf4ff48042b4f5001f6ff07f0604f07f0138bf0026802c28bf80318df807109df809509df80a108df8030004d29df808200223002415e0c4f3c610b4f5804f024403d20323012400200be0b4f5001f03d204230224012003e0052303240120002135468df8053004f108038df808208df809508df80a1070b96846a222c118c254062048700c208870c81c06a90c22faf7f7f904f117034ff225066a46c0f2470601200821b047384609b0f0bd70b582b00546ff208df8040044f25220c0f20100009040f2c960c0f2480016460c46804798b148f27e30c2f2070000880122c1b264298df8032008d80721b0f5807f38bf03218df803108df80400301b28bf08280cd3d221281929550621417005218170033069460522faf7b3f90834204602b070bd00bf024600284ff0ff3009d0022918bf70471078112801d1507810b14ff0ff30704710b586b045f64d50c0f24600804701284ff000003ed1cde9020040f20830c0f210000190ff208df8140044f25220c0f20100049040f2c960c0f24800804798b148f27e30c2f2070000880122c1b264298df8132008d80721b0f5807f38bf03218df813108df8140040f2d260adf80800052001ac8df80a00e01d04a90522faf75df94ff2250cc0f2470c0120092122460c23e04706b010bd024600284ff0ff3021d0012918bf704710781f2819d110b545f64d54c0f24604a04701281cbf002010bd4bf20e31c0f2000104f5e2747944e02029220023a047002818bf4ff0ff3010bd4ff0ff3070474ff29c50c2f22900016808466ff39600b0f1005f1ad108684ef66c62ccf2ff02904213d14868b0f57d7f0fd1d1f83c0160b147f64c62c2f207021268801a0028cebf01200020c1f83c017047002070474ff29c50c2f22900026810466ff39600b0f1005f32d110684ef66c61ccf2ff0188422bd15068b0f57d7f27d1d2f86c0120b347f64c61c2f207010968401a0028c4bf01207047d2f8701100200029c2f86c0182f86a01c2f87001c2f82003a2f88c0308bf704780b548f2a352c0f24502084690470020bde88040704700207047f0b101684ef66c62ccf2ff02914218bf704790f8461199b110b54af273644ff0000cc0f24604864680f846c10120002100220023aef844c1a446bde810406047704700bf02464ff6ab70cff6ff7042f6653c7844c0f2440c00210023604700bf70b5002866d0044600796179a279e37940ea012040ea024050ea036007d00e2803d0032856d1032502e0042500e00225fff74eff00284dd04ff29c50c2f22900066830466ff39600b0f1005f42d130684ef66c61ccf2ff0188423bd17068b0f57d7f18bf70bd45f64d50a478c0f24600804701282ed1082086f88402032086f88502102086f88602b22086f88802062086f8890286f88a02462086f88b0243204ff0000e86f88c0201204ef6057c06f5217286f887e286f88d0286f88e5286f88f42c0f2470c09210d2386f890e2bde87040604770bd00bf2de9f04f81b04ef66c6a4ff29c560446ccf2ff0ac2f229064ff6ff77002547f67f784ff07f0906e048f2a351c0f24501bff32f8f8847d6f800b0bff35f8f3068bff35f8f01466ff39601b1f1005f07d10168514504d14168b1f57d7f00f096804ff47d7000f048fe002800f0bb804ff60c41cff6ff7100bf42182e3182f8f45382f8f55382f8f65382f8f75382f8f85382f8f95382f8fa5382f8fb5382f8fc5382f8fd5382f8fe5382f8ff5382f8005482f8015482f8025482f8035482f8045482f8055482f8065482f8075482f8085482f8095482f80a5482f80b5482f80c5482f80d5482f80e5482f80f5482f8105482f8115482f8125482f8135482f8145482f8155482f8165482f8175482f8185482f8195482f81a5482f81b5482f81c5482f81d5482f81e5482f81f5482f8205482f82154a0d14ff47d7141600121c0f800a08173a0f8c48180f8c391078447848784c784078547858785c785078647868786c786078747878787c78756e8001f59457ff459afbff35f8f00bf46e8000121b156e8001f5945f8d04de7002780f85b712a270821032380f85c71042780f8581180f85931102380f85d7180f85e1101214ff2250c074600f5ac7280f85a3180f85f1180f86031002c18bf0124c0f2470c012010210a2387f8614101b0bde8f04f604701b0bde8f08f00bf80b582b04ff0010ccdf800c000f002f802b080bd2de9f04381b04ff29c57c2f229073f68ddf820803c466ff39604b4f1005f10d13e684ef66c65ccf2ff05ae424ff0000904d17e68b6f57d7f08bfb946012804d013e04ff0000901280fd11c4615460e460746fff7d1fd2346044631462a463846002c18bfb9f1000f07d14af2736cc0f2460c01b0bde8f043604799f8460180b1b8f1010f7cd1d9f84001002189f84611a9f84411a0b342f68d41c0f2440188472ee0b9f844010121013080b2012898bf0846a9f84401d9f8400142f68d44c0f2440489f8461128b94846fff71ffec9f8400140b1a047d9f84001a4f140024ff4c8719047a8b199f84601002848d0d9f84001002189f84611a9f8441100b1a0474af2736cc0f2460c0120002100220023afe745f64d50c0f24600804701282fd1082089f84801032089f84901102089f84a01002089f84b01b22089f84c01062089f84d0189f84e01462089f84f01432089f85001012089f85101b9f844014ef6057c070a09f5a47289f8528189f85301c0f2470c012009210d2389f8547178e701b0bde8f08300bf80b582b04ff0050ccdf800c0fff734ff02b080bd2de9f04f83b04468002c00f0ba828368002b00f0b68204eb030b4ff000090027002614e047f64c63c2f207031b6845f69077c0f201073b44c6f83c310ceb0a0300275b451c464ff0000680f09a82a04618f9013b03f07f05bd40002b46ea050610d406f00703012b16dc0bb3012b40f08882abeb0803082bc0f0838204f10903dee700bfd84580f07c82182f07f107074446dcd975e200bf022b3ad0052b40f07082abeb0803042bc0f06b82631dc7e7d84580f0668294f90130002b04f10203bed55b4580f05d8294f90230b3f1ff3f04f10303b4dc5b4580f0538294f90330b3f1ff3f04f10403aadc5b4580f0498294f90430b3f1ff3f04f10503a0dc5b4580f03f8294f90530002b00f13a82a31d96e7d84580f0358294f9013004f1020c002b03f07f0a1fd5dc4580f02a8294f90270e31c07f07f05b7f1ff3f4aeac51a02dde0469c460fe05b4580f01a8294f9037004f1040c07f07f05b7f1ff3f4aea853a40f3ff809846abeb0c039a4500f20882f308672b1dd0652b7ff45fafbaf1060ffff45baf9cf80030462b7ff456af98f80230432b7ff451af98f80330012b7ff44caf4ff29c54c2f229040290cde9002118e0044660460e4651461746654600f036fcac4631463a46204636e748f2a3513046c0f24501bff32f8f8847dde900210298ac462768bff35f8f2668bff35f8f33466ff39603b3f1005f0bd133684ef66c65ccf2ff05ab4204d17368b3f57d7f00f0c2804ff47d70654600f09efbdde9002106460298ac46002e3ff406af4ff60c43cff6ff73f4182e3384f8f49384f8f59384f8f69384f8f79384f8f89384f8f99384f8fa9384f8fb9384f8fc9384f8fd9384f8fe9384f8ff9384f8009484f8019484f8029484f8039484f8049484f8059484f8069484f8079484f8089484f8099484f80a9484f80b9484f80c9484f80d9484f80e9484f80f9484f8109484f8119484f8129484f8139484f8149484f8159484f8169484f8179484f8189484f8199484f81a9484f81b9484f81c9484f81d9484f81e9484f81f9484f8209484f82194a0d14ef66c63ccf2ff0333604ff47d7373600123b37347f67f73a6f8c4317f2386f8c3314ff6ff734ff29c5433847384b384f38433857385b385f38533867386b386f38633877387b387f387c2f2290454e8003fbb427ff440afbff35f8f00bf44e80063fbb154e8003fbb42f8d034e7dc4580f00c8194f90470631d07f07f05b7f1ff3f4aea455a3ff7e1ae5b4580f0fe8094f90570002f00f1f98004f1060c4aea077ae5e698f8043098f8057098f80650032b47ea052837dd052b58dc042b78d0052b7ff440aed6f86c313bb147f64c67c2f207073f68db1b002b18dcd6f8703186f86a91c6f87091c6f82093a6f88c936bb10c4648f2a35180461846c0f24501174665468847ac4621463a46404647f64c63c2f207031b6845f69077c0f201073b44c6f86c310ee6012b3ff400ae022b00f08780032b7ff406ae17460c466546fff711fb03460298ac4621463a46002b3ff4f9ad96f84631002b3ff4f4ad304641f28831a6f8448109f0b1f947e0062b4ad0072b7ff4e7ad80464df6db50c0f24a0016460f466446804703465d1ea446394632464046012d3ff6d5ad981eb0fa80f04009fff7e3fba446394632464046c9e517460c466546fff7d5fa03460298ac4621463a46002b3ff4bdad96f84631002b3ff4b8adb6f8443143457ff4b3add6f8403186f84691002ba6f844913ff4aaad42f68d411846c0f2440188470298ac4621463a469ee5d6f87031c6f86c91002b86f86a91c6f87091c6f82093a6f88c933ff490ad0f4648f2a35104461846c0f24501164665468847ac463946324648e696f84631c6f83c91002b3ff47bad0446d6f8400165468846174686f84691a6f8449120b142f68d41c0f2440188474af273660120002100220023c0f24606b04720463a464146ac465ce54ff2a513c0f2490303b0bde8f04f184700bf7fb50646002806d1fff75efa002807d19de80f00064649f29b1cc0f24f0c60477fbd00bff0b583b01d46144609294ed106460f46f22d10d8a22160196155062141700b2181704af29571c0f20001033079440b22f9f762fb0e35204629464ff4807200f03df80546ff208df8080044f25220c0f20100019040f2c960c0f24800804798b148f27e30c2f2070000880122c1b264298df8072008d80721b0f5807f38bf03218df807108df80800f82d0cd8d221601961550621417005218170033001a90522f9f72afb0835394630464ef60577c0f2470722462b46b84703b0f0bd70b58ab00c464ff29c51c2f229010b68bff35f8f19466ff39601b1f1005f16d119684ef66c66ccf2ff06b1420fd15968b1f57d7f0bd1694605461846164600f039fc324628462825a24231d244e04d218df8001043218df8011001218df80210002115258df803108df804108df805108df806108df807108df808108df809108df80a108df80b108df80c108df80d108df80e108df80f108df810108df811108df812108df813108df81410a24213d3111b022910d30fd003398d420cd8c22201190255062048708d70c81c69462a46f9f7b4fa6019c41c20460ab070bd00bf46f65450c2f20700016840f2230cc0f2000cfc44c26861454ff001034ff0040008bf0223624508bf0820002a08bf1046002918bf184370472de9f04f81b04ff29c53c2f229031c68bff35f8f23466ff39603b3f1005f40f0cc8023684ef66c67ccf2ff07bb4240f0c4806368b3f57d7f40f0bf80d4f8bc310133c4f8bc314ff6ff739a4238bf134694f87471a4f8c03184f8c2011fb1002a18bf002907d1b4f8c6010130a4f8c60101b0bde8f08f94f87b010028f3d0d4f8840170b147f64c69c2f20709d9f80030c01a002805dd94f87501012809d101270ce0b4f8c8010130a4f8c80101b0bde8f08f94f87771012f18bf022794f87a510020eb0793468846adf80200adf8000012d0022f10d194f8790168b90df1020641f281556b46c0f25b05404611463246a84794f87a515a461646b2f5c86f28bf4ff4c86606f1150a504600f061f8002856d0bbf5c86f88bf45f08005d9f80010d4f8802153230271120a42710a0a8171c2710a0c090e03704d234172a02143700123c17200218370c57002728772017394f87911bdf802204173bdf800108373c173090a0174110a8174310a017500f115014274c6740746084641463246f9f7d1f94ff27d12c0f2470238465146904710f1800fd8bf6ff07f007e28a8bf7e20d4f8801184f8c501481c48f2a351c4f88001c0f245013846884701b0bde8f08fb4f8ca010130a4f8ca0101b0bde8f08fb0b54ff2a054c2f22904216846f23f52c5f28802b2eb510f48f25f514cf67e25c0f24501caf2101518bf25608847002804bf691c2160b0bd10b301684ef66c62ccf2ff0291421bd190f87b11c1b1d0f88411b1b147f64c62c2f207021368cb1a012b0edb1268d0f88801002808bf7047891a42f64d42c0f2440208bf01211047704710b590f875210021c0f8841180f87b11511eb1fa81f149f259624909c0f25902044640f20b10904710f1800fd8bf6ff07f007e28a8bf7e2084f8c4014ef6e374c0f25a04a04704f1bc00bde81040004700bf2de9f04f81b00429c0f0e980834600784d2840f0e4809bf80100432840f0df809bf80200012840f0da804ef66c684ff29c570d46ccf2ff08c2f229074ff6ff7600244ff07f0906e048f2a351c0f24501bff32f8f8847d7f800a0bff35f8f3868bff35f8f01466ff39601b1f1005f07d10168414504d14168b1f57d7f00f098804ff47d70fff752ff002800f0a8804ff60c41cff6ff7100bf42182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ff47d7141600121817347f67f71c0f80080a0f8c41180f8c391068446848684c684068546858685c685068646868686c686068746878687c68757e8001f51457ff457afbff35f8f00bf47e8000121b157e8001f5145f8d04be79bf80310022905dc01290ed0022900f09e800ce003290dd0042908d190f8741129b101b0bde8f04fdce00d2d06d201b0bde8f08f044600f031f987e090f87b1119b390f87521002180f87b11511eb1fa81f149f259624909c0f25902044640f20b1090474ef6e37510f1800fd8bf6ff07f00c0f25a057e28a8bf7e2084f8c401a84705f1bc00804720469bf804100446012988bf002180f875119bf8051001f00302012a4ff0010198bf0a4680f877219bf80630012b88bf002380f878319bf80730022b88bf002380f879319bf808309bf8097043ea0723502b98bf5023b3f5f07f28bf4ff4f073a0f87c319bf80a309bf80b7043ea072341f28837bb4238bf1f46a0f87e719bf80c3080f8741103f0030380f87a3102f00103002103eb5202c0f88011c0f8bc11a0f8c01180f8c211c0f8c811a0f8c6117f2180f8762180f8c51100f009f8204600f04cf8204601b0bde8f04f78e000bfb0b5044690f87a01800758bfb0bd94f875014ef633750128c0f25a0507d105f1b000804705f58b71002088470ee005f5b670804794f87501012801d1002004e094f87701013818bf0120a84794f875014ff6ed120138b0fa80f0cff6ff7249f2015341097a44c0f2590340f20b10984710f1800fd8bf6ff07f007e28a8bf7e2084f8c301012084f87b01b0bd70b5044647f64c60c2f20700006894f87b1145f69075c0f2010500292844c4f8840108bf70bdd4f8880142f66536c0f2440658b94ff69130cff6ff707844002122460023b047c4f8880150b106f594718847d4f8880106f1e8022946bde87040104770bdb0b5044600f5c675082084f88c01032084f88d01102084f88e01002084f88f01c22084f89001062084f8910104f29311204600f065f84ff0280e4ef6057cc0f2470c012009212a462f2384f892e1bde8b040604770b54ff29c50c2f229000468bff35f8f20466ff39600b0f1005f46d120684ef66c61ccf2ff0188423fd16068b0f57d7f18bf70bd94f87b010025c4f8845100b394f8750149f259620138b0fa80f04109c0f2590240f20b1084f87b5190474ef6e37610f1800fd8bf6ff07f00c0f25a067e28a8bf7e2084f8c401b04706f1bc008047d4f8880184f8745170b142f68d45c0f24405a847d4f8880105f166018847002804bf0020c4f8880170bd70b505464d200870432048700120887095f874010c46c87095f87501087195f87701487195f87801887195f87901c87195f87c01087295f87d01487295f87e01887295f87f01c87295f87a01087395f87b01487345f64d50c0f246008047a073d5f880010026e073d5f88001000a2074b5f88201607495f883012675a074a020e074d5f8bc016075d5f8bc01000aa075b5f8be01e07595f8bf01207695f8c001607695f8c101a07695f8c201e07695f8c601207795f8c701607795f8c801a07795f8c901e07795f8ca0184f8200095f8cb0184f8210095f8c30184f8220095f8c40184f8230095f8c50184f82400fff79dfb84f82500d5f88401a0b147f64c61c2f207010a68821a012a0bdb0968401a44f6d35100f2e730c1f26201a0fb01018e0900e00026300a84f8266084f8270070bd00bf2de9f04182b04ff29c51c2f229010c68bff35f8f21466ff39601b1f1005f79d121684ef66c62ccf2ff02914272d16168b1f57d7f6ed194f8cc1179b394f8ce01c0070ad0d4f86c0178b347f64c61c2f207010968401a002827dd47f24c45c2f2070555f8040c002854d042f29707c0f24c074af6e908002607f5437101a8c0f24b0801968847a8b1032084f8cf612860b4f8d001c04702b0bde8f081d4f8d811c1b302b0bde8f0410847204602b0bde8f04133e0019841f60d56c0f24c06a861b04706f5af708047e861b847012084f8cf0103202860b4f8d001c047d4f8e001a0b10199d4f8dc21b4f8d271531a38bf8b1abb420ad2b4f8d41159b147f64c62c2f207021268101a884203d32046022100f078f802b0bde8f08100bfb0b590f8cc41002c4cd044f28442c2f200021188082911462cd0114631f8083f082b27d0114631f8103f082b22d0114631f8183f082b1dd0114631f8203f082b18d0114631f8283f082b13d0114631f8303f082b0ed0114631f8383f082b09d0114631f8403f082b04d032f8481f0829114614d14a68b2f5870f10d36ff35602012a0cd14a684ff65363cff6ff737b449a4204d1d0f8d821002a18bf4a60002180f8cc1190f8cd11b1b1002180f8cd1145f60a61c2f20701097869b947f24841c2f20701096839b14af68171c0f24b010546042088472846002c08bfb0bd0321bde8b04000e000bfb0b588b0044645f64d50c0f246000d468047012840f08f8008208df8010003208df8020010208df8030000208df80400ca208df8050006208df8060018208df8070047f26440c2f2070050f81c2c94f8cc11002a18bf0122002945f60961c2f207014b7818bf0232002b94f8cf3118bf0432002b4ff0410318bf08328df808304c238df8093001238df80a308df80b508df80c2050f8182c4ef605758df80d200268c0f24705130a8df80e208df80f30130c120e8df810308df811204268130a8df812208df81330130c120e8df814308df8152002698df81620120a8df8172009788df8181081688df819106821c2f2000109688df81a10090a8df81b1047f64c61c2f207010a68130a8df81c208df81d30130c120e8df81e308df81f2000680df10102c4f8dc0108680921c4f8e00101201f23a84708b0b0bd00bf2de9f04f83b0022902d24ff0ff35ece0cde901100120cff680704ef66c644ff29c56ccf2ff04c2f229064ff6ff77851c4ff0000947f67f7b4ff07f0807e000bf48f2a351c0f24501bff32f8f8847d6f800a0bff35f8f3068bff35f8f00ea0501b1f1005f07d10168a14204d14168b1f57d7f00f093804ff47d70fff7a1fa0028c3d04ff60c41cff6ff7100bf42182e3182f8f49382f8f59382f8f69382f8f79382f8f89382f8f99382f8fa9382f8fb9382f8fc9382f8fd9382f8fe9382f8ff9382f8009482f8019482f8029482f8039482f8049482f8059482f8069482f8079482f8089482f8099482f80a9482f80b9482f80c9482f80d9482f80e9482f80f9482f8109482f8119482f8129482f8139482f8149482f8159482f8169482f8179482f8189482f8199482f81a9482f81b9482f81c9482f81d9482f81e9482f81f9482f8209482f82194a0d14ff47d714160012104608173a0f8c4b180f8c381078447848784c784078547858785c785078647868786c786078747878787c78756e8001f51457ff45cafbff35f8f46e8000121b156e8001f5145f8d051e7044645f64d50c0f24600804701281dd1029d6978022916d00129204607d000297ff425af00210025fff77efe0fe0019f41f28831022f0ed14ff4fa730022012741f2883624e02046fff7fafd0025284603b0bde8f08faa78052f11d3eb782e79072f43ea062310d395f805c0ae79092f4cea0627e4d3ee792d7a46ea052607e041f288364ff4fa7301e041f288360127642b98bf64238b4228bf0b4690f8cc1180f8ce21a0f8d031a0f8d271a0f8d46171b147f24841c2f20701096800295ed001210446fff730fe0025c4f8e051bee744f28442c2f200021188082911462cd0114631f8083f082b27d0114631f8103f082b22d0114631f8183f082b1dd0114631f8203f082b18d0114631f8283f082b13d0114631f8303f082b0ed0114631f8383f082b09d0114631f8403f082b04d032f8481f0829114632d14a686ff00105b2f5870ffff483af0123cff680731a40012a7ff47caf4b684ff6c112cff6ff727a44934214bfc0f8d831d0f8d831002b3ff46daf4a60012180f8cc1199e74af60771c0f24b010420884720b105462046fff756fd5be70121204684f8cd118fe76ff0010553e700bf70b582b00c464df6cb61c0f245018847002c18bf002801d102b070bd0168e029fad10546fef7d2f9014628460029f3d0a278e3782679217842ea0322637942ea0642042942ea036604d16178002908bf0d2e1fd026f001010629ddd147f29120c0f246008047014628460029d4d04ff65914062e4ff00f034ff00006c0f24e044ff000004ff000014ff0000208bf0c2301960ae004204ff6591401900026c0f24e040020002100220e230096a047284602b070bd3146fff7a3bf00bfb0b582b00c460546fef782f90146002d4ff0000018bf002901d102b0b0bd47f2fc70c2f2070000684df6cb61c0f24501884790b10068e0284ff00000edd129784ff6591c0191c0f24e0c0021002223460090e047012002b0b0bd002002b0b0bd08b530460921fff7cbff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf08b530460a21fff7b7ff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf08b530460b21fff7a3ff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf01280bd1002908bf704710b5896804460846fef781f92046bde81040704700bf10b5059c4ff20340c0f2460080472146fff7e6ff10bd00bfb0b5c4b0044600284ff0000000f0c78089b20b2940f0c380207838b96078092804d1a078612801d1e07810b1002044b0b0bdfef7e5f80028f8d045f64d50c0f24600804701281cd00228efd103208df8070001200df107058df80800a81c21460b22f8f7cff94af66104c0f24604f02029460d220023a047b0fa80f0400944b0b0bd4ff29c50c2f22900006801466ff39601b1f1005fc9d101684ef66c62ccf2ff029142c2d14168b1f57d7fbed122797f21042a06dc012a0cdcbab1012a08bf00211ae0082a0bdc052a11d0082a08bf0a2112e0022a0dd0042a08bf01210ce0092a09d00a2a08bf0e2106e0092104e0022102e0032100e00b2180f80b1310216a2580f80c13a22180f80653152580f80e13062180f807531a2580f80f130c2180f80853132580f8101352210822022380f8095380f811134921012580f8042380f8053380f80a2380f80d3380f8121380f8135380f81453217900f5417280f815136179192380f81613a17980f81713002180f81813e17980f81913217a80f81a13617a80f81b13a17a4ff2250480f81c13c0f247040120e021a047284644b0b0bd00bf1fb5fff72bff002803d0bde81f4000207047bde81f4038b584b049f21f13c0f24703184710b5f0281bd1d1b1cab10c78032c16d10d2a1cbf0b2010bd487801281cbf0a2010bd45f64d50c0f246000c468047012803d1a01c0b21fff7fffe002010bdbde81040fdf785bc00bf002804bfa3207047017e427e837ec07e41ea0221184300064ff0a40008bfa320a4220a2928bf1046704700bf4ff29c52c2f229021268bff35f8f13466ff39603b3f1005f10d1d2f800c04ef66c63ccf2ff039c4508d15368b3f57d7f02bf0023c2f8fc32c2f8003347f2c942c0f24d02104700bf4ff29c50c2f229000068bff35f8f01466ff39601b1f1005f0fd101684ef66c62ccf2ff02914208d14168b1f57d7f02bf0021c0f8fc12c0f8001347f2d940c0f24d0000472de9f04184b0dde90a76022f16d340f64705a94212d08eb13578412d0ed175784e2d0bd1014602f0bf0012284ff00d0008bf002b0ed004b0bde8f0810c9d0097cde9016546f63916c0f24d06b04704b0bde8f081082feed3b078012802d1f078022803d90d2004b0bde8f081002953d045f6f444c2f2060414f8040c81424bd12068002848d048f22732c0f254020d4608460221904700283ed024682088d8b36088c8b3a088b8b3e088a8b330797179b279f37940ea012040ea024050ea0368d0d04ff29c50c2f229000068bff35f8f01466ff39601b1f1005f1bd101684ef66c62ccf2ff02914214d14168b1f57d7f10d1f178a1b190f8fc22aa420cd1d0f80023424508d101295bd1082faad100f09bf875e0f07818b1082004b0bde8f081082f9fd1f9f742fec8b10646d0f86c010028f1d047f64c61c2f207010968401a0128e9db96f8fc0268b196f8fd02032809d00628e0d1304600f076f8dce7112004b0bde8f08146f63917c0f24d0707f53a60804707f539622846214690470120002786f8fd020df10f02304600210123a6f8fe7286f8fc52c6f800838df80f70adf80c7000f07ef861884af2bd6603abc0f24c0628460222b047384604b0bde8f081a7f1510189b24ff6b87291424ff00d0119d390f8fd02032808467ff42baf334613f8080fa7f108018ab280b9052a0ed9a1884af2bd67c0f24c072846b847002004b0bde8f081084604b0bde8f08101280dd1042a0bd3981810f8021c00297ff420af10f8010c00287ff41bafe0e702284ff00d0008bf062a7ff4fcae707b01283ff60fafd4e790f8fd120a1f022a38bf7047022905d0012907d1042180f8fd127047052180f8fd12704780b582b0052180f8fd120121adf8061045f6f441c2f2060190f8fc0209684af2bd6c49880df10603c0f24c0c0222e04702b0bde8804070472de9f04fc7b0054690f8fc0203920591d8b145f6f041c2f206010978884214d148f22732c0f2540202211c46904760b195f8fc0240f66502c0f255020021904718b100690088172802d247b0bde8f08f033880b2f42828bff42007af0b3807f101084ff000094ff0000a01900495029414e000bf0699cde94509adf810112121adf8121143f23d5144a8c0f255018847049d029c1ffa8af0a042d6d2a4eb0a01019a1ffa81fbb5f8fe1241235a45b8bf93468df81c304e234a1c8df81d300123a5f8fe22d5f800238df81e30059b1ffa8af08df81f30130a8df82410090a8df820208df82130130c120e8df82510b0fa80f18df823204a091ffa8bf111fa8afaa2458df8223008bf0232bbf1000f8df826202fd001390329039901eb000c01d2002115e04ff6fc700bea00020cf10103002100bf5e1816f8014c7d187078ec725c5cb67804318a422c736873ae73f1d1049d1bf003020dd01cf80160cb19012ade7207d00ceb01004178022a19731cbf8078587395f8fc020bf10b0406900b2010fa84f649f6cd713046c0f24c01884700283ff47eaf26f003031ffa84fc06f003025e426ff00303c1180433f518043581f8049081f8059081f8069081f80790f2d152b10344012a83f8049005d0022a83f8059018bf83f806900bf10e0202701b22442108230272220480f801908170c370417283723ff43dafbcf1040f01d2002214e047f6fc710cea0103002200bfb95c8618f17218f8021008eb020531736978ad78043293427173b573f0d11cf003033ff41fafbe5c00f10b01012b8e543ff418af561cbd5d022b8d553ff412af0232bb5c8b540de7f0b583b04ff29c51c2f229010c68bff35f8f21466ff39601b1f1005f4bd121684ef66c62ccf2ff02914244d16168b1f57d7f40d194f8fc12e9b3002840d002888a423dd145f6f446c2f2060616f8041c8a4235d1316899b3356894f8fd12032919d8d4f86c1139b147f64c62c2f207021268891a00290edc02218df80b100df10b020746204600210123fff78dfe2046fff75cfe38468278092a1bd141896b8894f8fd72994217d1032f3adc012f6ad0022f3dd004e018b181780939022901d203b0f0bd47f6ed31c0f24d0103b0bde8f040084794f8fd72032ff1d8a2f10d0102290cd2c178d1b302208df8040001aa204600210123fff757fe03b0f0bd092a08bf032fdcd14189aa889142d8d1c078002800f0818002200df105028df80500e6e7052f04d0042fcad1c07805262fe0c078002848d0062084f8fd0202208df807000df10702204600210123fff72cfe052fb5d02046fff7f9fd03b0f0bd4268002aadd00389a3f2012189b2b1f57e4fa6d34089082b48d12988884245d12046012108234ce0c0780526002808bf022650b102208df80a000df10a02204600210123fff701fe6988012294f8fc024af2bd67adf8082002abc0f24c07022284f8fd62b84703b0f0bd052f15d1002094f8fc523668c4f8fc02c4f8000347f2c944c0f24d0404f11000804728463146224603b0bde8f0401047032084f8fd0201208df806000df1060272e7e98888427ff457af2046022103e0204603210022002303b0bde8f040bfe506290ad14178012907d18178653911f1630f02d3c178012902d94ff0ff307047f0b581b00179427941ea022540f6b8318d421fd80646fdf7edfbd8b1f9f724fbc0b10446d0f8d80342f66537c0f2440758b941f26f60c0f200007844012100220023b847c4f8d80320b107f1e8022821904718b14ff0ff3001b0f0bdb078f178d4f8e4230023c7f6e07340ea452003ea425240ea0120bff35f8f1043bff35f8fc4f8d403002001b0f0bd00bf02293cbf4ff0ff3070472de9f04f9bb00278437842ea0325b5f5007f04d94ff0ff301bb0bde8f08f4ef66c6a4ff29c56ccf2ff0ac2f229064ff6ff774ff0000b4ff07f090791099008e000bf48f2a3512046c0f24501bff32f8f8847d6f80080bff35f8f3468bff35f8f20466ff39600b0f1005f07d12068504504d16068b0f57d7f00f09a804ff47d70fef7c5fa002800f0928004464ff60c40cff6ff7000bf21182e3081f8f4b381f8f5b381f8f6b381f8f7b381f8f8b381f8f9b381f8fab381f8fbb381f8fcb381f8fdb381f8feb381f8ffb381f800b481f801b481f802b481f803b481f804b481f805b481f806b481f807b481f808b481f809b481f80ab481f80bb481f80cb481f80db481f80eb481f80fb481f810b481f811b481f812b481f813b481f814b481f815b481f816b481f817b481f818b481f819b481f81ab481f81bb481f81cb481f81db481f81eb481f81fb481f820b481f821b4a0d14ff47d7060600120a07347f67f70c4f800a0a4f8c40184f8c39127846784a784e78427856785a785e78527866786a786e78627876787a787e78756e8000f40457ff455afbff35f8f00bf46e8004028b156e8000f4045f8d049e70024ddf824805db1fdf7d2fa0146002c4ff0ff3018bf002902d11bb0bde8f08fb5fa85f040094ff000098df82c908df82d908df82e908df82f908df830908df831908df832908df833908df834908df835908df836908df837908df838908df839908df83a908df83b908df83c908df83d908df83e908df83f908df840908df841908df842908df843908df844908df845908df846908df847908df848908df849908df84a908df84b908df84c908df84d908df84e908df84f908df850908df851908df852908df853908df854908df855908df856908df857908df858908df859908df85a908df85b908df85c908df85d908df85e908df85f908df860908df861908df862908df863908df864908df865908df866908df867908df868908df869908df86a908df86b90bcb1d4f87021a2b14ff4006304e03f683b44b3f5403f0cd2d718be680136f6d07e68033626f0030609eb060101f11009ede7002d4ff0020a039500f00581ddf81cc0acf102020a2ac0f00081002608eb0a0b9bf801504ff0ff30012d3ff648af9bf802209bf803309bf8047042ea03229bf8053042ea074747ea0361a1f1011212f5803f0a91fff433af9bf808109bf809e0029141ea0e210af10a020497aceb02034f1e9f42bff423afcde905269bf806209bf807300a9e42ea032cb6eb0c07fff416afb9423ff613af18f80a70089147ea052a4feada000ba90e5c07f00705012707fa05f5354240f001830e5c45ea06050d5407994ff6ff75c0f20205b4b3d4f8700198b317461a0201924fea0e264ff4006200eb0208d8f8083053454bd0d8f800301a44aa4221d800eb0208d8f80830534540d0d8f800301a44aa4216d800eb0208d8f80830534535d0d8f800301a44aa420bd800eb0208d8f8083053452ad0d8f800301a44aa42d3d900bfbcf1000f40f0bc8204980a464ff6fc710330c0f2030108404844944600f1100908980599069e00eb010a0398013686424ff0000028bf0120ddf824804fd2aceb0a02092a3ff64caf49e0d8f804000a9a904240f09582d8f80c006045c0f0908236d9089aa0eb0c00824200f289827ab3029831180198c1f1000cc2199044a1f1010e002208eb02050beb0203287c9e7ab04240f0758296451cd06e7cdf7abe4240f06e820ceb0207be1c13d0ae7c187b864240f06582079ef81c07d0e87c5b7b984240f05d8204329142dbd1b446a7e78c46a5e7ddf81cc0a2e7ddf81cc0002800f04e82baeb0c004ff0000118bf0120b9f53e3f88bf0121014303980028c1f100003ff43eae00297ff43baed4f870b1bbf1000f40f08b804ff44030fef754f8002800f02d82834600206ff0200100220beb02030bf8020040320beb0107b2f5006f01f1400158709870d870187158719871d871187258729872d872187358739873d873187458749874d874187558759875d875187658769876d87618775877987787f8400087f8410087f8420083f8220083f8230083f8240083f8250083f8260083f8270083f8280083f8290083f82a0083f82b0083f82c0083f82d0083f82e0083f82f0083f8300083f8310083f8320083f8330083f8340083f8350083f8360083f8370083f8380083f8390083f83a0083f83b0083f83c0083f83d0083f83e0083f83f0093d14ff43e30cbf800080020cbf804084ff0ff31cbf80c084ff40060c4f870b1cbf80818c4f820034ff6ff760221c0f202064ff000090ae00aeb080109f10109ddf8248099454ff000003ff497ad08eb010518f801006f78cdf81c900a9195f802c0eb7895f804906a7995f806a0e97995f808e06d7a40ea072808955cb3012f29d84ff400670beb0705a868404500f0a28028680744b7421dd80beb0705a868404500f0988028680744b74213d80beb0705a868404500f08e8028680744b74209d80beb0705a868404500f0848028680744b742d7d94cea032040ea094040ea0267f81c20f00300d4f82093cdf818a000f1100a0020cde904e10297b9f1000f26d00beb09035bf809105a68514580f09b80eab10beb02005bf80210d0f80490514580f08c80b9f1000f11d00beb09035bf809105a68514580f0868042b10beb02005bf80210d0f804905145d6d376e000204ff400694ff4006504e000bf3d44b5f5403f23d20beb05018a685bf805700132f4d04868ca68033020f0030000f110060beb09001032f7f711f94168c2684bf809608368d4f870b18a424ff00001b14408bf00f110014bf82310d7e7c9f540310f294ff00002c4f8202310d90beb09004bf809104ff0ff3142608160c260c4f820930ae0e868039b0a9a089f60e010b10268114401604ff000090020b9f1000f7ad00beb09035bf809105a68514522d2002a71d00beb02005bf80210d0f80490514513d2b9f1000f66d00beb09035bf809105a6851450ed2002a5dd00beb02005bf80210d0f804905145d7d30546cc469146184601e01d469446a1eb0a0110290fd309eb0a020beb02034bf802104ff0ff31c3f804c0996000219446d960c5f800a0039b0a9addf818a0dde904e1089f00280cbfc4f820c3c0f804c002984ff6ff7668600020c0f20206c5f80880e8604aea0121ddf81c904eea072a814202f10a087ff4c0ae05f1100778180999524641449b46f7f726f8e9685b466868aa68d4f870b15144e96081424ff0000018bf07464bf82270a6e600204ff400684ff4006703e02f44b7f5403f23d20beb07018a685bf807500132f4d04868ca68033020f0030000f110060beb08001032f7f745f84168c2684bf808608368d4f870b18a424ff00001b04408bf00f110014bf82310d7e7c8f5403200210f2ac4f820130dd90beb08034ff0ff304bf8082059609860d960c4f820831bb0bde8f08f00281ebf0168114401604ff0ff301bb0bde8f08f00bf02293cbf4ff0ff3070472de9f04f8bb00278437842ea0325b5f5007f00f2f08005eb4502022303eb4202914240f0e8800590fcf7abfe002800f0e2804ef66c694ff29c56ccf2ff09c2f229064ff6ff77002447f67f784ff07f0b06e048f2a351c0f24501bff32f8f8847d6f800a0bff35f8f3068bff35f8f01466ff39601b1f1005f07d10168494504d14168b1f57d7f00f096804ff47d70fdf7d0fd002800f0af804ff60c41cff6ff7100bf42182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ff47d7141600121c0f800908173a0f8c48180f8c3b1078447848784c784078547858785c785078647868786c786078747878787c78756e8001f51457ff459afbff35f8f00bf46e8000121b156e8001f5145f8d04de7d0f870c10495bcf1000f20d000234ff4006104e03f683944b1f5403f0bd20ceb0107be680136f5d07e68033626f0030633441033eee775b9b3f53e3f40f2e0804ff0ff310bb0bde8f04f08467047002d00f0d680002305994ff0000901f1020a153103914ff0ff31059109eb49060aeb46056c784ff0ff31012ce3d8af78ea7857ea022e1ebf2a796d7952ea0528d9d0bef5207fd6d8b8f5f07fd3d80ef10102520802fb08fb4ff6fb724ff6ff779345c0f20207c6d81af81610059e41ea0421039cb9f1000f28d014f8132c14f8125c42ea05228a42b3d0feb114f80d2c14f80c5c42ea05228a42aad0012e15d014f8072c14f8065c42ea05228a42a0d0022e0bd014f8012c257842ea05228a4297d0043e721c04f11804d6d15646bcf1000f2fd00bf105054ff400640ceb040adaf808208a4230d0daf800201444bc4220d80ceb040adaf808208a4225d0daf800201444bc4215d80ceb040adaf808208a421ad0daf800201444bc420ad80ceb040adaf808208a420fd0daf800201444bc42d3d94ff6fc720bf10801c0f201021140194401f1100320e0daf80410a9427ff44fafdaf80c10a9427ff44aaf9af8101004297ff445af9af811109af8122041ea022171457ff43caf9af813109af8142041ea022141457ff433af049909f1010989450599b24601f1010105917ff43dafb3f53e3f3ff624af00240025019019e000211fe7d0f870c14a688b684ff6ff7793454ff00002c0f20207c1f80cb008bf01f110024cf82320013575454ff000013ff408af05eb45000aeb40011af8100091f8018091f802e091f803b091f804904979bcf1000f40ea082605912cd0b8f1010f29d84ff400610ceb01039a68b24200f0a8801a681144b9421dd80ceb01039a68b24200f09e801a681144b94213d80ceb01039a68b24200f094801a681144b94209d80ceb01039a68b24200f08a801a681144b942d7d94eea0b21059b013149ea0322490801fb02f75a4607f1050b8df81d004fea1b208df820004fea1b408df8210005208df82500042001218df8270048468df81b1003908df82a000df11b0011218df81c408df81e808df81fb08df822408df824408df823408df82640cdf808e08df828e091468df829208df82b30fff797f800287ff482ae01980021d0f870c1bcf1000f3fd0ddf810e0b8f1010f3cd84ff400630ceb03018a68b24235d009680b444ff6ff71c0f202018b4226d80ceb03018a68b24228d009680b444ff6ff71c0f202018b4219d80ceb03018a68b2421bd009680b444ff6ff71c0f202018b420cd80ceb03018a68b2420ed009680b444ff6ff71c0f202018b42cbd9002104e0ddf810e02ee7ddf810e0002f3ff41aaf4fea0922029f059b42f001023a44039f1b0252083b4353435a1e032a01d200220ae023f0030700228e18043297427475b475f4753476f7d113f003033ff4f8ae01f11507012bbc543ff4f2ae3a44022b547018bf9470ebe62de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010a47f67f7b4ff07f0807e000bf48f2a351c0f24501bff32f8f8847d5f80090bff35f8f2868bff35f8f01466ff39601b1f1005f07d10168a14204d14168b1f57d7f00f094804ff47d70fdf7f2fa002800f005814ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ff47d710460416080f80ea0a0f8c4b180f8c381068446848684c684068546858685c685068646868686c686068746878687c68755e8001f49457ff45aafbff35f8f45e8000121b155e8001f4945f8d04fe7d0f88813002974d104464ff41630fdf759fa014600284ff0000069d0002200bf8b1888544032b2f5163f58709870d870187158719871d871187258729872d872187358739873d873187458749874d874187558759875d875187658769876d876187758779877d87783f8200083f8210083f8220083f8230083f8240083f8250083f8260083f8270083f8280083f8290083f82a0083f82b0083f82c0083f82d0083f82e0083f82f0083f8300083f8310083f8320083f8330083f8340083f8350083f8360083f8370083f8380083f8390083f83a0083f83b0083f83c0083f83d0083f83e0083f83f009ad1c4f8881300e00021084601b0bde8f08f00bf2de9f04f93b04ff6ff75a9424ff0000c2cd0dde91c874ff4805ecde90aecd0f89ce3cde90087229fdde920a9dde91e6b249c0697239f0aadcdf840c0cde911eccde90845cde9026bcde904a90546079704f0b8fe84464cb1bcf1000f06d19df8480095f8a013084385f8a003604613b0bde8f08f2de9f04f93b00446002047f64c65a4f8a003c2f207052868002a89461abfc4f894030146d4f89413401ac4f89c03fcf739fa002800f05a81d4f88803002800f0558104f0e7ff002800f050810646b4f88c03002853d0a0f10108d4f89c0300254ff4a0714ff4f0774ff4805acde911050df1280bcde901152046414632464ff42073cde90aa51095cdf824b0cde90755cde90555cde90355009704f059fe002840f02481d4f89c034146cde91105012008904ff4a0700190204632464ff420734ff4f077cde90aa51095cdf824b0cde90655cde90455cde90255009704f038fe002840f003819df8480094f8a01347f64c65084384f8a003c2f2070506e0d4f8881330464ff41632f6f7cefa4ef66c684ff29c57ccf2ff08c2f229074ff6ff764ff0000a07e000bf48f2a351c0f24501bff32f8f8847d7f800b0bff35f8f3868bff35f8f01466ff39601b1f1005f07d10168414504d14168b1f57d7f00f098804ff47d70fdf7f6f8002800f0c4804ff60c41cff6ff7100bf42182e3182f8f4a382f8f5a382f8f6a382f8f7a382f8f8a382f8f9a382f8faa382f8fba382f8fca382f8fda382f8fea382f8ffa382f800a482f801a482f802a482f803a482f804a482f805a482f806a482f807a482f808a482f809a482f80aa482f80ba482f80ca482f80da482f80ea482f80fa482f810a482f811a482f812a482f813a482f814a482f815a482f816a482f817a482f818a482f819a482f81aa482f81ba482f81ca482f81da482f81ea482f81fa482f820a482f821a4a0d14ff47d7141600121817347f67f71a0f8c4117f21c0f8008080f8c311068446848684c684068546858685c685068646868686c686068746878687c68757e8001f59457ff456afbff35f8f47e8000121b157e8001f5945f8d04be7064604f0bffe002e18bf002803d1012089f8050022e0c6f864014ff0010a4ff4f07086f868a101904ff420704af61f4c0090c0f2470c00200021002200230027e04730b186f86871c6f8647189f805a004e099f8050089f804a030b14ff0ff3013b0bde8f08f0026cbe794f8a00384f8a10338b3d4f8900342f66536c0f2440620b129682d31c4f8981310e044f6dd70c0f200007844002122460023b047c4f89003296801f12d01c4f8981320b106f1e8022d21904728b1002084f8a10313b0bde8f08f002013b0bde8f08f80b582b04ff4f0704af61f4e01904ff4207cc0f2470e0020002100220023cdf800c0f04702b080bd022a3cbf4ff0ff3070472de9f04fadf2345d239008784f780a4450ea072001f10207249002f04483259300232292974202f03883781c904202f0348338787978be1c40ea0121901b81422c962f9102f229832598ddf880253690ddf85805ddf878153790ddf85c053f913890ddf8600527933990ddf864053a90ddf868053b90ddf86c053c90ddf870053d90ddf874053e901068411e0028116002f003832f98002802f0ff822f98841c032c02f0fa82fe78072e02f2f6822c9890f80090f00702d107f1040e27e02f9820f00100022802f0e88297f804a07d7923984aea052b594636aa02f0ecfa002842f0db82ddf8640507f1060e012d3a900dd8ddf88005806948b14feadb020af00701835c012505fa01f119438154b00707eb0408cdf8a08005d44ff0000a042e29d2a1e000bfc64505d01ef9014b4ff0000af34603e000244ff0010ac34645f64d55c0f24605a847012808bf0134601e81b2670800ebd130002c48bf4710a84701283a9808bf7f42ddf8a0803844de463a90042e78d3baf1000f42d1c64540d0724612f8011b3a9842453dd09ef801200ef10203120642ea0141434500eb214c3ed00ef103029ef80210424534d09ef803200ef10403120642ea014143454fea214129d00ef105039ef80420434500f0ac869ef805700ef10603434542ea072200f0a3860ef107079ef80630474501f0dc829ef807700ef1080e3f024ff0000a15e03a98002100e0c64600eb010c4ff0010a0022002108e04ff0010a002203e04ff0010a00220021c646002300273b433b9f62440b447fb1dde93c76dde93e40bc45d8bfbc46b142d8bf3146a242a8bf22468342a8bf0346ddf8a0800120cde93cc1cde93e233b90baf1000f42f01582b9f1040f40f38380b9f1060f40f3f380b9f1070f00f0b982b9f1080f00f06c81b9f1090f42f00182c64502f0fe811ef801abc64542f0f981baf10f0f02f2f581ddf87c05002801f078833b993698dde93829002900f029863799dde93d733f9e994227eae775b8bf0b46b242b8bf1646b542359681f261833c994fea630c21eae17b4fea0a11339135990bf10104491b4fea5b0e4aea0a1211f003084fea54013494329100f0f7869b4581f2638205fb09045feacb7171465e4609d014f80e10349e01f0f00141ea0a0104f80e10329961452144319681f23f8204eb0c060c4604f8012bb44281f039828f1cb7424a7081f03582cf1cb7428a7081f030820f1dca70b7423946ead301f029ba00bfb9f1020f37dcb9f1010f00f06f81b9f1020f42f083813698dde937763490ddf88005dde939a1dde93b45dde93d32ddf8fcb0c0694ff00009c645cde946e8cdf820914290cdf80c91cde92a32cde928152e9400f07c820ef1010046909ef80090404500f074820ef1020046909ef80100b84604026fe2b9f1030f00f09681b9f1040f42f04b81dde936c0dde938633490ddf88005dde93aa2dde93c74dde93e59c0694ff0000bc645cde942e8cdf810b14090cdf804b1cde9323c3596cde92d74cde9305200f0af820ef1010042909ef800b0404500f0a7820ef1020042909ef801004fea0028a2e2b9f1050f00f0fa81b9f1060f42f01281c64502f00f810ef10100404502f00a810ef10200404502f005810ef10300404502f000810ef10400404502f0fb800ef10500404502f0f6800ef10600404502f0f1800ef10700404502f0ec800ef1080ca8eb0c001028c2f0e5800ef11800404542f0e0809ef804009ef8051050ea01261ebf9ef806009ef8071050ea012502f0d1809ef800009ef80120379940ea0224081bc2f0c780864202f2c4809ef802009ef80330389a40ea0327d01bc2f0ba80854202f2b780ddf87c05002801f03a8239980df1e80e369b34909ee8014fcdf8d4e0cde906478de8010f1846dde93437cdf828c0cde90865059704f0d7f801f021ba36983999339037983591349038983a9931904046cde94ee0ddf880053291c06900214eac46aedde93b7bdde93da5ddf8fc805091cde946012046314602f03ffb81462046314602f03afb5099002940f0ac82dde94ec2cdf8c080944500f0a5820cf10101914200f0a0820cf10201914200f09b820cf10301914200f096820cf10401914200f091820cf10501914200f08c820cf10601914200f087820cf10701914200f082822d909cf800009cf804102b909cf805003b4628900cf108005e46d646cdf8a8909cf801b09cf802709cf8039029919cf806a09cf80710a2eb0008b8f1010f2e9141f0fe80904200f05d829cf808100f2900f258820cf1090001f0f3b8c64502f01580724612f8010b012802f20f80369900283091dde93751359139993191dde93ac134913c992d913d992b913e992a913f99299100f0d982424501f0f7870ef10202424501f0f2870ef10302424501f0ed870ef10402424501f0e8870ef10502424501f0e3870ef10602424501f0de870ef10702424501f0d9870ef10802424501f0d4879ef801209ef802309ef8046042ea03239ef803209ef805409ef80610774642ea062e44ea012af9793a7a07f109041a9441ea0221b8e2a8eb0e06052ec1f0b4870ef10505454501f0af870ef1060b9ef80540a8eb0b00a042c1f0a6870beb0400404541f0a187369820903798359038982a9039981f90dde93a9034903c9831903d983290dde93e803390ecb14ff0000a04e000bf0af1010aa24515d21bf80a0001381e28f6d90beb0a00a4eb0a014eaa46ab774602f07cfe002801f075874e98be468244a245e9d3ddf87c05002801f0f3803498cdf8c090f146002800f0b283319820eae0703190329820eae070219035984045a8bf404635902a9833998842a8bf08462a90a0e3c64501f04d870ef10100404501f048870ef10200404541f04387704601784078dde93b5441ea0021ddf880050df1d80c0990ddf87c059ce80c10089004a8dde93976ddf8f490ddf8f8e0ddf8fc8080e810422398cde900c7cde90265cdf81c8004f0b2f8074659e1ddf880050df1f00adde936c1dde93853dde93a629ae89004ddf8fc90c0694ff0000bc645cde946e8cdf820b14290cdf80cb1cde9323ccde93451cde92d47cde93062cdf8ac9000f022810ef1010046909ef800b0404500f01a810ef1020046909ef801004fea002815e10120b8464890002446ad42af2846394602f0a3f935902846394602f09ef9489907460029cdf8b4b0cde9324a00f0148144460025002031900120bb464890002046af0df5847a30903846514602f085f980463846514602f080f94899002940f0f2800346dde946014ff0ff37884240f0ec80ddf8d4e0bef1000f00f1e680bbf1000f00f1e280ddf880254398116a329f08431062349847ea09074e904ff6fe7087423398dc46a246b3464f945096519000f0e5834ff6ff70874240f0c1832398d0f888934ff420704f904ff4f07050904ff4a0705190d4e3012044904ff0000842ac40ad2046294602f037f906462046294602f032f94499002940f0a480dde94212914200f09f8011f8014b914240f09a80ddf8803541991a6a1143239a1962002a00f09080d2f870114ff0ff37002900f08b8048ea0b030022b2eb532f40f0848051f82320002a00f07f80a2eb010e5fea8e7279d16ff4403240f60f057244cff6fd75aa4270d301eb0e0c5cf8081c99426ad15cf80c1ca1f1011212f5803f63d3bcf1000f60d05cf8042c8a425cd1cef54032914258d82b90ddf880051d46806950b1eb080bf0070e10f80380012202fa0ef242ea0802c2546046002246ab01f061fe00284ff0000708bf4ff0ff373bd0ddf87c05c0b3a6f1011010f1021f4ff0000731d92b98a0f1011010f1021f2bd93198002300284e9301f07f822d98349920eae0722e9820eae07330988142a8bf0146359834914845a8bf4846359001f06dba012048904ff0000846af42ac3846214602f091f881463846214602f08cf8489951b34ff0ff37229a279b002f00f0478701f0bbbddde9460188423ff4e7ae024612f8015b8a42469200f0bf82821c469243788a4245ea032500f0b782c21c469283788a42319300f03486011d4691c078bb4644460002d1e6dde946218a42d0d0134613f8014b8b42cbd0951c56784a1bb2424ff0ff37c6d3aa198a42c3d1ddf8803543991a6a1143239a1962002abad0d2f87021002ab6d048ea0b0e0021b1eb5e2fb0d152f82e100029acd0891a8b07a9d16ff44033bc4640f60f070b44cff6fd77bb4267469ed3531853f8082c724597d153f80cccacf1011212f5803f90d328aa002b4ff0ff3782e8604026903ff48aaf53f8040c60457ff485afc1f540302a9984453ff67fafddf880051d468069664640b1ca080bf0070c835c012101fa0cf119438154c12efff46daf287801287ff469af2998002801f02380dde928b8a5f13f0700f0bcbf424501f01e850ef10202424501f019850ef10302424501f014850ef10402424501f00f859ef801209ef80260714693004fea460eca780e7905314fea820a1a917100baf1000f1b9101f0fb841b99002901f0f784ea1ac1f0f484924501f2f1843599b1eb0e02c1f0ec841b99914201f2e884349903eb0c06084301d000230be05feacc704ff0000306d1002e04d40aeb0600a842d8bf01231a9f1b9aa8eb07001890ddf87c0502fb0af9b0fa80f0400918430024c0074ff0000b19931f902e95cdf8709022e0dde9303002fb003c4a081cf80230339803f00f0803f0f0030344c907329808bf48ea0003ddf8a0800cf8023026988344dde9200181424ff0000088bf01200443e00708bf0f44e10704d0d94507d801f095bc00bf474518bfd94540f2a281b8eb070001f08b8439780b0901d0012211e0012801f083847b780bb102220ae00428c1f07c84ba78fb7852ea032301f07684042200bf2192a9eb0b02934201f26e8420901f9826930028c0d101f00f003390269809010128cde91d7432912dd14ff0000c2698ddf8a0801e9cdde91c97c007acd00ceb0b00b0fbfaf101fb1a0001eb0e02811952ea0100a0d4a9429ed2359882429bd2349800283ff482af2d98814294db2b98824291db2a988142bff68eaf29988242fff674af88e720f001014ff0000c16e0dde93030339f04fb00305308c45cd20704f00f0504f0f0043c44329a08bf45ea02042e9dc4540cf1020c6145b7d00beb0c02b2fbfaf404fb1a2704eb0e0907eb060859ea080427d4a84525d23598814522d2349858b12d9880451ddb2b9881451adb2a98804517da2998814514dadde930304fea580709fb00343398e35d03f00f0503f0f00303445feac870329808bf45ea00032e9de355501cb0fbfaf202fb1a0002eb0e04821954ea0200bbd4aa42b9d235988442b6d234980028a0d02d988242b0db2b988442addb2a988242aada2998844294dba6e70aeb0a1109fb02f2f5f7cefa00f040bd00234ff0010ac646fff77bb9002021903190052e01f0ac832098002801f0a883fbf7e4f8002801f0a38395f800a00af10600864241f09c8347f65420c2f207000768002f01f09483387b797bba7bfb7b40ea012040ea024040ea0365a5f1810010f1800fc1f08483387c797cfa7c40ea0120b97c40ea014040ea02601490813810f5817f41f27483baf1000f4ff000001b97339077d04ff0000e00270ae000bf00f100404ea941f826000137574506f1010e17d21bf807007646411e1e29efd90beb0700aaeb070146aa42ab02f054fa00283ff489ad469942984eaa0f4442f82600e3e7bef1000f329500f0df80aef1010b4ff0000a4ead09e0be46d3450af1010aa6f1010605f1040500f0cd804ea850f82a100029f1d40020534686421dd005eb80077a68b2f1ff3f18dc5a1c934514d0ba68b2f1ff3f11dc9a1c93450dd0fa68b2f1ff3f0adcda1c934506d03a690433002a00f10400e0d400e000221b9846ab42ac7746009402f092fa00283ff43bad42980028c0d04af20d3146a8c0f24e018847b9e7329501204ff0000e90e04446fff720bc474508bfd94541f0e882ddf87c05002818bf012019990840012840f06684dde9300318990efb03004fea5a0700eb56021b98009701901a9801f09ffb002840f0548401f0caba2f4600f04abc239839464eaa1e46644601f0cefa00287ff4f9acddf88005ddf8d4e08069a446334660b10021b1eb572f08d1fa0809f00701875c012606fa01f139438154ddf838912a46b9f1000f3ff4ddac002a4ff0ff371cbfdde9301050ea01003ff4d5ac4f997145fff4d1aca1eb0e018a423ff6ccac50996145fff4c8aca1eb0c0188423ff6c3acddf87c15002700293ff4bdaca8f101111d4611f1021f7ff6b6ac2e99002900f02b85299921eae1732a9921eae1742b998a45a8bf8a462d998b45a8bf8b4600f01dbd002002e04ff0000e012099f804200f21950602f00f0601eae575754389214d43ed0a99f800c08df808510e2599f801a099f8023099f80370349212f0200f08bf012506fb05f501fb05f54fead5258df809514ff00d0508bf022506fb05f501fb05f54fead5258df80a514ff00c0508bf032506fb05f501fb05f54fead5258df80b514ff00b0508bf042506fb05f501fb05f54fead5258df80c514ff00a0508bf052506fb05f501fb05f54fead5258df80d514ff0090508bf062506fb05f501fb05f54fead5258df80e514ff0080508bf072506fb05f501fb05f54fead5258df80f514ff0070508bf082506fb05f501fb05f54fead5258df810514ff0060508bf092506fb05f501fb05f54fead5258df811514ff0050508bf0a2506fb05f501fb05f54fead5258df812514ff0040508bf0b2506fb05f501fb05f54fead5258df813514ff0030508bf0c2506fb05f501fb05f54fead5258df814514ff0020508bf0d2506fb05f501fb05f54fead5258df815514ff0010508bf0e2506fb05f501fb05f54fead5258df816514ff0000508bf0f256e434e43f60a00288df8176140f024824fea0a6242ea0c41309a380602eb214b329940ea0340ddf88480ddf86ca0aef1010501eb204000261390cdf85ce0159507e001f01f000b3801367645834400f0f8814ea850f82610b1f1ff3ff1dd33469d421cd04ea800eb83004268b2f1ff3f16dc0133ab4212d08268b2f1ff3f0fdc0133ab420bd0c268b2f1ff3f08dc0133ab4204d002690133002ae1d400e00022504646ab40af009702f0d5f8002800f0d081409900291d9100f0ba819df820019df82111189650ea0125cdf868b000f09f819df824719df825613f0447ea0667149e9df81f019df81e112e444fea002c41ea00229df8220106eb2747139e9df823310004f71b1a9e40ea03604ff0010e06eb204b28920eeb520203141c920ceb010201f003000bf1010119910bf1020116911d992d97571e1e97f718f31a01312990101a2e910eeb5201319a3390d8074ff000093290f8072b913090269509e000bf2e982b9909f10109a94508442e9000f04e812d9809eb00034345f1db2a988342eeda28980028ebd0dde91f104ff0000a03fb01071e98032880f09c802998ddf88480269d0028dbd0dde91c10012309fb010c34984fea5a011cf8011000f0100083ea1014c8b201f00f035feaca7e08bf03091846002b18bf01202043012815d10aeb0b06964211db359886420eda7008395c42adeb5c01f00f0501f0f0011943f60708bf45ea0311269d395429980128a6d00af1010040081cf80000bef1000fc1b24fea111808bf00f00f085ffa88f0002818bf01202043012817d119980aeb0003934212db359883420fda5808395c42ae16f8086001f00f0501f0f0013143db0708bf45ea0611269d39542998ddf8848002283ff474af0af1020040081cf80000bef1000f00f00f03c1b208bf0b091846002b18bf0120204301287ff460af16980aeb00069642fff65aaf35988642bff656af7008395c42adeb5c01f00f0501f0f0011943f60708bf45ea0311269d395445e7ddf8b8c008e000bf33980af1040a50450cf1020c3ff458af34981cf8016c00f010030120f6b2002580ea13130f2e88bf01251d43012d0beb0a0815d1904513db3598804510da4fea58053609795d42a8865d01f00f0401f0f00131435feacb7008bf44ea061179551cf8010c10f00f0e704618bf01201843012818d108f10106964214db3598864211da7008395c42aa12f80e6001f00f05329c319a45ea061501f0f001002c08bf41ea06053d549cf80000c6b200200f2e88bf01201843012816d108f10205954212db359885420fda690830097e5c42ad285c06f00f0506f0f006309c0643002c08bf45ea00167e549cf8000010f00f06304618bf0120184301287ff481af08f103039342fff67caf35988342bff678af5808395c42ab9b5d01f00f06329d46ea031601f0f001002d08bf41ea03063e5466e74af20d3146a8c0f24e0188479df81c019df81d11dde91aba159ddde917e605e09df81c019df81d11ddf85ce040ea012002e6002007e000274ff0010ac646fef73cbd4ff0ff303390339ffff7aab94446fff79eb80f4600e04f1cd90708d03199994205da3978339c01f00f0121433970b8f1010f05f1010700f0d8809b4580f2968007fb09045feacb7171465e4609d014f80e10349e01f0f00141ea0a0104f80e10329961452144319614da04eb0c060c4604f8012bb4426dd28f1cb7424a706ad2cf1cb7428a7066d20f1dca70b7423946edd360e00f465ee0102190427ff45ea92b9ab84652ea0b2c4ff0ff373ff458a958ea092226923ff453a9bcf5207f3ff64fa9269ab2f5f07f3ff64aa9baf10f0f2191cdf87ca03ff643a92e9910293ff63fa9ddf88005479a016a1143ddf87c250162002a00f08a8332992a9a614449428a42c0f283833499329a0027891a2a9a8a42bff625a926992d9a49428a42fff61fa92d9a31988242bff61aa9002b00f0858326eae671209134992eeaee7ea942a8bf2946dde9303034919842a8bf1846319077e34f1cd90708d03199994205da3978339c01f00f0121433970b8f1020f05f1020739d09b4536da07fb09045feacb717146d8460ad014f80e10ddf8d08001f0f00141ea0a0104f80e1032996145214414da04eb0c060c4604f8012bb4420fd28f1cb7424a700cd2cf1cb7428a7008d20f1dca70b7423946edd302e00f4600e04f1cd90707d0984505da3978339c01f00f0121433970ef1c3599691a11f1040f11d9229a279b2498013383422c982f9900eb01077ef432ab00f071be00bf359904378f42edd09b4539da07fb09045feacb7171465d4609d014f80e10349d01f0f00141ea0a0104f80e1032996145214418da04eb0c060c4604f8012bb44280f0cd8001f10208b0454a700cd201f10308b0458a7007d201f10408ca70b0454146e9d300e08846d90709d09d4207da98f80010339c01f00f01214388f800109b4536da791c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c04314601f8012ba14280f09580b11ca14272700ad2f11ca142b27006d2311df270a1420e46ecd300e03146dc0707d09d4205da0c78339d04f00f042c430c709b4536dab91c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c0400bf314601f8012ba14260d2b11ca14272700ad2f11ca142b27006d2311df270a1420e46edd300e03146dc0707d09d4205da0c78339d04f00f042c430c709b45bff64baff91c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c0400bf314601f8012ba1422ad2b11ca14272700ad2f11ca142b27006d2311df270a1420e46edd300e03146dc073ff41baf9d42bff618af0c78339d04f00f042c430c7010e701f10108d9077ff442af4ae7711cdc077ff478af7ee7711cdc07acd1b3e7711cdc07e3d1fde6b8f1010860d01bf8010b411e1f29f7d341b22029fef698af07eb400117f81000497840ea0122c12afef48eaf284631464eab00f0a9fd0028e2d1fef785bf002400235345b8bf5c45bef680af289908eb01065645bef67aaf5d45bef677af991a8e427ef773af211a8d427ef76faf9f1b1946b8bf3146b342e0464ff0000cd8bf6746be44d31b671bd8bf6746c61ba542aaeb0100c8bf2c46834238bf1846abeb04039e422e9328bf1e46349b2b96994507eb080329932d9442d1299b2d9f9f422fdd4ff0010c3be0ddf87c05002800f09381a9f1011010f1021f4ff000077ef635af2698a0f1011010f1021f7ef62eaf3198002300284e9300f0cf842d9820eae0722e9820eae07335985045a8bf5046359034982b998842a8bf0846349000f0bdbc299b2d9f7145a7eb0303b3fa83f34fea53134ff00007c8bf012703ea070c2b9b002b00f058814ff0040a2aea8e071a970eeb000743184fea5e06013f01f0010203f001041b967e0819962aea8706171918963294c61bdde930745018274435920eeb02048eea01024908179159082d9b169179192e9dc91a4fea560ba94238bf0d4601212e95bbf1010f88bf710801f0030321f00301129161082691410821913499159301eb5000411c03381490d00720904ff0ff3000eb56002a906ff0010009eb540300eb56002890981e13906ff00200ddf844e11c9600eb5600339e4ff00008109111931f90cde91dec08e02e9808f10108339e80454ff000073ef495ae6fea08014046bcf1000f2b9a18bf50182999359b421802fb0e910bb9002305e01b9b1a9ccb5ce34003f00f033193329b0bb9002304e0199b189ccb5ce3401b0130932d9b209f03443498002f03fb060a2198269f504439441cd15a46f4f7b3fadde91dec359840b11799319a1af8010000f0f00010440af8010032980028b6d01699309a1af8010000f00f0010430af80100ace703fb06f4bcf1000f02fb0ef23ed01c980228ddd31398149910442144002200eb0b039c785f782a9dc4f3031444ea071701eb0b049542a770cad05f7810f80b50c7f3031747ea0517289d67709542bfd010f80b7013f8015cc7f3031747ea05171f9d01f80b709542b2d013f8017c13f8023cc7f30317043247ea031304389345a1f1040104f8013cc9d1a1e71c9b022b9ed31c9b082b01d200222be0119bddf848e003eb020c109a144400220ceb02077d781cf80260c5f3031545ea0616a51805f8016cbe787b78c6f3031646ea0313a354fb78be78c3f3031343ea06136b703b79ff780432c3f3031343ea07139645ab70dbd1159bdde91dec002b3ff468af531ccf5c8e5c159cc7f3031747ea0617012c87543ff45caf941c0f5dce5c159dc7f3031747ea0617022dc7543ff450af0a44d278095dc2f3031242ea0111015546e70027fef7a7bd00224ea8cde905402b9806eb0a0104903598cde902510190dde93210349f009701f089fb0746fef792bd00214ff0000e2091dde9280141ea0021b1eb5c0f28bf4fea5c01269ab1eb520f28bf51081c91013938bf394610912d99beeb0104d8bf3c463198411a9142a8bf11468c421e91bef66dad28984fea092a4fea002932982a994fea0b230f181c9920984a004943890028921b918742c8bf3846349d0ceb0702aa424ff000012a92b8bf1546bcf1030f38bf0121269e0022032e38bf012211431a91410819912b990aeb080219444b08b3eb520f219b1d9000f1010c4fea031015904fea520243ea031038bf4a08149029986910484429951891824228bf0246109b4ff0000a03fb03f080000d906ff0080000eb420016902d987045c8bf8646339835992b9701fb0e002e99309000203290701e1790b01e139058001290781c119008010f9041ea011026460e904fea5c00cdf830c00b9010e001780f9a01f00f0111430170359c319e30980136204430901e9800278642bef6e8ac2699f04308448642b8bf304628996fea400008440128319638db1b994ff0ff3200fb10101c99a1eb0a01012902eb41013bdb01fb01f2824237dd1699a1eb4a0202f10803032b02f1060126db01fb01f7874222dd052b02f1040121db01fb01f787421ddd072b02f102011cdb01fb01f7874218dd0af1040a092ba2f1080103db524382420a46dbdc08310ee02d983399359c219a4ff0000a39e00af1010a04e00af1020a01e00af1030abaf1010f29db08318a1f5243824224dcbaf1020f16db0a1f5243824215dcbaf1020f0fd08a1e5243824211dcbaf1040f08db01fb01f282420ddcbaf1040a01f10801e1d14ff0000a07e0aaf1010a04e0aaf1020a01e0aaf1030a2d983399359c219a319e30442b9b00fb04192a985344102aa0eb0a0800f08b8034988342b8bf18461d99814239da1d9f199af90739460ad0199f219a19f8071001f0f001114309f80710dde90b21b2eb600f09eb020715da149d09eb60063a4602f8015bb2420fd2ba1cb2427d700cd2fa1cb242bd7008d23a1dfd70b2421746edd302e03a4600e07a1c359c319ec70707d0814205da1078159900f00f0008431070ddf880c0e045c8bfc4462998844541da5feacc700bd04fea5c0019f80010219a01f0f00111430cf1010c09f800101898b0eb5c0f1add1898309e149d4fea5c0209eb0007b018044604f8015bbc4210d2811cb94225700fd2c41cbc420d700ad20436b118b9422570ecd305e009eb5c0102e0411c00e021462998359c319ec00708d02998844505da0878159a00f00f00104308702e9810280bd1012002901f982099349a01904846cdf8008002f0c7fbcae6b6fa86f01a99400908434ad11798864247d01399701e891b8842b8bf01466fea4100129908440128c0f29f800d99329a00fb101010998a1a4ff0ff31012a01eb42016ddb01fb01f7874269dd5100a1f1090202f10807032f02f1060157db01fb01f6864253dd052f02f1040152db01fb01f686424edd072f02f102014ddb01fb01f6864249dd3299092f01f104013291a2f1080103db524382420a46d9dc08313ee020988342d8bf034634988045a8bf80464345bff66daed80709d0580819f800102e9a01f0f0011143013309f800105908b1eb680f17da309f0e9d09eb68027c18264606f8015b96427ad2a01c904235707bd2e61c9642057076d20437781890423570ecd371e009eb53006ee0329a013204e0329a023201e0329a03323292329a012a23db08318a1f524382421edc329a022a19db0a1f5243824200f3ba80329a022a11d08a1e5243824200f3b580329a042a09db01fb01f2824200f3b080329a0831043a3292ded1002032901198329900eb010c20988342d8bf0346ddf8d0e0f445b8bfe646734543dad80709d0580819f800102e9a01f0f0011143013309f800105a08b2eb6e0f17da309e0e9d09eb6e07b018044604f8015bbc4212d2811cb94225701ad2c41cbc420d7015d20436b118b9422570ecd310e009eb53010de0601c02e0411c09e030465feac8713ff4cfad4345fff6c6adcae521465feace7007d0734505da08780f9a00f00f001043087032982a99c0430e18012002901f98209f349c01904846394622466346009602f0abfabe42d8bf3e46a045a8bfa0464645bff6a5adf00709d0700819f800102e9a01f0f0011143013609f800107108b1eb680f17da309b0e9d09eb68025c18274607f8015b974210d2a01c90423d700fd2e71c974205700ad20433581890423d70ecd305e009eb560002e0601c00e038465feac8713ff473ad4645fff66aad6ee53298013858e73298023855e73298033852e700223098359f09eb00014ea808902998009707902898cde905402698cde903102a98029034980190dde9321001f0c1fd0746fef73eba4ff0ff300df2345dbde8f08fb81a18bf4ff0ff300df2345dbde8f08fb0b586b008b3d0f87001f0b10023b3eb512f1ad150f82130bbb11b1a9d0714d16ff4403540f60f041d44cff6fd74a5420bd3184450f8085c8d4206d150f80c1ca1f1011515f5803f03d24ff0ff3006b0b0bd50f8045c8d42f7d1c3f540339942f3d80028f1d0037813f00b0fedd1144601ab0022002500f011f80028e5d00198dde903122060481c40086160a260e06028462561656106b0b0bd00bf91429cbf002070472de9f041855c4ff0050c6e0758bf4ff0030c15f0f30f02d1891a614502d20020bde8f0818418627894f802e0002e05d5e078267942ea0e2240ea062e002a4ff0000018bfbef1000fead0b2f5207fe7d8bef5f07f88bfbde8f081082d38bf0120072d18610ad8501c400800fb0ef0a1eb0c018842d3d804eb0c0828e004eb0c080efb02f5002000bf00eb0c04a142c6d008eb00073e78360903d00127b54213d2bde70c1b012cbad07e781eb10227b5420ad2b4e7042cb2d3bc78fe7854ea0626add00427b542aad3ad1b3844dcd158600120c3f800809a60c3f80ce0bde8f0812de9f04f89b0dde91257069005fb07f000294fea4007029100f0d48100200390089002984ff0010e00264ff0000b4ff000084ff0000c4ff000090497079205930be000bf4ff0000c4ff00308cdf80ca009f10109814500f0ba81bcf1000f40f0b4810699b8f1020f11f809a0ead0b8f1010f15d0ddf81cc0b8f1000f40f086805fea1a100af00f01089100f092800499814280f09a804ff0010c4ff0000882e1079abaf1000f00f07f800499514576d3a1eb0a010491089901eb01100901019114e000bfa15d089f01f0f0013943a1550136aaf1010a4ff0010eae4224bf00260bf1010bbaf1000f00f0598113998b45d1d20bfb0324bef1000fe3d0a91bb1eb5a0f88bf4fea5a0141b38d0804eb060817d0002208f10107a2eb850c6ff003057b1904350ceb05020432d870187158719871f5d1059b079a2f1d11f0030504d10ce0002711f0030508d0012d08f8070004d04744022d787018bfb870aaeb410abaf1000f0e440dd0129dae42b5d2a15d019f01f00f013943aaf1010a4ff0000ea155afe7129d4ff0000aa6e7039a52ea0a2213d004990392914280f08f804ff0010c4ff0000853e74ff0000c4ff002084ee74ff0000c4ff00108f4e000214ff0010c4ff00008039142e7089a091a049102eb02111201cdf80090019214e000bf1af80670089a07f0f00717440af80670013601384ff0010eae4224bf00260bf1010b002800f0d680139a934580f0cd800bfb03cabef1000fe2d0ad1bb5eb500ff14688bf45087db3ac080aeb06081ed0002308f10107a3eb840c6ff0030400bf07eb040e04340ceb040304338ef803108ef804108ef805108ef80610f0d1059bddf81cc0271d15f0030404d10ce0002715f0030408d0012c08f8071004d04744022c797018bfb970a0eb45002e4488b1129dae4210d21af80620019f02f00f023a430af8062001384ff0000e0028abd180e000bf129d0020ce469de7891a0491089901eb011009010191114613e000bf1af80620089c02f0f00222430af80620013601394ff0010eae4224bf00260bf1010b002953d0139a9345bff4ccae0bfb03cabef1000fe3d0ad1bb5eb510f88bf4d085db3ac080aeb060819d0002208f10107a2eb840c6ff0030400bf3a1904340ceb04030433d070107150719071f5d1059bddf81cc0271d15f0030404d10de0002715f0030409d0012c08f8070005d04744022c787018bfb87000bfa1eb45012e4489b1129dae42b6d21af80620019f02f00f023a4301394ff0000e0af806200029b0d103e000bf129d0021a4e74ff000084ff0000c029852e64ff0010c4ff0000803e04ff000084ff0000c0298ddf8009045e60120012107e04ff0010cb8fa88f0049f8cf001014009b7fa87f252091140084009b0bde8f08f00bf2de9f041826882b10121816007220020511e20fa01f1c90708bfbde8f0814ff0ff3191400843bde8f0818c46056841688d42e9d06b1c03602c78ff2c11d18b4200f0dc80ac1c046095f90120b2f1ff3fd6b200f3d080bf2e22d806f03f0602238fe062b2b2f1ff3f02dd07222046cfe7bf2c09d804f03f070e224ff0010e4ff000084ff0000c2ee0df2c0fd804f01f0715224ff0000c4ff001084ff0010e22e0df2e0fd806f01f0603236ae0ef2c0fd804f00f071c224ff0010c4ff000084ff0010e10e0ef2e58d806f00f06042358e0f02c40f093804ff0000820224ff0000c4ff0000e00278b424fea072603d0af1c07606d7803e00125856000251f46c02c45ea06046cd35b1a7d1ab3fa83f3b5fa85f55b096d092b434fea042403d001258560002503e07e1c06603d783746b8f1000f44ea050453d17d1ab5fa85f56d092b434fea042403d001258560002503e07e1c06603d783746bcf1000f44ea05043ed1791ab1fa81f1490919434fea042131d001238360002030e0f02e3ed1002605234ff0010e00250127ea074fea062617d18c4215d0621c0260247801379f4246ea040623d000bf8a424fea062609d0541c0460127801371643bb422246f3d116e02246013701254ff0000e9f4214468560dad112e07b1c0360387840ea0104bef1000f20467ff413afbde8f08114465feace7202d0091b8e4204d9012181600020bde8f081a11907462046002263463960bde8f041ffe78446081ab0f5806f01d90020704761454ff00000fad0002a18bf70472de9f04fabb09fed251a9fed250a9fed253a9e4600264ff0ff380df12c090df10c0ab7ee002ab0ee084ab6ee005ab1ee006ab9ee007a00206746019009e000bf49f826500af8064001368f42bc4600f0cb8217f8012b501e01280fd8012a23d18f4274d09cf901000cf10207b0f1ff3fc5b240f38f8000220724f5e1052a37d0042a30d0032a49d1002e00f0d982701e59f820501af8004093e200bf0000004f000000cf000000008f4254d00cf102079cf801008f4247d09cf802200cf103078f4240ea02203fd09cf803200cf104078f4240ea024037d09cf804200cf10507130600223ae0002e00f0aa82013eace7022ec0f0a582b21e59f82230701e59f8205049f820301af802301af800400af8003049f822500af8024096e702f0f80010281fd1002e00f08b82701e1af80030002b40f0858259f82050152a6fd16d420022002406463de20023012206e001220724002588e101220020002343ea000501242fe2a2f12000062827d8002e00f06782731e1af80300002800f0618259f82300242a40f0858080f00045012400221e4617e2bf2d5ad801220292002205f03f000e244ff0000b00928f4200f019819cf802300cf10308002215e1322a51d002f0fe0030284dd0402a40f0a380032ec0f03682701e1af80020002a00f03082b21e1af80230002b00f02a82033e1af80630002b00f0248209eb8202d2ed000a09eb860209eb8000d2ed001ad0ed002a70eee10a62eea00a71eea00acee1002800f00e82023e1af80600002840f0088259f82600122a58dc102a00f03081112a00f03381122a40f02c81454354e1df2d44d8002205f01f00152400924ff0010b0122bae0002e00f0eb81a2f13100013eb0fa80f01af806304009834240f0e08159f82600302a7bd100ee900af8eee00a94e1002b00f0d481023e1af80630002b00f0ce8159f82630212a40f3ed80222a00f02581232a00f02981252a40f03a8100ee903a01ee900af4ee610af1ee10fa48bff0ee601a11ee905a71e1ef2d72d805f00f001c24012274e0a2f11303022b80f0c480002d00f0a381b0f1004f08bf15f1010300f0eb80132a40f0f18090fbf5f5f1e0a2f1480010f1070f4ff00000c0f05f81002e00f05c81013e1af80600002800f0858109eb8600d0ed000af4ee420af1ee10faf5ee400ac8bff0ee420af1ee10fa48bff0ee430a432a72ee601a00f3b480412a00f0f380422a00f00f81432a40f0008161eea10a72ee600a1de1312a40f0948000ee900a20f00040b0f1ff4f4ff00002f4ee410aa8bf0122f1ee10fa4ff0000080f21c81f4ee400af1ee10fa00f11681002a40f01381fdeee00a10ee905a98e0f02d4ff0000040f00981002220244ff0000b009202928f427ff4e7ae00230122b8460002c02d43ea000535d3781aa8eb0103b0fa80f0b3fa83f340095b0918434fea05270ebf18f8013b00230122bbf1000f43ea07051fd1a8eb0103b3fa83f35b0918430ebf18f8013b002301222f02009d002d43ea07050ed1a8eb0103b3fa83f35b0918434fea05230ebf18f8010b0020012240ea0305474602984ff0ff3838b1601e25fa00f0c0071cbf08fa04f005430024a3e0162a10d1a842b8bf054637e0202a4cd0212a51d100ee903a01ee900a70eee10a8ee005442ae0a842c8bf054626e0451b24e0002800f1c680def800200546824238bf15469042019888bf0120019015e0442a48d0452a5fd0462a4ed161eea10a61e00025132a4ff0000208bf4ff00045002469e090fbf5f202fb15050022002462e000ee903a01ee900a61eea00a57e000ee900af5ee400af1ee10fa00f0928001ee903ac1eea00a4ae000ee903a01ee900a71eea00a43e000ee903a01ee900af4ee610af1ee10fac8bff0ee601a11ee905a37e060eea01a70eea00a74ee600a61eea00a2ce0f4ee450af1ee10fa18d570eea01a60eea10a22e0f4ee450af1ee10fa15d560ee861a60eea11a60eea10a16e060eea00a13e060eea01a60eea10a0ee071eea10a61eea00a72ee600a07e061ee870a61eea00a61eea00a70ee820a10ee905a012400224ff000005ab9202e09d0002c3ff436ad25f00040b0f1ff4ffff630ad00202bb0bde8f08f56b3701e1af8001059f82000d9b102ee100a20f00040b0f1ff4f4ff00001b4ee412aa8bf0121f1ee10fa4ff00000e4dab4ee402af1ee10fadfd40029ddd1bdeec20a10ee100a019adef804101143cef804102bb0bde8f08f00202bb0bde8f08f80b5002970d090f900c0bcf1200f5ffa8cfc07db012010604ff0010ec3f800c0704680bdacf1c20ebef11d0f0fd801295ad090f9011011f1410f55dc02211160407800f03f006cf38a108446e4e70cf0f00ebef1e00f23d1032945d390f901e01ef1410f40dc90f9021011f1410f3bdcbcf1e00f5ffa8ef101d1a02934d3bcf1ed0f01d19f292fd80321116042784fea0c3189b2807802f03f0241ea821136e004294ff0000ebbd3acf1f50111f1050fb6d390f901e01ef1410f15dc90f9021011f1410f10dc90f9031011f1410f0bdcbcf1f00f5ffa8ef101d1902904d3bcf1f40f03d18f2901d9002080bd042111604ff4e011427801ea8c4c817802f03f02c0784cea023201f03f0142ea811100f03f0001eb000c7fe72de9f04188b04af2bb261c46c0f24e0613460a46ddf83880002706f1ae05214627706770a770e77027716771a771e77127726772a772e77227736773a773e77327746774a774e77427756775a775e77527766776a776e77627776777a777e777a8470028c8f800705cd020786178a278e3780843104318434ff0010008d0e179a27911431ebf617a227a51ea020102d108b0bde8f081a07b14284ff00000f7d1217d8df8040041f0010121758df805008df806008df807008df808008df809008df80a008df80b008df80c008df80d008df80e008df80f008df810008df811008df812008df813008df814008df815008df816008df817008df818008df819008df81a008df81b008df81c008df81d008df81e008df81f0001a92046b047c8f8000018b1012008b0bde8f08106f1520120468847d8f80000002818bf012008b0bde8f081002804bf4ff0ff3070472de9f04f95b00df1200c8ce80f00f8f7fefc002800f004824ef66c6a4ff29c5bccf2ff0ac2f2290b4ff6ff760024012547f67f797f2707e000bf48f2a351c0f24501bff32f8f8847dbf80080bff35f8fdbf80000bff35f8f01466ff39601b1f1005f07d10168514504d14168b1f57d7f00f093804ff47d70f9f721fc002800f0cf814ff60c41cff6ff7142182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ff47d71c0f800a041608573a0f8c49180f8c371068446848684c684068546858685c685068646868686c686068746878687c6875be8001f41457ff45aafbff35f8f4be8000121b15be8001f4145f8d04fe7d0f87011209e4ff0ff3029b30022b2eb562f21d151f82600002800f03481431a98074ff0ff3017d16ff4403240f60f071a44cff6fd77ba420ed3ca1852f8080cb04240f0208152f80c1ca1f1011010f5803f04d24ff0ff3015b0bde8f08f002a4ff0ff30f8d052f8047c8f42f4d1c3f540339942f0d810ad104600222b460024fef716ff002800f0fe80239b0f22990603f00f0002eae17101fb00f289214a43d20a8df830200e2213f0200f08bf0f2408bf012200fb02f201fb02f24fead2228df831204ff00d0208bf022200fb02f201fb02f24fead2228df832204ff00c0208bf032200fb02f201fb02f24fead2228df833204ff00b0208bf042200fb02f201fb02f24fead2228df834204ff00a0208bf052200fb02f201fb02f24fead2228df835204ff0090208bf062200fb02f201fb02f24fead2228df836204ff0080208bf072200fb02f201fb02f24fead2228df837204ff0070208bf082200fb02f201fb02f24fead2228df838204ff0060208bf092200fb02f201fb02f24fead2228df839204ff0050208bf0a2200fb02f201fb02f24fead2228df83a204ff0040208bf0b2200fb02f201fb02f24fead2228df83b204ff0030208bf0c2200fb02f201fb02f24fead2228df83c204ff0020208bf0d2200fb02f201fb02f24fead2228df83d204ff0010208bf0e22424360434843c00a8df83f00c3f3001006900ca84a43cde9045008ac0b9dd20addf88890ddf884a0ddf87c8013cc1e9e8df83e2022462b46cdf80c90cdf808a0cdf80480009600f02df8dde91201a2455044c8bf5446a9454944c8bf4d46b042b8bf06464145b8bf8846a64211dd4146a8450edd249800680f280ad8249f491b321b07ebc0030130dc801d815a8199813860002015b0bde8f08f4ff0ff3015b0bde8f08f2de9f04f8fb0dde91c5a0e9129691e9eddf868c0002900f05c812f68002e40f05381874200f050819af80f100f2940f04b819af80e100e2940f046819af80d100d2940f041819af80c100c2940f03c819af80b100b2940f037819af80a100a2940f032819af80910092940f02d819af80810082940f028819af80710072940f023819af80610062940f01e819af80510052940f019819af80410042940f014819af80310032940f00f819af80210022940f00a819af80110012940f005819af80010002940f000811b9fb2eb0c044ff00001d8bf0c46db1bd8bf0b46d5f808e0ea681d46e919189fa444aeeb0403a7eb0c070694bb42b8bf1f46199b521b0b91591a8a42b8bf1146012f0c910797c0f2e5820c990129c0f2e1820ef101014c08069900eb6c000a9048100990042020ea81000590079801310138cde903014810029004fb05f000f102094ff0000acde9005c089407e000bf0c980af1010a8245a14400f0bb821c980e9b01680aeb050000fb04120b980a9f504400fb03705feacc7303d1099fdde9063810e0099b2e46d35c059d0778eb4007f0f00703f00f033b4400f8013b049bdde902783546d619da074fea580b0d9208d131465a466446f2f712fba446089c68e000bfb8f1020f64d3abf10102032a04d200211bf0030e35d15be06ff0030202ea58034f44b646c3f1000c3944471c8e18f578b478c5f3031545ea0415bc18e5703579f378c5f3031545ea0313237173793579c3f3031343ea05136371b3797679c3f30313043243ea06130ceb02060436a371dcd1dde9005c089c111d76461bf0030e26d04b1cf75c3246765cc7f30317ddf804c047ea06171646bef1010f475417d08f1cd65dd55cc6f3031646ea0516009dddf804c0bef1020fc654164608d03144c978f25dc1f3031141ea0211c15500bf5feac8713ff45aaf0d9a16f80b10002a4ff0000208bf042210f80b30d14003f00f0242ea011100f80b1047e7874200f095810026a1e16d68002d00f0018200244ff000090ae000bfdde90c14d8f804500c44ddf874a0ac4280f0f281ddf870800d94d8f800100f5d3e0903d001210c910ce000bf2e1b012e00f0e28121444d78002d00f0628102210c912e4617f00f011e9f1af801a0b7fa87f74fea571718bf012147ea010e1b9f4fea0a1b16f003014c4600f08980cde90a16d8f808100026b9fbf1f404fb119161449142a8bf012606ea0e06012e18d13c449c4215db189da94212da199dac420fda0e9d4e0804fb0504c907a75d6ff00f01554604bf0f215d4639401b9f2943a1550a990b9e012909f1010458d0d8f80810b4fbf1f606fb1141002461449142a8bf012404ea0e04012c18d1f4199c4215db189da94212da199dac420fda0e9d574604fb05044d08c907665d6ff00f0104bf0f215f46314039431b9f61550a990b9e022909f102042ad0d8f80810b4fbf1f505fb1141002461449142a8bf012404ea0e04012c19d1ec199c4216db189da94213da199dac4210da0e9d574604fb05044d08c907665d6ff00f0104bf0f215f4631400b9e39431b9f615509f10304711e0329b14405d23ae700bf0434a1453ff436afd8f808100026b4fbf1f505fb114161449142a8bf012606ea0e06012e1bd13d449d4218db189eb14215da199eb54212da0e9ed04605fb06054e08c907af5d6ff00f0104bf0f21d84639401b9f41ea0801ddf87080a955d8f80810661cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e1cd13d449d4219db189eb14216da199eb54213da0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa955d8f80810a61cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e1cd13d449d4219db189eb14216da199eb54213da0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa955d8f80810e61cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e7ff466af3d449d42fff662af189eb142bff65eaf199eb542bff65aaf0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa95544e7042e78d38e78c97856ea012673d0042188e61b99002901dd012609e0b1fa81f149090027bcf1000fc8bf012707ea0106d5f808e0d5f80cb00bfb0ef9b9f1000f59d01e990024b1fa81f149094ff0ff380d91f1070c9107e000bf01340bfb0ef94c45a8f1010846d20c991c9e0029214618bf09eb0801b1fbfef536680ef1010705fb1e117f0805fb07664f08f65d042727ea8107fe4016f00f094f4618bf01270d9e3743012fd8d161449142d5db1b9f3d449d42d1db189fb942ceda199fbd42cbda0e9f1af8096005fb070e4d081ef80570c90707f00f0907f0f00747ea06071c9908bf49ea06170ef80570d1f808e0d1f80cb0b1e70fb0bde8f08f00bf002804bf4ff0ff3070472de9f04f99b01c461546cde90e01f7f772ff002800f0fb814ef66c6b4ff29c59cde90c54ccf2ff0bc2f229094ff6ff7a0024012547f67f787f2607e000bf48f2a351c0f24501bff32f8f8847d9f80070bff35f8fd9f80000bff35f8f01466ff39601b1f1005f07d10168594504d14168b1f57d7f00f0a3804ff47d70f8f793fe002800f0c4814ff60c41cff6ff7142182e3182f8f44382f8f54382f8f64382f8f74382f8f84382f8f94382f8fa4382f8fb4382f8fc4382f8fd4382f8fe4382f8ff4382f8004482f8014482f8024482f8034482f8044482f8054482f8064482f8074482f8084482f8094482f80a4482f80b4482f80c4482f80d4482f80e4482f80f4482f8104482f8114482f8124482f8134482f8144482f8154482f8164482f8174482f8184482f8194482f81a4482f81b4482f81c4482f81d4482f81e4482f81f4482f8204482f82144a0d14ff47d71c0f800b041608573a0f8c48180f8c361a0f820a0a0f822a0a0f824a0a0f826a0a0f828a0a0f82aa0a0f82ca0a0f82ea0a0f830a0a0f832a0a0f834a0a0f836a0a0f838a0a0f83aa0a0f83ca0a0f83ea059e8001fb9427ff44aafbff35f8f49e8000121b159e8001fb942f8d03fe7d0f87021279e249d4ff0ff302ab30021b1eb552f21d152f82500002800f01881811a88074ff0ff3017d16ff4403340f60f070b44cff6fd77bb420ed3571857f8080ca84240f0048157f80cacaaf1011010f5803f04d24ff0ff3019b0bde8f08f57f8040c50454ff0ff30f6d1c1f540318a45f2d8002ff0d0baf1c10fedd33878012840f0e580b0060f2206f00f0102eae070484389225043c00a8df854000e2016f0200f08bf012001fb00f002fb00f04fead0208df855004ff00d0008bf022001fb00f002fb00f04fead0208df856004ff00c0008bf032001fb00f002fb00f04fead0208df857004ff00b0008bf042001fb00f002fb00f04fead0208df858004ff00a0008bf052001fb00f002fb00f04fead0208df859004ff0090008bf062001fb00f002fb00f04fead0208df85a004ff0080008bf072001fb00f002fb00f04fead0208df85b004ff0070008bf082001fb00f002fb00f04fead0208df85c004ff0060008bf092001fb00f002fb00f04fead0208df85d004ff0050008bf0a2001fb00f002fb00f04fead0208df85e004ff0040008bf0b2001fb00f002fb00f04fead0208df85f004ff0030008bf0c2001fb00f002fb00f04fead0208df860004ff0020008bf0d2001fb00f002fb00f04fead0208df861004ff0010008bf0e2001fb00f002fb00f04fead0204ff000038df8620008bf0f235943299d51430020c90a002d8df863103ff427af289cc6f30010a7f13f0810ae0b9001e0013d1cd014f8010b411e1f29f8d341b220290fdb08eb400118f81000497840ea0122c12a06d3384651463346fef794f80028e5d14ff0ff3019b0bde8f08f0d9c2698ddf894b0a042c8bf04462a980894dde9289406300790cde909a704e058440b38013c834653d019f8010b1f28f6d908eb400118f81000497840ea0122c12ad8d3384651463346fef766f80028d1d00b980c9f069015a8cde90460ddf898a0229ddde90e010d9b239e3a46cde902ba00950196fff740fadde91201bb4558445144d8bfbb46a8422a46b8bf0246b142a8bf31465a4517dd089b994214dd2a9b1b680f2b10d8089ea2eb0b02a1eb060c079901ebc307ba802a9a21f833b0591c7e80a7f806c01160dde909a710aea8e7002019b0bde8f08f2de9f04fd3b0dde95ce5dde9648cdde9629a0d9075b1dde96050dde95e47a94224eae47b27eae774a8bf29468242a8bf024602e000244ff0000b09eb0e0008eb00055845c8bf83468d420ceb0a07b8bf2946a24588bf54469742b8bf3a468b45b8bf944202db53b0bde8f08f669804f0010701974fea5b07033809970bf101070090580008974e080c90002701200df14c0e0df10c0c02948ce80e00cde90a6b06e000bf0798012700284ff00000dad0c00707906698069708bf0830ddf800906ff007086ff004044ff0000b4ff0000a0f9018bf09f10809cdf838900f994fea5a00085c102300f0f002cc46a14610901194cdf8488000bf1cf8041f0eeb08001cf8014c9cf8015042ea141704f00f041443447242ea111401f00f01847211430eeb0904217242ea15119cf802600772617205f00f011143a17242ea1611817306f00f01114308f10808083b09f10809c173d1d11098ddf83890000110224b465d4600bf13f8041f0eeb050713f8014c5e7840ea141804f00f0404437c7440ea111401f00f010143f97440ea161193f802c0397506f00f010143797540ea1c11b9750cf00f010143083a05f1080587f81080bc74f975d5d1ddf84880119c0af1020a08f120082034baf1100f0bf1200b84d101980699049a48400299059b00eb01090399dde90a6b9145bff65baf0d9803fb090807e000bf0c9809f1020991458044bff64faf0d98dc4609fb03045feacb700bd0099dddf820c0605d1ef8007000f0f00007f00f0738446055b6eb5c0f28d94fea5c0a04eb060b464616f80a0006eb0a041ef80050204600f8015b58451dd205781ef80570a51c5d45077017d228781ef800002870e51c5d4510d2287804361ef80000287006eb0a055d45ddd306e000bf04eb5c05c80705d1b4e7651cdde90a6bc807afd08c45adda28781ef8007000f00f0007f0f00738442870a3e72de9f04f8bb01d9d6c68072c00f286802cb12f89b94200f08180012c7bd100287cd0d0f87061002e78d00027b7eb512f74d156f82170002f70d0a7eb060c5fea8c776bd16ff440370ceb070e40f60f07cff6fd77be4561d306eb0c0e5ef8086c8e425bd15ef80c6ca6f1011717f5803f54d35ef8047cb74250d1ccf54037be424cd8bef1000f49d0032e47d39ef80070022f43d19446aa69ddf86ca0dde91987dde917b9b2b14fead10801f00704da464ff0010b4f4612f808900bfa04f444ea090402f80840d346ddf86ca0b946dde919876c6805eb44021181721e1c9e01346c600996169e0ef101010396159e0a950296149ecde904b9cde900366346cde90687cdf820a0fbf795fa6968013969600bb0bde8f08f6f89b94204d14ff0ff300bb0bde8f08f022c3ff479afaf89b942f4d0032c3ff473afef89b942eed0042c3ff46daf2f8ab942e8d0052c3ff467af6f8ab942e2d0062c3ff461afaf8ab9427ff45dafdae700bf70b5049d8b42c8bf19469542b8bf2a46914205dadde905e3bef1000f01d103b170bdbef10f0c18bf9c46cb070ed04b10c45cbcf1000f03d004f00f05ae4504d904f0f00444ea0e04c45401314c1000eb61035510bcf1000f00eb620049d0ac425fda00bf1c78764604f00f05beeb141f38bf2609754598bf754645ea06141d4605f8014b854265d25c78764604f00f05beeb141f38bf2609754598bf75469c1c45ea061584425d7040d29c78764604f00f05beeb141f38bf2609754598bf7546dc1c45ea061584429d702fd2dc78764604f00f05beeb141f38bf2609754598bf754645ea06151c1ddd7084422346b9d31ce0ac4219da4eea0e1500bf1c4604f8015b844226d29c1c84425d700ed2dc1c84429d700ad21c1ddd7084422346edd304e01c46d00704d17ae71c46d0073ff477af9142bff674af2078bcf1000f03d0beeb101f98bf70bd00f00f0040ea0e10207070bd5c1cd007ebd161e72de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010a47f67f7b4ff07f0807e000bf48f2a351c0f24501bff32f8f8847d5f80090bff35f8f2868bff35f8f01466ff39601b1f1005f07d10168a14204d14168b1f57d7f00f094804ff47d70f8f76af9002800f005814ff60c41cff6ff7100bf42182e3182f8f47382f8f57382f8f67382f8f77382f8f87382f8f97382f8fa7382f8fb7382f8fc7382f8fd7382f8fe7382f8ff7382f8007482f8017482f8027482f8037482f8047482f8057482f8067482f8077482f8087482f8097482f80a7482f80b7482f80c7482f80d7482f80e7482f80f7482f8107482f8117482f8127482f8137482f8147482f8157482f8167482f8177482f8187482f8197482f81a7482f81b7482f81c7482f81d7482f81e7482f81f7482f8207482f82174a0d14ff47d710460416080f80ea0a0f8c4b180f8c381068446848684c684068546858685c685068646868686c686068746878687c68755e8001f49457ff45aafbff35f8f45e8000121b155e8001f4945f8d04fe7d0f89812002974d104464ff41630f6f739f8014600284ff0000069d0002200bf8b1888544032b2f5163f58709870d870187158719871d871187258729872d872187358739873d873187458749874d874187558759875d875187658769876d876187758779877d87783f8200083f8210083f8220083f8230083f8240083f8250083f8260083f8270083f8280083f8290083f82a0083f82b0083f82c0083f82d0083f82e0083f82f0083f8300083f8310083f8320083f8330083f8340083f8350083f8360083f8370083f8380083f8390083f83a0083f83b0083f83c0083f83d0083f83e0083f83f009ad1c4f8981200e00021084601b0bde8f08f00bf70b5044690f8a00384f8a10350b3d4f8900347f64c6642f66535c2f20706c0f2440520b131682d31c4f8981310e040f22f00c0f200007844002122460023a847c4f89003316801f12d01c4f8981330b105f1e8022d219047002808bf70bd002084f8a10370bd00bf2de9f047a4b0d0f89442bff35f8fa4b142f691760546c0f2440620460021b04770b1d5f8900340b142f64d42c0f244022d2124b0bde8f047104724b0bde8f08747f64c69c2f20709d9f8007095f8a10300283fd0f7f7a4f8e0b3d5f89813781a17d495f8680110b995f82403e0b395f8a00385f8a10380b3d5f8900342f64d48c0f2440878b1d9f800102d31c5f898131de0d5f8900300b342f64d42c91bc0f24402904719e04ff64b70cff6ff70a8f1e807784400212a460023b847c5f89003d9f8001001f12d01c5f8981310b12d21c04710b1002085f8a10306f16601204624b0bde8f04708474af21f37c0f2470700200290adf80c00b84795f8680110b995f8240318b12846fff746ffe5e70df104084046f5f7a4fc02a9284600224ff0000afaf7ebfd81464046f5f7bffdb9f1000f02d085f8a1a303e00146284600f009f89df80c000028c7d107f14c008047c3e700bf2de9f04f90f8d13300f5697c4cf82310591c41f69a134b4390f8d0b31b0c03eb8303a1eb4301bbf1090f80f8d1139cbf0bf1010b80f8d0b3bbf1040f0bf0030e05d200244ff000094ff0000a2ee00bf0fc0800244ff000094ff0000a00eb8406d6f8a473d6f8a853b7fbfbf3d6f8ac1303eb090203fb1b73b5fbfbf7d6f8b06307fb1b5553443a44b1fbfbf72b44b6fbfbf53a4407fb1b1105eb020905fb1b6219440434a04502eb010ad7d1bef1000f1dd05cf82450bef1010fb5fbfbf606fb1b55b144aa4412d00ceb84056e68bef1020fb6fbfbf404fb1b66a144b24406d0ae68b6fbfbf505fb1b66a944b244bafbfbf202eb0901c0f8cc13bde8f08f00bff0b500294ff6ff7e00f0af80012903d10022c90775d1a8e021f00102c2f1000c6ff0010241f221038418a578e7788eea05252cb26e0036b203ead43484ea450503ead6366c0086ea450624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead53585ea460686ea07273eb27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead636023286ea470703ead5360ceb0205023586ea470e95d10232c90733d0805c41f221038eea002001b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead23181ea400e1ffa8ef0f0bd2de9f04fcbb00646c07c8b468df80600b08954998df80700000a8df808008df80a10080af1898df80b00080a17468df80d000020012b8df805308df809b08df80c108df80e008df80f008df810008df811008df812008df813008df814008df815008df816008df817008df818008df819008df81a008df81b008df81c008df81d008df81e008df81f008df820008df821008df822004cd1307e96f81780a0f1090144f62510c2f29240a1fb0002891a02eb510100970df10500b8eb910f88bf4fea9108c8ebc80706f11a0400f1010a00f10509093021463a46f0f781ff06f1210506f1280029460722f0f779ff284621460722f0f774ff20465146032207f10905f0f76dff06f11d0049460422f0f767fff07d02289cbf0130f075009fbb450cd0b8f1240f13d94ff0ff304bb0bde8f08fbb454ff00905f07509d14ef60b67abb20df10502c0f247070120f02115e002200df12304aab28df82300a01c0df105018df82470f0f73bffa81c4af6610782b2c0f24607f02021460023b8474bb0bde8f08f2de9f04184b0044690f84d0000284ff0000000f09a8094f84f1042f28b0701f078018df8071094f85010c0f25b0701f007018df80610cde9020002a906200022b847054670b9002002adcde902000df1070128460122f0f701ff012029460122b847054694f84e00a8b1002602a906200022cde90266b84760b9cde9026602ae04f1540130460122f0f7e8fe572031460122b8470543002602a906200022cde90266b84768b90df108080df1060140460122cde90266f0f7d1fe312041460122b847054302a906200022cde90266b84768b9002002ae04f15301cde9020030460122f0f7bbfe462031460122b8470543002602a906200022cde90266b84768b90df1080804f1510140460222cde90266f0f7a4fe362041460222b847054302a9a3200022cde90266b847054302a997200022cde90266b84742f62b310543c0f2440102208847284615b104b0bde8f081002184f84e1084f84d10a16504b0bde8f08100bf2de9f04f8bb00190233002254ff000080df10c0a4ff001094ff0000b002402900be000bf09fa0bf0002f0bf1010b08bf0443bbf1070f354426d042f2ff10c0f20000784410f80b0042f2f911c0f20001794411f80b6042f2fb0351463246c0f25b03cde90988cde90788cde90588cde90388984707460028d4d10298514628443246f0f739fecde742f2fb00c0f25b004ff60073002600f1340703a9c0f21f0381200c22cde90966cde90766cde90566cde90366b84730b9029803a928440c22f0f71afe8026ddf804c040f6b80146ea0400220ac2f200018cf823008cf824200a68002a00f0ad8045f2fd774ff6ff766ff0020241f22103c0f202070d681544ed7886ea052635b203ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea46060d6824b2154403ead4342d7984ea460686ea052635b203ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea46060d6824b2154403ead4346d7984ea460686ea052635b2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead4350332ba4285ea46067ff460afb1b2090a01e0ff26ff218cf83e109cf84c109cf84d208cf83f1026218cf83d608cf84020ff288cf84b101cbf04208cf81c000bb0bde8f08f70b588b042f2fb0514460e46c0f25b05002181280791cde90511cde90311cde90111009107d11b023435694681202246a84720b905e069462246a84708b108b070bd6946054630462246f0f71bfd284608b070bd2de9f0478cb08579972d17d00446fe2d0fd0fd2d2ad142f69570c0f25b008047002084f84e0084f84d00a0650cb0bde8f08720460cb0bde8f047cbe50020cde9040042f2fb00c0f25b00a0f1700304a9972000229847044642f62b31c0f244010220884720460cb0bde8f08742f2fb08002094f80c90677bc0f25b08cde90a00cde90800cde90600cde9040004a99f200422c047064620b901a804a90422f0f7c7fc002e6ff00100ddd19df80410bd29d9d19df805104029d5d19df806101029d1d194f84d00002852d047f64c60c2f20700006843f698210844a065002604a937200222cde90a66cde90866cde90666cde90466c047002840f0898002a804a90222f0f795fc04a947200122cde90a66cde90866cde90666cde90466c047002875d10df1030004a90122f0f781fc0020cde90a00cde90800cde90600cde9040004a905200122c047002860d10df1020004a9012249ea0726f0f76afc352d5bdc002d00f08180012d70d19df8020082e0002604a9052001228df80e60adf80c600296cde90a66cde90866cde90666cde90466c047d8bb0df1080a04a950460122f0f746fc04a935200122cde90a66cde90866cde90666cde90466c04738bb0af1010004a90122f0f733fc002604a937200222cde90a66cde90866cde90666cde90466c04798b90af1020004a90222f0f71ffc04a947200122cde90a66cde90866cde90666cde904660126c04778b14ff0ff300cb0bde8f087362d6ed0572d15d194f84e00002800f08580572039e00af1040004a90122f0f7fbfb04f14f0051460722f0f7f5fb84f84d603ee700208df801006946284601228df8009000f04ef9312d044627d036e09df80200002e00f0380618bf4036704010f0380f10d09df808009df8091041f6f6430e22c0f2000302ea96027b449a5a41ea0020904239d8012000218df80110694601228df8006000f024f904460df103014620012200f01df9054602a93620022200f017f945ea040141ea00040025a8f1700604a9a3200022cde90455b047044304a997200022cde90455b0470443aee69df802000e2101ea900041f67e41c0f200017944085a864204d96ff001000cb0bde8f0876946362002228df800708df8019000f0e6f80446d0e70020cde90a00cde90800cde90600cde9040004a9592001220125c04700287ff45caf04f1540004a90122f0f767fb84f84e5060e740f6b800c2f200000168002904bf4ff0ff30704780b584b000684ef2173102904ff41630039002a8c0f2470188474ff4f07042f29f7e01904ff4207cc0f25b0e0020002100220023cdf800c0f04704b080bd00bf2de9f04340f6b801c2f2000109684ff0000e01f1020c4cf6cd4340f2762808e00ef1010ebef5f07f0cf5a07c08bfbde8f083aef1a0096ff00906644607e000bf07eb0711a170053445452e46e8d290f84c1006f10a054f1e112905fb03f208bf570d122908d1a6f1e6019f294ff000079cbfb9f19f0f077b07eb071104f8021c90f84c1006f10c024f1e112903fb02f208bf570d122908d1a6f1e4019f294ff000079cbfb9f19f0f077b07eb071104f8011c90f84c1006f10e024f1e112903fb02f208bf570d122908d1a6f1e2019f294ff000079cbfb9f19f0f077b07eb0711217090f84c1006f110024f1e112903fb02f208bf570d122908d1a6f1e0019f294ff000079cbfb9f19f0f077b07eb0711617090f84c1006f112024f1e112903fb02f208bf570d12298ad1a6f1de019f294ff000079cbfb9f19f0f077b80e700bf2de9f04383b042f28b0914460e460546c0f25b090027694606200022cde90077c84710b103b0bde8f083e846404631462246cde90077f0f77dfa284641462246c84703b0bde8f08370b50446d0f840010d4638b92046f6f7cdf90028c4f8400108bf70bd42f64d46c0f2440606f140018847d4f8400129463246bde8704010472de9f04f81b0934612788ab1022300bf0beb030717f8012c62b11bf8032062b17a784ab1ba780433002af1d1023b04e0002205e0013b00e0013303eb4302520042eae272931c02f1010c01eb810203f0030e23f0030a00eb8213a3f5a0784ff0ff3906e009f10109b9f10d0f08f5a0786bd009eb010202eb8202bcf1030f00eb821605d24ff0ff34bef1000f2ed1e9e70024474604e000bfa24507f1020721d0621cd209042a03d83a7802f0f0023a70a21cd209042a03d87a7802f00f027a70e21cd209042a03d87a7802f0f0027a700434e209042adfd86208b55c05f00f05b554d9e7013cbef1000fbbd0a21cd509042d08d85208b55ce7076ff00f0708bf0f273d40b554bef1010fabd0e21cd509042d09d85208b55ce7074ff00f0708bf6ff00f073d40b554bef1020f9ad0221dd509042d96d85208e407b55c6ff00f0408bf0f242c40b4548ce79bf80010cdf800b0002900f0ce80022041f2410a41f2420b41f2430808e0009a063012f8011f03330029009200f0bd80a1f17f0717f15f0ff1d341f2f932c0f2000201eb41017a4402eb81014ff20014a1f5c079cff6ff7402e014f52074ded0494619f9027bc509042d09d8b7f1ff3f06dc1a1992f8016f46f0f00682f8016f5ffa87fe5fea4e6208d5042d06d81a1992f8017f47f00f0782f8017f5fea8e620ad540f27d22904206d81a1992f8027f47f0f00782f8027f5feace6209d5b0f51f7f06d81a1992f8027f47f00f0782f8027f5fea0e724fea900c09d5bcf19e0f06d81a1992f8036f46f0f00682f8036f5fea4e720ad540f27a22904206d81a1992f8037f47f00f0782f8037f91f90110042d09d8b1f1ff3f06dc1a1912f80a7047f0f00702f80a70c9b24a0608d5042d06d81a1912f80a7047f00f0702f80a708a060ad540f27d22904206d81a1912f80b7047f0f00702f80b70ca0609d5b0f51f7f06d81a1912f80b7047f00f0702f80b700a0709d5bcf19e0f06d81a1912f8087047f0f00702f8087049077ff565af40f27a2188423ff660af191911f8082042f00f0201f8082057e701b0bde8f08f00bf2de9f04381b04ff29c51c2f229010f68044638466ff39600b0f1005fbff35f8f0cd138684ef66c61ccf2ff01884205d17868b0f57d7f18bf002700e0002745f64d50c0f24600804741f2d161c0f2000141f2d662c0f2000279447a44022808bf0a4641f2b861c0f2000179440128204618bf114600f074fe47b197f87b0180b141f2b661c0f20001794419e041f2a361c0f200017944204601b0bde8f04300f05fbe97f8740141f29062c0f2000241f28d61c0f2000179447a44002808bf1146204600f04dfe97f8750141f26d62c0f2000241f27761c0f200017944012820467a4408bf114600f03bfe41f26561c0f200017944204600f033fe97f9c311204600f022ff41f25161c0f200017944204600f026fef6f7a2fd41f23368c0f2000841f23f66c0f200067e44054600f003003146f844012808bf414641f21d69c0f2000902282046f94408bf494600f008fea808012808bf4646022808bf4e462046314600f0fdfd41f2fb51c0f200017944204600f0f5fdd7f8840198b147f64c61c2f207010a68821a012a0bdb0968401a44f6d35100f2e730c1f26201a0fb0101890900e00021204600f0eafe41f2bd51c0f200017944204600f0d2fdd7f8bc11204600f0ddfe41f2aa51c0f200017944204600f0c5fdb7f8c011204600f0d0fe41f29251c0f200017944204600f0b8fd97f8c211204600f0c3fe41f27b51c0f200017944204600f0abfdb7f8c611204600f0b6fe41f26855c0f200057d442046294600f09dfdb7f8c811204600f0a8fe2046294600f094fdb7f8ca11204600f09ffe41f23c51c0f200017944204600f087fdd7f88011204600f092fe41f22751c0f200017944204600f07afd97f9c511204600f069fe41f21351c0f200017944204600f06dfd97f9c411204601b0bde8f04300f059be00bf2de9f04f81b0134681464a1c00f08f808e0a4ff0000b19f80b20002a00f0888109eb0b077a78002a00f00a81ba78002a00f00981fa78002a00f008813a79002a00f007817a79002a00f00681ba79002a00f00581fa79002a00f004813a7a002a00f003817a7a002a00f00281ba7a002a00f00181fa7a002a00f000813a7b002a00f0ff807a7b002a00f0fe80ba7b002a00f0fd80fa7b002a00f0fc803a7c002a00f0fb807a7c002a00f0fa80ba7c002a00f0fb80fa7c002a00f0fc803a7d002a00f0fd807a7d002a00f0fe80ba7d002a00f0ff80fa7d002a00f000813a7e002a00f001817a7e002a00f00281ba7e002a00f00381fa7e002a00f004813a7f002a00f005817a7f002a00f00681ba7f002a00f00781fa7f002a00f008810bf1200bbbf1600f7ff477af4ff0600b00e1002119f80120002a00f0af8109eb01056a78002a00f0b080aa78002a00f0b180ea78002a00f0b2802a79002a00f0b3806a79002a00f0b480aa79002a00f0b580ea79002a00f0b6802a7a002a00f0b7806a7a002a00f0b880aa7a002a00f0b980ea7a002a00f0ba802a7b002a00f0bb806a7b002a00f0bc80aa7b002a00f0bd80ea7b002a00f050812a7c002a00f04e816a7c002a00f04c81aa7c002a00f04a81ea7c002a00f048812a7d002a00f046816a7d002a00f04481aa7d002a00f04281ea7d002a00f040812a7e002a00f03e816a7e002a00f03c81aa7e002a00f03a81ea7e002a00f038812a7f002a00f036816a7f002a00f03481aa7f002a00f03281ea7f002a00f03081203160297ff479af32e10bf1010b74e00bf1020b71e00bf1030b6ee00bf1040b6be00bf1050b68e00bf1060b65e00bf1070b62e00bf1080b5fe00bf1090b5ce00bf10a0b59e00bf10b0b56e00bf10c0b53e00bf10d0b50e00bf10e0b4de00bf10f0b4ae00bf1100b47e00bf1110b44e00131f6e00bf1120b3fe00231f1e00bf1130b3ae00331ece00bf1140b35e00431e7e00bf1150b30e00531e2e00bf1160b2be00631dde00bf1170b26e00731d8e00bf1180b21e00831d3e00bf1190b1ce00931cee00bf11a0b17e00a31c9e00bf11b0b12e00b31c4e00bf11c0b0de00c31bfe00bf11d0b08e00d31bae00bf11e0b03e00e31b5e00bf11f0bb1f5205f4ff0010100931fd364234ff47a7442f2107700bf01eb81025200b6fbf2f50a2d11d301fb03f2b6fbf2f50a2d0bd301fb04f2b6fbf2f50a2d05d37943b6fbf1f2092ae7d800e011465846bbf15f0f98bf5f20c0f1000c1ceb0b0a53d0b6fbf1f74cf6cd4207f13003ccf6cc4209f80b300a29a1fb023547d31af1010342d007fb11674fead508b7fbf8fe48f21f520ef1300309eb0b06c5f2eb1273706429a1fb023434d31af102032cd00efb18776409b7fbf4f544f6d35205f13003c1f26202b370b1f57a7fa1fb022323d31af1030218d005fb14729b0941f25975b2fbf3f7cdf2b715a1fb055407f13005f57007fb132642f210720bf1040b91424fea5431a9d209e0834607e00bf1010b04e00bf1020b01e00bf1030b0020009b09f80b002de00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2904d849444ff03f020a7003d1002189f85f1001e000204870002119f80100002800f0a18009eb0105687800285ed0a87800285dd0e87800285cd0287900285bd0687900285ad0a879002859d0e879002858d0287a002857d0687a002856d0a87a002855d0e87a002854d0287b002853d0687b002852d0a87b002851d0e87b002850d0287c00284fd0687c00284ed0a87c00284dd0e87c00284cd0287d00284bd0687d00284ad0a87d002849d0e87d002848d0287e002847d0687e002846d0a87e002845d0e87e002844d0287f002843d0687f002842d0a87f002841d0e87f002840d0203160297ff498af44e001313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2905d849444ff02f00087040f09580002089f85f00581c00f094809d0a4ff0000e19f80e00002800f08d8109eb0e067078002800f00f81b078002800f00e81f078002800f00d813079002800f00c817079002800f00b81b079002800f00a81f079002800f00981307a002800f00881707a002800f00781b07a002800f00681f07a002800f00581307b002800f00481707b002800f00381b07b002800f00281f07b002800f00181307c002800f00081707c002800f0ff80b07c002800f00081f07c002800f00181307d002800f00281707d002800f00381b07d002800f00481f07d002800f00581307e002800f00681707e002800f00781b07e002800f00881f07e002800f00981307f002800f00a81707f002800f00b81b07f002800f00c81f07f002800f00d810ef1200ebef1600f7ff477af4ff0600e05e100204870581c7ff46caf002119f80100002800f0aa8109eb01025078002800f0b0809078002800f0b180d078002800f0b2801079002800f0b3805079002800f0b4809079002800f0b580d079002800f0b680107a002800f0b780507a002800f0b880907a002800f0b980d07a002800f0ba80107b002800f0bb80507b002800f0bc80907b002800f0bd80d07b002800f04b81107c002800f04981507c002800f04781907c002800f04581d07c002800f04381107d002800f04181507d002800f03f81907d002800f03d81d07d002800f03b81107e002800f03981507e002800f03781907e002800f03581d07e002800f03381107f002800f03181507f002800f02f81907f002800f02d81d07f002800f02b81203160297ff479af2de10ef1010e74e00ef1020e71e00ef1030e6ee00ef1040e6be00ef1050e68e00ef1060e65e00ef1070e62e00ef1080e5fe00ef1090e5ce00ef10a0e59e00ef10b0e56e00ef10c0e53e00ef10d0e50e00ef10e0e4de00ef10f0e4ae00ef1100e47e00ef1110e44e00131f1e00ef1120e3fe00231ece00ef1130e3ae00331e7e00ef1140e35e00431e2e00ef1150e30e00531dde00ef1160e2be00631d8e00ef1170e26e00731d3e00ef1180e21e00831cee00ef1190e1ce00931c9e00ef11a0e17e00a31c4e00ef11b0e12e00b31bfe00ef11c0e0de00c31bae00ef11d0e08e00d31b5e00ef11e0e03e00e31b0e00ef11f0e0122b3f5205f1ed364234ff47a7442f2107602eb82004100b5fbf1f00a2811d302fb03f1b5fbf1f00a280bd302fb04f1b5fbf1f00a2805d37243b5fbf2f00928e7d800e00a46f046bef15f0f98bf4ff05f08c8f1000c42f2107a1ceb0e074dd0b5fbf2f30a2a03f1300009f80e004cf6cd40ccf6cc40a2fb000641d3781c3dd003fb1253f608b3fbf6f409eb0e0504f13000687048f21f50c5f2eb10642aa2fb000130d3b81c29d004fb16334e09b3fbf6f4b2f57a7f04f13000a87044f6d350c1f26200a2fb000120d3f81c16d004fb1630890941f25974b0fbf1f3cdf2b714a2fb044603f13004ec7003fb11050ef1040e52454fea5632afd209e0c64607e00ef1010e04e00ef1020e01e00ef1030e002009f80e0001b0bde8f08f0f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2904d849444ff03f00087005d1002089f85f0001b0bde8f08f0020487001b0bde8f08f2de9f0411f22831813f81f7c002f00f0808013f81e7c002f7dd013f81d7c002f7bd013f81c7c002f79d013f81b7c002f77d013f81a7c002f75d013f8197c002f73d013f8187c002f71d013f8177c002f6fd013f8167c002f6dd013f8157c002f6bd013f8147c002f69d013f8137c002f67d013f8127c002f65d013f8117c002f63d013f8107c002f61d013f80f7c002f5fd013f80e7c002f5dd013f80d7c002f5bd013f80c7c002f59d013f80b7c002f57d013f80a7c002f55d013f8097c002f53d013f8087c002f51d013f8077c002f4fd013f8067c002f4dd013f8057c002f4bd013f8047c002f49d013f8037c002f47d013f8027c002f45d013f8013c002b43d0835c002b41d020327f2a7ff47baf64e01f3a3ae01e3a38e01d3a36e01c3a34e01b3a32e01a3a30e0193a2ee0183a2ce0173a2ae0163a28e0153a26e0143a24e0133a22e0123a20e0113a1ee0103a1ce00f3a1ae00e3a18e00d3a16e00c3a14e00b3a12e00a3a10e0093a0ee0083a0ce0073a0ae0063a08e0053a06e0043a04e0033a02e0023a00e0013a5f2a25d8c2f15d0cc2f15e0ec2f15f03c2f160080244002509e000bffc78002cf47008bfbde8f0810435a84510d04e5d565586b1ab420bd04f197c78561974704cb1ae4504d0bc78b47024b1ac45e5d1002180f85f10bde8f08100bf7f2905d140f61301c0f20001794403e7b1f1ff3fc8bf0fe0b0b540f2fd72c0f200027a440d4611460446fff7f5fe20466942bde8b040ffe72de9f04f4ff0000c10f80c20002a00f0c48000eb0c035a78002a62d09a78002a62d0da78002a62d01a79002a62d05a79002a62d09a79002a62d0da79002a62d01a7a002a62d05a7a002a62d09a7a002a62d0da7a002a62d01a7b002a62d05a7b002a62d09a7b002a62d0da7b002a62d01a7c002a62d05a7c002a62d09a7c002a62d0da7c002a62d01a7d002a62d05a7d002a62d09a7d002a62d0da7d002a62d01a7e002a62d05a7e002a62d09a7e002a62d0da7e002a62d01a7f002a62d05a7f002a62d09a7f002a62d0da7f002a62d00cf1200cbcf1600f7ff496af4ff0600c5be00cf1010c58e00cf1020c55e00cf1030c52e00cf1040c4fe00cf1050c4ce00cf1060c49e00cf1070c46e00cf1080c43e00cf1090c40e00cf10a0c3de00cf10b0c3ae00cf10c0c37e00cf10d0c34e00cf10e0c31e00cf10f0c2ee00cf1100c2be00cf1110c28e00cf1120c25e00cf1130c22e00cf1140c1fe00cf1150c1ce00cf1160c19e00cf1170c16e00cf1180c13e00cf1190c10e00cf11a0c0de00cf11b0c0ae00cf11c0c07e00cf11d0c04e00cf11e0c01e00cf11f0c01230a291fd364274ff47a7642f2107500bf03eb83025200b1fbf2f40a2c11d303fb07f2b1fbf2f40a2c0bd303fb06f2b1fbf2f40a2c05d36b43b1fbf3f2092ae7d800e01346e2464cf6cd49bcf15f0f98bf4ff05f0acaf1000eccf6cc491eeb0c0b4ed0b1fbf3f50a2b05f1300200f80c20a3fb092446d31bf1010241d005fb1316e508b6fbf5f800eb0c0108f130024a7048f21f52c5f2eb12642ba3fb022434d31bf102022cd008fb15656609b5fbf6f4b3f57a7f04f130028a7044f6d352c1f26202a3fb027223d31bf1030718d004fb1654920941f25976b4fbf2f5cdf2b716a3fb066705f13006ce7005fb124142f210720cf1040c93424fea5733aed209e0d44607e00cf1010c04e00cf1020c01e00cf1030c002100f80c10bde8f08f0000434d01ffff0000000000000052420100ff000000080310000000000000000000080010631a2308011a1c0800100018c00420a0024801520964617368626f617264580162012028904e46616365636c61772f33380000000000000000000000000000002020202020002020000000505050000000000000000000005050f85050f85050000000002070a8a07028a8702000000048a85010202854480000000020505020689090680000002020200000000000000000000010204040404020100000000040201010101020400000000000005020f82050000000000000002020f82020000000000000000000000020204000000000000000f800000000000000000000000000202000000000080810102020404000000000708898a8c88888700000000020602020202020700000000070888808102040f8000000007088083008088870000000000818284888f8080800000000f88080f00808887000000000708080f08888887000000000f808081010202020000000007088887088888870000000007088888878080870000000000000202000002020000000000000202000002020400000000008102040201008000000000000f80000f8000000000000004020100810204000000000708888102000202000000000708898a8a89880780000000070888888f888888800000000f08888f0888888f000000000708880808080887000000000e0908888888890e000000000f88080f0808080f800000000f88080f0808080800000000070888080b888887000000000888888f888888888000000007020202020202070000000003810101010909060000000008890a0c0c0a090880000000080808080808080f80000000088d8a8a888888888000000008888c8a89888888800000000708888888888887000000000f0888888f080808000000000708888888888a87008000000f0888888f0a0908800000000708880700808887000000000f8202020202020200000000088888888888888700000000088888850505020200000000088888888a8a8d88800000000888850202050888800000000888850502020202000000000f8081020408080f8000000007040404040404070000000004040202010100808000000007010101010101070000000205088000000000000000000000000000000000000f80040200000000000000000000000000000700878888878000000008080f088888888f00000000000007088808088700000000008087888888888780000000000007088f8808078000000001820702020202020000000000000788888888878087000008080f08888888888000000202000602020202070000000080800180808080808483000004040485060605048000000006020202020202070000000000000f0a8a8a8a8a8000000000000f08888888888000000000000708888888870000000000000f088888888f0808000000000788888888878080800000000b8c0808080800000000000007880700808f00000000020207020202020180000000000008888888888780000000000008888505020200000000000008888a8a8a870000000000000885020205088000000000000888888888878087000000000f810204080f800000000182020402020201800000000202020202020202000000000601010081010106000000048a89000000000000000009f0535593747c181040101010201020c005353a829c51bd314a810260d5b0bfe096d6963205220006d6963204c20006d6963203f20006e6f206374780061726d200063666720006f6666200070646d00636f646563002072656720002074626c2000540053002d00206c65617365200073207461702000200042400020736b697020002f002066722000206e7466200020756e7265672000000000", + "new": "b0b581ea00039b0701d0034637e0c2b110f0030315d000f1010ca2f1010e0023cc5c9e45c45403f1010404d0634413f003032346f4d121440319121b102a14d302e00346102a10d3d1f800c0d1f804e0cc688d68103adc609d60c3f804e043f810cb0f2a01f11001eed8042a07d300bf51f8045b043a032a43f8045bf8d8002a08bfb0bd0139013b11f8015f013a03f8015ff9d1b0bd00bf884218bf002a00d1704710b50b1a38bf431a934207d288420ad281ea00039b0726d0034669e0fff79fffbde81040704781ea000300eb020c9b0701eb020e42d15fea8c732bd0a0f1010c00bf8b1813f801ec8418531e04f801ec04d0624412f003021a46f2d101eb030e00eb030c17e0830736d0a2f1010c00f1010e002300bfcc5c9c45c45403f1010404d0734413f003032346f4d1121b2144031922e01346042b0ed3aef10402acf1040152f80449043b032b41f80449f8d802f1040e01f1040c1a4653b1aef10101acf1010300bf11f80149013a03f80149f9d1bde8104070470346042a06d351f8044b043a032a43f8044bf8d8002af0d00139013b00bf11f8014f013a03f8014ff9d1e6e700bf80b5002a18bf10f0030301d186460ce000f1010c864600bf013a0ef8011b04d01cf003030cf1010cf6d1102a11d35ffa81fc4ff001330cfb03fc00bf103acef80cc0cef808c0cef804c04ef810cb0f2af4d8042a0bd35ffa81fc4ff001330cfb03fc00bf043a032a4ef804cbfad8002a08bf80bdaef10103013a03f8011ffbd180bd00bf2de9f04fc7b04ff29c5bc2f2290b4ff6ff754ff47e740027012647f67f784ff07f0a1191cde90f3007e000bf48f2a351c0f24501bff32f8f8847dbf80090bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0ad101684ef66c62ccf2ff02914203d14068b0f57e7f3ed04ff47e7006f017fa002800f01b816ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ef66c61ccf2ff01016044608673a0f8c48180f8c3a1058445848584c584058545858585c585058645868586c586058745878587c5875be8001f4945a9d1bff35f8f4be8000121b15be8001f4945f8d09fe74ff47e7800264ff0010a47f67f797f2707e000bf48f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0ad101684ef66c62ccf2ff02914203d14168b1f57e7f40d04ff47e7006f0adf9002800f0b1806ff0070142180831b1f57c7f167256729672d672167356739673d673f2d14ef66c61ccf2ff010160c0f8048080f80ea0a0f8c49180f8c371058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa142a7d1bff35f8f4be8000121b15be8001fa142f8d09de7d0f8948242f6f76ac0f2440ab8f1000fbff35f8f4ad00af19a0240464ff0ff314ff0ff379047002840f036811198002860d010980778a7f1170002285ad811980c2840f02381109c6078a178084300f01d81e0780138022800f21881a279e379667a42ea0322237a207942ea034242ea0663a27ae67a6179192f42ea062200f08481172f40f09a81002a40f0ff80fe2800f0b285812800f0a585002840f0b88551ea030040f0f28000f002be04460020d047e0b104f5257151e8008fb8f1000f0cd1bff35f8f00bf41e80002002a00f08b8051e8008fb8f1000ff5d00021bff32f8f0029bff35f8f7ad0804693e74ff0ff37d1e047f6df40c0f24f00cdf83880804700274ff47e784ff0010947f67f764ff07f0a1397adf8507006e048f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0ad101684ef66c62ccf2ff02914203d14168b1f57e7f47d04ff47e7006f0bdf8002840d06ff0070100bf42180831b1f57c7f177257729772d772177357739773d773f2d14ef66c61ccf2ff010160c0f8048080f80e90a0f8c46180f8c3a1058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa142a7d1bff35f8f4be8000159b15be8001fa142f8d09de70af5a971884716e701217ae70020109f42f6f76addf83880c0f2440a9fb1119989b1397801f07f02b2f10b0418bf0124b2f11c0618bf01268a2924dc0b2926d01c2924d03ce00f9012a803f055fd4ff0ff3701269df85100002812a818bf4ff0ff3703f019fe054646b99df8500028b94af21f30c0f247004c3080470f98002818bf056114e09c2901d08b2918d168b14af21f31c0f247010746884797f8681121b997f824133846109f49b14ff0ff370af5807140468847384647b0bde8f08f0f9012a8264003f017fd387800f07f041e2c05d11199384608f048fd0746b9e71d2c00f07e0018bf1a2819d1dbf800100322cff680720a40b2f1005fbff35f8f12d10a684ef66c63ccf2ff039a420bd14a68b2f57e7f04bf002281f8a12303e0a4f115010129e1d90f2c2cdd142c40f3bb81152c00f0ba82162c00f0c4821f2c40f088831198012840f0588438781f2840f0548445f64d54c0f24604a047012841f0388041f21051c0f2010104f5e2777944e02029220023b8470746002818bf4ff0ff3766e7092c00f3a980052c00f0f081072c40f05e830d9600264ff0010947f67f744ff07f083ae000294ff0ff3708bf002b7ff47caf1328bff479af102a4ff0000138bf01211228b2fa82f218bf510901297ff46caf00f07abc182f4ff0ff3708bf00297ff463af002b7ff460af352800f36483002800f05284012800f05e84312840f05084082abff451af00f05fbc48f2a351c0f24501bff32f8f8847dbf80070bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57e7f00f060854ff47e7005f051ff002800f058856ff0070142180831b1f57c7f167256729672d672167356739673d673f2d14ef66c61ccf2ff0101604ff47e71416080f80e90a0f8c44180f8c381058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb942a5d1bff35f8f4be80001002900f021855be8001fb942f6d099e70a2c00f0bc810b2c40f0b582dbf800500320cff680702840b0f1005fbff35f8f40f0698728684ef66c61ccf2ff01884240f0618768680027b0f57e7f7ff49baed5f8900342f68d49c0f244090028a5f8a07318bfc8470021a5f8d013c5f8cc13c5f86c1185f86a1185f86811d5f87001c5f8641185f86911c5f87011c5f82013a5f88c1320b148f2a351c0f245018847d5f89802002818bf03f099fd0024c5f89842d5f8880320b148f2a351c0f245018847c5f88843a5f88c43686ca5f8484040b1c847686c09f166018847002804bf002068644bf63940c0f251008047dbf800400320cff680702040b0f1005fbff35f8f48d120684ef66c61ccf2ff01884241d16068b0f57e7f3dd194f87b014ff00008c4f8848100b384f87b8194f8750149f259620138b0fa80f04109c0f2590240f20b1090474ef6e37710f1800fd8bf6ff07f00c0f25a077e28a8bf7e2084f8c401b84707f1bc008047d4f8880184f8748142f6f76addf83880c0f2440a50b1c847d4f8880109f166018847002804bf0020c4f88801dbf800000321cff680710140b1f1005fbff35f8f40f0468601684ef66c62ccf2ff02914240f03e864168b1f57e7f40f0398690f8cc11002900f02e8607f022fb00f030be102c00f00681112c40f0d0811198022840f0a0823878112840f09c827878002840f0988245f64d50c0f24600804701284ff000077ff4baad40f20830c0f210003790ff208df8d80044f25220c0f20100359040f2c960c0f248003446cde93877804798b148f27e30c2f2070000880122c1b264298df8d72008d80721b0f5807f38bf03218df8d7108df8d80040f2d260adf8e000052037ae8df8e200f01d35a90522fff771fa4ff22507c0f247070120092132460c23b84742f6f76addf838800746c0f2440a264670e511980d9602282cbf7878ff204ff47e7800274ff0010a47f67f797f240c9006e048f2a351c0f24501bff32f8f8847dbf80060bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57e7f00f049814ff47e7005f091fd002800f0d8836ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ef66c61ccf2ff010160c0f8048080f80ea0a0f8c49180f8c341058445848584c584058545858585c585058645868586c586058745878587c5875be8001fb142a6d1bff35f8f4be80001002900f00b815be8001fb142f6d09ae711980228c0f0cc8100f0c8fd002800f0c7817c78002c00f03683022c00f2c08140f00e85014611980628c0f08a84109fb878fa783b797f7940ea022043ea072232283790389280f0f384322000f0f6bc1199781c013908f0b1fa0746cce41199384607f025fb0746c6e4119801380228c0f096817878b9784ff0ff3740ea0120b0f5007f3ff6b8ac0321119a01eb400191427ff4b1ac002700288df8dc708df8dd708df8de708df8df708df8e0708df8e1708df8e2708df8e3708df8e4708df8e5708df8e6708df8e7708df8e8708df8e9708df8ea708df8eb708df8ec708df8ed708df8ee708df8ef708df8f0708df8f1708df8f2708df8f3708df8f4708df8f5708df8f6708df8f7708df8f8708df8f9708df8fa708df8fb708df8fc708df8fd708df8fe708df8ff708df800718df801718df802718df803718df804718df805718df806718df807718df808718df809718df80a718df80b718df80c718df80d718df80e718df80f718df810718df811718df812718df813718df814718df815718df816718df817718df818718df819718df81a718df81b713ff42dac10990df1dc0a033101224b78012b00f2d0820f7847ea0323db081af8034007f0070702fa07f7274240f0c3821af80340013847ea040701f102010af80370e4d10d9604f0fafb002800f0c5830027012647f67f784ff07f09bae21d2c60d11199781c013908f059fe0746fff7f6bb90f848100df1300842f6f76a109f98e86001c0f2440a61b1416c39b142f68d42c0f244020446084690472046002180f848100121119a032a1ad3cdb9b878082800f294844bf63941c0f25101963188470027fff7cbbb362800f00681462800f00081572840f0ec80002e7ff4edabfbe0119a052ac0f0d580012d40f0d280b8783d46411e06294ff000073ff6afabe97803293ff6abab2a79002a3ff4a7ab4bf63943c0f2510303f59a7398470027fff79dbb1a2818bf1c2c6cd104f087fb002868d000f065fc814609f08ef8b9f1000f4ff0ff3718bf00283ff488ab834647f63400c2f20700d0f81806d9f894131b2ca0eb0100c9f89c0300f0fc821a2c40f01d83109900254f1c11994ff4f072a1f1010a4ff4a071cde93d5037a84ff420744ff48058cde90950cde901214846394652465b46cde937853f95cde90755cde90555cde90355009409f0e4fa002840f0f282d9f89c033946cde93e0537a80a90012009904ff4a07002904ff4f0700190484652465b464ff42077cde937853d95cde90755cde90555cde90355009709f0c1fae7e24ff0ff37fff728bb0c294ff0ff377ff451abb3f5005f5dd3fff74cbb481e1f284ff0ff373ff646abc1f51630834251d9fff740bb002b7ff43bab421f18bf0122b0f1350318bf01231a40b0f1590318bf01231a40b0f1470318bf0123134208bf012937d0b0f1370218bf0122b0f1c10318bf01231a4208bf02292bd09f284ff0ff377ff417ab042924d0fff713bb022d40f0ef804bf63940c0f2510080470027fff7daba022abff405ab13e0002a7ff401aba0f1fd0102290cd397287ff4faaa08e06ff0780002427ff4f4aa02e0402abff4f0aa45f64d50c0f24600804710990128c9784ff001004ff0010608bf022008424ff000073ff4ddaacdf8388047f67f794ff07f0806e048f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0ad101684ef66c62ccf2ff02914203d14168b1f57e7f40d04ff47e7005f0d9fa002800f0da806ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ef66c61ccf2ff0101604ff47e7141608673a0f8c49180f8c381058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa142a7d1bff35f8f4be8000121b15be8001fa142f8d09de74af21f35c0f247050446a84794f86801ddf83880109f00287ff464aa94f82403214600287ff45eaa3878172812d0d1f8840320b903f066ffc4f8840360b342f68d41c0f24401a1f140024ff47a719047214608bb01f226300e4639460c22fef703ff0f98002186f825030120bff35f8f86f824034ff4f07001904ff4207005f5106600900020002200230027b04700283ff42aaa84f8247305f14c0080474ff0ff37fff721ba119a072ac0f00781032d40f00481b878fa78397940ea02207c79bd7901284ff0010798bf384644f62062904228bf10464bf63942c0f2510202f5e272642928bf6421904747f63400c2f207000068002800f0898244ea0521012988bf0f4642f68d41c0f24401a1f14002394690470027fff7b9b9002780f8477145f64d50c0f24600804701287ff4aea943f2a310c0f2560080470746fff7a6b9ddf838804ff0ff37fff7ceb900201199dde90d68022910992cbf4978ff21002800f0548202294ff000072cd0012926d000297ff48ba94cf67e21caf2101187778783cbf8041087818760058445848584c584058545858585c585058645868586c586058745878587c58780f8407080f8d17380f8d073c0f8cc73fff767b901218173fff763b98773fff760b90df1300842f6f76a109f98e8600100210020c0f2440a77e542f6f76a4ff0ff37c0f2440afff74cb948f2a351c0f24501bff32f8f8847dbf80040bff35f8fdbf800000321cff680710140b1f1005fbff35f8f0bd101684ef66c62ccf2ff02914204d14168b1f57e7f00f08b804ff47e7005f07cf9002800f0e1806ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ef66c61ccf2ff0101604ff47e7141608673a0f8c48180f8c391058445848584c584058545858585c585058645868586c586058745878587c5875be8001fa142a6d1bff35f8f4be8000100294dd05be8001fa142f7d09be780461198b14603284ff0000738d3281fb0fa80f04009084032d01198109a4cf6cd410338ccf6cc419578a0fb0101b5eb910f88bf8d082e46302d28bf302608f14a00d11c06eb8602fef7b0fd002788f8486088f849709db1d8f8440038b9404600f04cfa0028c8f8440000f0798142f68d41c0f24401a1f1400201219047002742f6f76addf83880c0f2440a4e46fff79fb8d0f870110027002900f0ad804ff400624ff0ff3c04e02b681a44b2f5403f4fd28d18ac68b7eb542ff5d1e3081af8033004f00706f340db071ebf41f82470c5f808c0ef60e7e71198032840f0c48010994ff4f077487889785a4640ea012400200890cde90600cde90400cde902004ff4a0700190484621464ff42073009708f04afe002800f01e814ff0ff37a3e01198012840f0a08009f57970bff35f8f50e8001f013140e80012002af8d113a94846012208f06afe07468de04ff0ff3752e04ff0000c4ff400634ff0000ec0f820c305e077463344b3f5403fbe4642d2cf18ba68ce580132f4d1f418220c022a2fd80a19956801352bd115682e443e6012681444220c022a23d80a19956801351fd115682e443e6012681444220c022a17d80a199568013513d115682e443e6012681444220c022a0bd80a199568013507d115682e443e6012681444b4f5403fcfd3bef1000fc7f804c00cbfc0f82033cef80430b7e7002742f6f76adde90d68c0f2440afef7e4bfb0f5fa6f084603d94ff4fa60379008460121054680f8471145f64d50c0f24600804701281bd143f2a318c0f25608a8f188008047022c074608bf002f01d057b90de04bf2110237a9c0f24b020220904728b10746c047002085f8470100e0002742f6f76addf83880c0f2440afef7acbf90f8cd11002918bf06f0f0fcdbf800000321cff680710140b1f1005fbff35f8f24d101684ef66c62ccf2ff0291421dd14168b1f57e7f19d1d0f8d813b1b14ff00041bff35f8fc0f8d4134af21f30c0f2470000f510674ff4f07001904ff4207400200021002200230094b84795f84701002785f8477158b145f64d50c0f246008047012804d143f2a310c0f256008047d5f8400195f84641c5f83c7185f84671a5f8447150b1c847d5f8400109f166018847002804bf0020c5f840010120a87354b14af27365c0f246050021002200230027a847fef740bf0027fef73dbf601ca9f88c03002783e74bf639400027c0f2510088f84870804786e600bf2de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010947f67f7a4ff07f0b07e000bf48f2a351c0f24501bff32f8f8847d5f80080bff35f8f2868bff35f8f01466ff39601b1f1005f06d10168a14203d14168b1f57e7f3dd04ff47e7004f04fffb8b36ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ff47e710460416080f80e90a0f8c4a180f8c3b1068446848684c684068546858685c685068646868686c686068746878687c68755e8001f4145b2d1bff35f8f00bf45e8000129b155e8001f4145f8d0a7e7002001b0bde8f08f70b500284dd001684ef66c62ccf2ff02914218bf70bd90f8481090f849504bf6394c8d42c0f2510c2ad205eb8501014491f84d2091f84e4091f84ae091f84b3091f84c1042ea0424012c4ff0010298bf14466e1c054680f84960b9b164294eea032028bf6421012888bf024644f62060824228bf02460cf5e2731046984706e0002180f84810bde870406047e047686c38b142f64d42c0f244022146bde87040104770bd02464ff64b70cff6ff7042f6653c7844c0f2440c00210023604700bf2de9f04fcdb04ff29c57c2f229073c6840f2030a20464ef66c696ff39600cff6807accf2ff09b0f1005fbff35f8f40f0e9812068484540f0e5816068b0f57e7f40f0e08194f8710347f64c65c2f2070504f5497628b347f61800c2f20700016d4bf67c52c0f2720291421ad1406cc0b1d4f87c032968401a012802db03f00cfe78b93046b8460df059ff50b142f69570c0f25b0080474746002084f8720384f8710394f8700368b1d4f880032968401a012802db03f0f0fd20b9002084f8700384f86a013078bff35f8f70b194f86fa3ac46baf1000f00961cd094f8250394f83e13091a18bf012115e094f87103002840f0888194f87003002840f08381d4f88403002800f07e8142f68d41c0f24401884777e1012194f8270394f83133059094f8280394f83d23069094f8265394f82a0394f82b9394f82ce394f82db394f82e8394f82f63934235d194f8302394f83c339a422fd194f83b2396422bd194f83a23904527d194f83923934523d194f8382396451fd194f8372391451bd194f83623904217d194f8292394f835339a4211d194f83423069b93420cd194f83323059b934207d194f83223954203d111b994f82583a9e00023012284f8403384f8433384f8443384f8453384f8463384f8473384f8483384f8493384f84a3384f84b3384f84c3384f84d3384f84e3384f84f3384f8503384f8513384f8523384f8533384f8543384f8553384f8563384f8573384f8583384f8593384f85a3384f85b3384f85c3384f85d3384f85e3384f85f3384f8603384f8613384f8623384f8633384f8643384f8653384f8663384f8673384f8683384f8693384f86a3384f86b3384f86c3384f86d3384f86e3384f83f2384f8415384f84203dcf8002047f61803170a84f8432384f84473170c120e84f846230822c2f2070384f8457384f86f231a6d4bf67c57c0f2720704f22631ba4204f2323a1bd15a6ccab140f6b803c2f200031a689ab1182d00f0cf83172d40f0db83fe2804f2473c0d4600f0fc83002840f0068400980df0dafe294602e0022084f8400350460c22fef7cbf994f8258394f86fa384f83e8345f64d50c0f246008047811eb1fa81f14fea511b012808bf4ff0020bbaf1000f5ad004f23f3007a9049040f261400631c0f2470003910aa9023100254ff00309a0f5b84000240291019015e000bf029807a91a468df828908df82980fef795f947f00802019ff0200aa90023b8470334e0b25045b1462fd2aaeb0400c7b20420032f28bf4f468df81c0005983a468df81d0006988df81fb08df81e0004988df8204050fa84f103988df821a08df822508df823508df82450fef767f9b81dc345c3b24ff00306c2d14ef60b670120f02107aac0f24707c9e7bff35f8f00994ff29c574ef66c6940f2030a0020c2f22907ccf2ff09cff6807a08703d68bff35f8f05ea0a00b0f1005f59d12868484556d16868b0f57e7f52d105f575700021bff35f8f50e8006f40e80012002af9d147f64c60bff35f8fc2f207000468b6f1004f0fd0b84603f023fc58b1002e00f0f58095f8ec03320a002800f08b8195f8ed1394e195f8ec03e8b147f61800c2f207000068b8b145f60960c2f207000478002040f261430a9007900aa907aac0f247032046984707990a9a43f69b53c0f24e0320469847002085f8ee0385f8ec03d5f8d80320b142f68d41c0f244018847d7f80080bff35f8f08ea0a00b0f1005f40f0ac80d8f80000484540f0a780d8f80400b0f57e7f40f0a18098f8700338b1002088f86801c8f864014db0bde8f08f98f86801002800f07f80d8f86441002c7ad040f6b800c2f20000066807a802f019f9002e00f08081304621464ff416324ff6ff750696fef7a9f8002747f67f767f2406e048f2a351c0f24501bff32f8f88474ff29c50c2f22900d0f800b0bff35f8f0068bff35f8f00ea0a01b1f1005f06d10168494503d14168b1f57e7f63d04ff47e7004f0eafb002802f0c1806ff0070100bf42180831b1f57c7f177257729772d772177357739773d773f2d14ff47e71416001214ff29c52c0f800908173a0f8c46180f8c341058445848584c584058545858585c585058645868586c586058745878587c587c2f2290252e8001f5945a7d1bff35f8f42e8000121b352e8001f5945f8d09de798f86a0170b1d8f86c0140b147f64c61c2f207010968401a002802f38d80002088f86a0140f6a120c0f2470080474db0bde8f08f95f8ec03002840f0db803be7817b002942f06080027f0021002a8df8281000f026824ff29c550aaac2f22905535c002b00f0908253185f78002f00f04e829f78002f00f04c82df78002f00f04a821f79002f00f048825f79002f00f046829f79002f00f04482df79002f00f042821f7a002f00f040825f7a002f00f03e829f7a002f00f03c82df7a002f00f03a821f7b002f00f038825f7b002f00f036829f7b002f00f03482df7b002f00f032821f7c002f00f030825f7c002f00f02e829f7c002f00f02c82df7c002f00f02a821f7d002f00f028825f7d002f00f026829f7d002f00f02482df7d002f00f022821f7e002f00f020825f7e002f00f01e829f7e002f00f01c82df7e002f00f01a821f7f002f00f018825f7f002f00f016829f7f002f00f01482db7f002b00f01282203160297ff47baf31e20120a5f8ec0340f20220a5f8f0030220002185f8ef03c5f8e01302f00103c6f300208b42c6f34b2206d123b395f8f233f7b2bb421fd00ce05bb995f8ef13a5f8ea2385f8f013022185f8f113c5f8dc4311e095f8ef3385f8f03385f8f163a5f8ea23c5f8dc4331b9012185f8ee13c6f34951a5f8e813002804bf002185f8ee1385f8ed0385f8f26395f8ee1341b395f8680160b1d5f8e403bff35f8fb5f8e8136ff39f20884216d195f8ee13c1b195f8ef633ee0002088f86801c8f8640188f86a01012088f8690140f6a120c0f24700804701f076bf002085f8ee03c5f8dc43d5f8dc13b5f8ea0395f8f163611a81421ed28902b1fbf0f04ff4406395f8f01300fb00f2a3eb40005043000d721a00fb02f3002b4ff4007344bf4ff60063cff6ff7310fb0230c21700eb925001eb9026002147f61800c2f207000068e0b1d5f8e003f4b2a0421ad0002040f261430a9007900aa907aac0f247032046984707990a9a43f69b53c0f24e0320469847c5f8e04395f8ee1302e00020c5f8e003d5f8d80385f8ef6311b14ff47a7108e095f8f113f2b28a424ff0280108bf4ff47a7142f68d42c0f24402403a904795f8ee034746c8b13868bff35f8f00ea0a01b1f1005f41f003870168494541f0ff864168b1f57e7f41f0fa86002180f86811c0f864114db0bde8f08f95f8ed0300287ff4adadf0b20228ddd140f6b800c2f2000001680029d6d001684ff416322139002301f8403f403a01f81f3c01f81e3c01f81d3c01f81c3c01f81b3c01f81a3c01f8193c01f8183c01f8173c01f8163c01f8153c01f8143c01f8133c01f8123c01f8113c01f8103c01f80f3c01f80e3c01f80d3c01f80c3c01f80b3c01f80a3c01f8093c01f8083c01f8073c01f8063c01f8053c01f8043c01f8033c01f8023c01f8013c4b708b70cb700b714b718b71cb710b724b728b72cb720b734b738b73cb730b744b748b74cb740b754b758b75cb750b764b768b76cb760b774b778b77cb7781f820309cd100684ef217310a904ff416300b900aa8c0f247018847474661e700980d460df07afc10b302304ff0030008bf022084f840032946fff736bc84f87003dcf800204ef660231a44c4f88023b8b100980d460df03ffe0df013fe294660b9fff722bc4ff29c55c2f2290595e00df008fe002829463ff417ac0320fff712bc002084f86a01fff70fbc18684a4600eb0b20704400eb084000eb06616046fdf7d2fd0ee04eea0b2141ea084141ea066361464a460df007fc00281cbf032084f8400309f1080084f86f032946fff7ecbb01313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2921d84ff0520353541dd00a4445235e29537018d04f235d29937014d052235c29d37010d044235b2913710cd045235a29537108d052235929937104d020235829d37141f0d08200218df887100121427f002a00f0c28000220aab9f5c002f00f0a0809f187e78002e5ed0be78002e5dd0fe78002e5cd03e79002e5bd07e79002e5ad0be79002e59d0fe79002e58d03e7a002e57d07e7a002e56d0be7a002e55d0fe7a002e54d03e7b002e53d07e7b002e52d0be7b002e51d0fe7b002e50d03e7c002e4fd07e7c002e4ed0be7c002e4dd0fe7c002e4cd03e7d002e4bd07e7d002e4ad0be7d002e49d0fe7d002e48d03e7e002e47d07e7e002e46d0be7e002e45d0fe7e002e44d03e7f002e43d07e7f002e42d0be7f002e41d0ff7f002f40d02032602a7ff49aaf54e001323ae0023238e0033236e0043234e0053232e0063230e007322ee008322ce009322ae00a3228e00b3226e00c3224e00d3222e00e3220e00f321ee010321ce011321ae0123218e0133216e0143214e0153212e0163210e017320ee018320ce019320ae01a3208e01b3206e01c3204e01d3202e01e3200e01f325f2a15d84ff053079f5411d013444b275e2a5f700cd049275d2a9f7008d050275c2adf7004d020275b2a1f7140f0f08100228df887200131827f002a00f0be8000210aaa535c002b00f0a08053185f78002f5ed09f78002f5dd0df78002f5cd01f79002f5bd05f79002f5ad09f79002f59d0df79002f58d01f7a002f57d05f7a002f56d09f7a002f55d0df7a002f54d01f7b002f53d05f7b002f52d09f7b002f51d0df7b002f50d01f7c002f4fd05f7c002f4ed09f7c002f4dd0df7c002f4cd01f7d002f4bd05f7d002f4ad09f7d002f49d0df7d002f48d01f7e002f47d05f7e002f46d09f7e002f45d0df7e002f44d01f7f002f43d05f7f002f42d09f7f002f41d0db7f002b40d0203160297ff49aaf50e001313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2911d84ff0440353540dd00a4455235e29537008d050235d29937004d020235c29d37040f0098100218df8871001216a6846f23f53c5f28803b3eb520f40f08b80d20700f08d8000210aaa535c002b00f0858153185f78002f00f0f9809f78002f00f0f980df78002f00f0f9801f79002f00f0f9805f79002f00f0f9809f79002f00f0f980df79002f00f0f9801f7a002f00f0fc805f7a002f00f0fc809f7a002f00f0fc80df7a002f00f0fc801f7b002f00f0fc805f7b002f00f0fc809f7b002f00f0fc80df7b002f00f0fc801f7c002f00f0fc805f7c002f00f0fc809f7c002f00f0fc80df7c002f00f0fc801f7d002f00f0fc805f7d002f00f0fc809f7d002f00f0fc80df7d002f00f0fc801f7e002f00f0fc805f7e002f00f0fc809f7e002f00f0fc80df7e002f00f0fc801f7f002f00f00d815f7f002f00f00b819f7f002f00f00981db7f002b00f00781203160297ff47baf1de14cf67e22caf210126a60002940f0198100210aaa535c002b00f0dc8053185f78002f61d09f78002f60d0df78002f5fd01f79002f5ed05f79002f5fd09f79002f60d0df79002f61d01f7a002f62d05f7a002f63d09f7a002f64d0df7a002f68d01f7b002f69d05f7b002f6ad09f7b002f6bd0df7b002f6cd01f7c002f6dd05f7c002f6ed09f7c002f6fd0df7c002f70d01f7d002f71d05f7d002f72d09f7d002f73d0df7d002f74d01f7e002f75d05f7e002f76d09f7e002f77d0df7e002f78d01f7f002f79d05f7f002f7ad09f7f002f7bd0db7f002b7cd0203160297ff49aaface000211171f6e6013173e0023171e003316fe004316de0013184e0053169e0023180e0063165e003317ce0073161e0043178e008315de0053174e0093159e0063170e00a3155e007316ce000225a710fe60b314ee0083165e00c314ae0093161e00d3146e00a315de00e3142e00b3159e00f313ee00c3155e010313ae00d3151e0113136e00e314de0123132e00f3149e013312ee0103145e014312ae0113141e0153126e012313de0163122e0133139e017311ee0143135e018311ae0153131e0193116e016312de01a3112e0173129e01b310ee0183125e01c310ae0193121e01d3106e01a311de01e3102e01b3119e01f315f2931d84ff04f0353542dd00a444b235e29537028d020235d29937024d00021d17024e01c3104e01d3102e01e3100e01f315f2918d84ff04103535414d00a444c235e2953700fd05d2993700cd04f235c29d37008d043235b29137104d020235a29537140f08e8700218df8871000220df1280b1bf80210002900f0a1800beb0203597800295ed0997800295dd0d97800295cd0197900295bd0597900295ad09979002959d0d979002958d0197a002957d0597a002956d0997a002955d0d97a002954d0197b002953d0597b002952d0997b002951d0d97b002950d0197c00294fd0597c00294ed0997c00294dd0d97c00294cd0197d00294bd0597d00294ad0997d002949d0d97d002948d0197e002947d0597e002946d0997e002945d0d97e002944d0197f002943d0597f002942d0997f002941d0d97f002940d02032602a7ff498af43e001323ae0023238e0033236e0043234e0053232e0063230e007322ee008322ce009322ae00a3228e00b3226e00c3224e00d3222e00e3220e00f321ee010321ce011321ae0123218e0133216e0143214e0153212e0163210e017320ee018320ce019320ae01a3208e01b3206e01c3204e01d3202e01e3200e01f325f2a04d84ff077010bf8021003d100218df8871003e00beb020100224a70076900231bf80310002900f0a2800beb0302517800295fd0917800295ed0d17800295dd0117900295cd0517900295bd0917900295ad0d179002959d0117a002958d0517a002957d0917a002956d0d17a002955d0117b002954d0517b002953d0917b002952d0d17b002951d0117c002950d0517c00294fd0917c00294ed0d17c00294dd0117d00294cd0517d00294bd0917d00294ad0d17d002949d0117e002948d0517e002947d0917e002946d0d17e002945d0117f002944d0517f002943d0917f002942d0d17f002941d02033602b7ff498af60233ce001333ae0023338e0033336e0043334e0053332e0063330e007332ee008332ce009332ae00a3328e00b3326e00c3324e00d3322e00e3320e00f331ee010331ce011331ae0123318e0133316e0143314e0153312e0163310e017330ee018330ce019330ae01a3308e01b3306e01c3304e01d3302e01e3300e01f334ff0010a0a2f21d364214ff47a7242f210740aeb8a067500b7fbf5f60a2e14d30afb01f6b7fbf6f50a2d0cd30afb02f6b7fbf6f50a2d06d30afb04fab7fbfaf6092ee6d802e0b24600e0aa465f2b994698bf4ff05f095e2b6bd8c9f1000b0433b7fbfafe0aa90ef130021944baf1090f01f8042c51d94cf6cd420beb030cccf6cc42bcf1030faafb025450d00efb1a77e608b7fbf6f4baf1640f04f1300501f8035c3dd348f21f52c5f2eb12bcf1020faafb02253bd004fb16776e09b7fbf6f4baf57a7f04f1300201f8022c2bd344f6d352c1f26202bcf1010faafb022526d004fb1677ae09b7fbf6f442f2107504f13002aa4501f8012c18d341f25971cdf2b711aafb0112043304fb16770beb030104294fea523aa3d109e0a3f1030906e0a3f1020903e0a3f1010900e099460df1280b00270bf809701bf80710002900f0a1800beb0704617800295ed0a17800295dd0e17800295cd0217900295bd0617900295ad0a179002959d0e179002958d0217a002957d0617a002956d0a17a002955d0e17a002954d0217b002953d0617b002952d0a17b002951d0e17b002950d0217c00294fd0617c00294ed0a17c00294dd0e17c00294cd0217d00294bd0617d00294ad0a17d002949d0e17d002948d0217e002947d0617e002946d0a17e002945d0e17e002944d0217f002943d0617f002942d0a17f002941d0e17f002940d02037602f7ff498af52e001373ae0023738e0033736e0043734e0053732e0063730e007372ee008372ce009372ae00a3728e00b3726e00c3724e00d3722e00e3720e00f371ee010371ce011371ae0123718e0133716e0143714e0153712e0163710e017370ee018370ce019370ae01a3708e01b3706e01c3704e01d3702e01e3700e01f375f2f13d84ff075010bf807100ed00beb070173225e2f4a7008d020225d2f8a7004d070225c2fca7040f09e8000218df88710d0f814a04ff000091bf80910002900f0c7800beb09056978002962d0a978002962d0e978002962d02979002962d06979002962d0a979002962d0e979002962d0297a002962d0697a002962d0a97a002962d0e97a002962d0297b002962d0697b002962d0a97b002962d0e97b002965d0297c002965d0697c002965d0a97c002965d0e97c002965d0297d002965d0697d002965d0a97d002965d0e97d002965d0297e002965d0697e002965d0a97e002965d0e97e002965d0297f002965d0697f002965d0a97f002965d0e97f002965d009f12009b9f1600f7ff496af4ff060095ee009f101095be009f1020958e009f1030955e009f1040952e009f105094fe009f106094ce009f1070949e009f1080946e009f1090943e009f10a0940e009f10b093de009f10c093ae009f10d0937e009f10e0934e000220a7161e709f10f092ee009f110092be009f1110928e009f1120925e009f1130922e009f114091fe009f115091ce009f1160919e009f1170916e009f1180913e009f1190910e009f11a090de009f11b090ae009f11c0907e009f11d0904e009f11e0901e009f11f090127baf10a0f23d364264ff47a7342f2107c07eb87014d00bafbf5f10a2912d307fb06f4bafbf4f10a290ed307fb03f1bafbf1f20a2a0ad307fb0cf7bafbf7f10929e6d804e02f4602e0274600e00f46b9f15f0f494698bf5f21b9f15e0f6cd8c1f1000e09f104090591bafbf7f6dc4606f13001cb44092f0bf8041c52d94cf6cd410eeb0903ccf6cc41032ba7fb011246d006fb17a1d608b1fbf6f2642f02f130050bf8035c40d348f21f54c5f2eb14022ba7fb044533d002fb16116e09b1fbf6f2b7f57a7f02f130040bf8024c2fd3012b44f6d353c1f26203a7fb03431fd002fb16129b09b2fbf3f642f2107406f13001a7420bf8011c1dd341f25971cdf2b711a7fb011409f1040906fb132a0eeb090104294fea5437e346a6d105990ce0059909e0a9f1030106e0a9f1020103e0a9f1010100e04946e34600270bf801701bf80710002900f0a1800beb0704617800295ed0a17800295dd0e17800295cd0217900295bd0617900295ad0a179002959d0e179002958d0217a002957d0617a002956d0a17a002955d0e17a002954d0217b002953d0617b002952d0a17b002951d0e17b002950d0217c00294fd0617c00294ed0a17c00294dd0e17c00294cd0217d00294bd0617d00294ad0a17d002949d0e17d002948d0217e002947d0617e002946d0a17e002945d0e17e002944d0217f002943d0617f002942d0a17f002941d0e17f002940d02037602f7ff498af5ee001373ae0023738e0033736e0043734e0053732e0063730e007372ee008372ce009372ae00a3728e00b3726e00c3724e00d3722e00e3720e00f371ee010371ce011371ae0123718e0133716e0143714e0153712e0163710e017370ee018370ce019370ae01a3708e01b3706e01c3704e01d3702e01e3700e01f375f2f1fd84ff075010bf807101ad00beb070173225e2f4a7014d020225d2f8a7010d074225c2fca700cd031225b2f0a7108d030225a2f4a7104d02022592f8a7140f0948200218df88710d0f8cc0300271bf80710002900f0a2800beb0704617800295fd0a17800295ed0e17800295dd0217900295cd0617900295bd0a17900295ad0e179002959d0217a002958d0617a002957d0a17a002956d0e17a002955d0217b002954d0617b002953d0a17b002952d0e17b002951d0217c002950d0617c00294fd0a17c00294ed0e17c00294dd0217d00294cd0617d00294bd0a17d00294ad0e17d002949d0217e002948d0617e002947d0a17e002946d0e17e002945d0217f002944d0617f002943d0a17f002942d0e17f002941d02037602f7ff498af60273ce001373ae0023738e0033736e0043734e0053732e0063730e007372ee008372ce009372ae00a3728e00b3726e00c3724e00d3722e00e3720e00f371ee010371ce011371ae0123718e0133716e0143714e0153712e0163710e017370ee018370ce019370ae01a3708e01b3706e01c3704e01d3702e01e3700e01f3701250a2820d364214ff47a7642f2107305eb85025400b0fbf4f20a2a13d305fb01f2b0fbf2f40a2c0bd305fb06f2b0fbf2f40a2c05d35d43b0fbf5f2092ae7d802e0154600e025465f2fbe4698bf4ff05f0e5e2f40f28c80069d00200bf80e001bf80010002900f02b810beb00025178002900f0e8809178002900f0e680d178002900f0e4801179002900f0e2805179002900f0e0809179002900f0de80d179002900f0dc80117a002900f0da80517a002900f0d880917a002900f0d680d17a002900f0d480117b002900f0d280517b002900f0d080917b002900f0ce80d17b002900f0cc80117c002900f0ca80517c002900f0c880917c002900f0c680d17c002900f0c480117d002900f0c280517d002900f0c080917d002900f0be80d17d002900f0bc80117e002900f0ba80517e002900f0b880917e002900f0b680d17e002900f0b480117f002900f0b280517f002900f0b080917f002900f0ae80d17f002900f0ac80203060287ff479afb4e0cef1000907f1040a42f2107cb0fbf5f60beb0a0706f13001092d07f8041c4fd94cf6cd4209eb0a01ccf6cc420329a5fb02433ff459af06fb1500de08b0fbf6f3642d03f1300407f8034c3cd348f21f52c5f2eb120229a5fb02243ff445af03fb16006609b0fbf6f3b5f57a7f03f1300207f8022c2ad3012944f6d351c1f26201a5fb01213ff430af03fb16008909b0fbf1f3654503f1300207f8012c19d341f25972cdf2b7120af1040aa5fb022403fb110009eb0a0104294fea5435a6d113e7aaf1030e10e7aaf1020e0de7aaf1010e0ae7d64608e701303ae0023038e0033036e0043034e0053032e0063030e007302ee008302ce009302ae00a3028e00b3026e00c3024e00d3022e00e3020e00f301ee010301ce011301ae0123018e0133016e0143014e0153012e0163010e017300ee018300ce019300ae01a3008e01b3006e01c3004e01d3002e01e3000e01f305f280ad84ff075010bf8001005d00beb000173225e284a7060d100208df887000aaf42f2941645f29c14284602213a46c2f22006c2f213040cf0c8fe00208df8280038460df040f828460e213a460cf0bdfe4ff6a42040f6b801cff6ff70c2f200010858a04269d14ff6b020cff6ff700858b0f54d2f61d14ff6b420cff6ff700858a0425ad145f610634ff0000ec2f213034cf6394406f1040c00274ff0ff3263454bd8186830f003051ad09e4228bf0c2845d3f11a8d424ff0ff3142d8bd42394688bf2946c00703eb05001cbf0f46ae44013c00f10403e2d12fe0002088709ee70421b7f5807f21d300223d46b5f5007f17d3b5f5806f16d3b5f5006f15d30901b2eb153f4fea1515f0d10fe00022ca716be500219171fff771b800211172fef72fbd490002e0890000e0c900634504d1484207ea0002714603e04ff0ff324ff0ff3147f64c60c2f20700d0f8840006f1080342f6941c9842c2f2270c4cd142f610674ff0000bc2f2200746f6b9700cf1040e00244ff0ff3a4ff0ff3977453bd83e6836f0030515d0bc4528bf0c2e35d3aceb07039d4233d82346a54288bf2b46f6071cbf1c46ab447b19013803f10407e4d121e00420b4f5807f16d300262546b5f5007f0cd3b5f5806f0bd3b5f5006f0ad30001b6eb153f4fea1515f0d104e0400002e0800000e0c000774504d1404204ea000ad94603e04ff0ff3a4ff0ff394ff6882040f6b807cff6ff70c2f200073b580cf10800834264d14ff69423cff6ff73fb58b3f5333f5cd14ff69823cff6ff73fb58834255d14ff29c5043f21063c2f229004ff0000bc2f2270342f6f935a0f1040ca0f1080e0024634542d81e6836f003071ad09e454ff0ff30059028bf0c2e3ad3aeeb030087424ff0ff3034d82046a74288bf3846f6071cbf0446bb44d819013d00f10403dfd123e00427b4f5807f17d34ff0000e2546b5f5007f0cd3b5f5806f0bd3b5f5006f0ad33f01beeb153f4fea1515f0d104e07f0002e0bf0000e0ff00634505d17b4204ea03000590584602e04ff0ff300590064666208df8280072208df8290065208df82a008df82b002f208df82c006d204b238df82d0061208df8313069238df82e0078208df83230422356278df82f0020208df833303a238df8377047270aac8df830008df834308df835004c238df838708df83a00002720468df836308df839308df83b700cf0fdffe05d002800f0a080e019417800295ed0817800295dd0c17800295cd0017900295bd0417900295ad08179002959d0c179002958d0017a002957d0417a002956d0817a002955d0c17a002954d0017b002953d0417b002952d0817b002951d0c17b002950d0017c00294fd0417c00294ed0817c00294dd0c17c00294cd0017d00294bd0417d00294ad0817d002949d0c17d002948d0017e002947d0417e002946d0817e002945d0c17e002944d0017f002943d0417f002942d0817f002941d0c07f002840d02037602f7ff49aaf64e001373ae0023738e0033736e0043734e0053732e0063730e007372ee008372ce009372ae00a3728e00b3726e00c3724e00d3722e00e3720e00f371ee010371ce011371ae0123718e0133716e0143714e0153712e0163710e017370ee018370ce019370ae01a3708e01b3706e01c3704e01d3702e01e3700e01f375f2f25d84ff02000e05521d0e01945215e2f41701cd076215d2f817018d065215c2fc17014d06e215b2f017110d048215a2f41710cd07521592f817108d06221582fc17104d02021572f017240f0f98000208df887002046494652460cf029ff069d0020215c002900f0a08021184a78002a5ed08a78002a5dd0ca78002a5cd00a79002a5bd04a79002a5ad08a79002a59d0ca79002a58d00a7a002a57d04a7a002a56d08a7a002a55d0ca7a002a54d00a7b002a53d04a7b002a52d08a7b002a51d0ca7b002a50d00a7c002a4fd04a7c002a4ed08a7c002a4dd0ca7c002a4cd00a7d002a4bd04a7d002a4ad08a7d002a49d0ca7d002a48d00a7e002a47d04a7e002a46d08a7e002a45d0ca7e002a44d00a7f002a43d04a7f002a42d08a7f002a41d0c97f002940d0203060287ff49aaf5be001303ae0023038e0033036e0043034e0053032e0063030e007302ee008302ce009302ae00a3028e00b3026e00c3024e00d3022e00e3020e00f301ee010301ce011301ae0123018e0133016e0143014e0153012e0163010e017300ee018300ce019300ae01a3008e01b3006e01c3004e01d3002e01e3000e01f305f281cd84ff02001215418d021184f225e284a7013d074225d288a700fd068225c28ca700bd065225b280a7107d072225a284a7103d0202259288a7128d100208df887000aac059a204631460cf05bfe28461a2122460cf08cfb002088f86801c8f8640106984ef217310a904ff416300b900aa8c0f247018847012088f86a0107a800f0dcf8c8f814004db0bde8f08f0020c871d6e70021417206e700bf2de9f04f81b0009041f204024cf65560cef20002ccf2ac50c2f8ac0f4ef6fc50cef2000001684ef66c6641f08071016052f8040c4ff29c57ccf2ff06c2f229074ff6ff7440f0010000254ff0010b47f67f784ff07f0942f8040c06e048f2a351c0f24501bff32f8f8847d7f800a0bff35f8f3868bff35f8f01466ff39601b1f1005f06d10168b14203d14168b1f57e7f3ed04ff47e7002f0b7fa002875d06ff0070100bf42180831b1f57c7f157255729572d572157355739573d573f2d14ff47e710660416080f80eb0a0f8c48180f8c391048444848484c484048544858485c485048644868486c486048744878487c48757e8001f5145b0d1bff35f8f00bf47e8000121b157e8001f5145f8d0a5e78169d1bb47f64c6245f6e466c2f20702cff6f8761368314617689f420ed117689f420bd117689f4208d117689f4203d1002901f10401efd19f421ed041f20401cef200010b6817681168b9420ed11168b9420bd11168b94208d11168b94203d1002e06f10406efd1b94206d041f20401cef200010968c91a816141f20400cef2000000680099086001b0bde8f08f00bf2de9f04f83b041f20401cef200014ef66c674ff29c5609680068ccf2ff07c2f229064ff6ff7400254ff0010847f67f794ff07f0a0291019007e000bf48f2a351c0f24501bff32f8f8847d6f800b0bff35f8f3068bff35f8f01466ff39601b1f1005f06d10168b94203d14168b1f57e7f3ed04ff47e7002f0f7f9002800f093806ff0070142180831b1f57c7f157255729572d572157355739573d573f2d14ff47e710760416080f80e80a0f8c49180f8c3a1048444848484c484048544858485c485048644868486c486048744878487c48756e8001f5945b0d1bff35f8f00bf46e8000121b156e8001f5945f8d0a5e7816961b144f6d350c1f26200a1fb0001880901284ff0010088bf88094ce047f64c6245f6e466c2f20702cff6f8761368314600bf17689f420ed117689f420bd117689f4208d117689f4203d1002901f10401efd19f422ed041f20401cef200010b6817681168b9420ed11168b9420bd11168b94208d11168b94203d1002e06f10406efd1b94216d041f20401cef20001096844f6d357ca1ac1f26207a2fb07768261b00901284ff0010088bfb009994208bffa2000e0fa20dde90121891ab1fbf0f003b0bde8f08f2ab1a2fb0103002b1cbf0020704702fb01f0ffe7b0b54ff2a054c2f229040146206846f23f52c5f28802b2eb500f40f258304df681124cf67e25c2f20000c0f24802caf2101518bf25609047002804bf691c2160b0bd00bf0846ffe7014640f258304df69f22c2f20000c0f248021047002855d1002953d0082a51d30b78aa2b4ed18b79f02b4bd12de9f04182b045f64d550b2ac0f2460547d3c878a2f10803834242d14878212841d1087901283ed1487901283bd1c879c8bb0c4614f8080f10f03c0f33d18818884610f8021c10f8010c164641ea0027a2f10a0081b220460bf058f8874222d1a847811eb1fa81f14f09012808bf0227002f4ad0207887f00301084247d0012039464246334600f027f90446002898f8080018bf06243be04ff27143c0f24c0318470b2400e00a24a847811eb1fa81f14e09012808bf02261eb3304600f090f8f8b10546407ce0b10027284631463246032300970bf0d2f8686840b14bf69b71c0f25d0188476868fff774ff6f602868af75002818bffff76dff00202860a8602882204602b0bde8f0810624f9e700243842f6d0404631463a463b4600f0fef8002818bf0446ece70b291dd3c278a1f10803934218d10278aa2a13d14278212a10d10279012a0dd14279012a0ad18279f02a07d1c2792ab9024612f8083f13f03c0f03d00a2070470b20704710b5084410f8023c10f8010c43ea0024a1f10a0081b210460af0c2ff201a18bf0a2010bd002808bf7047b0b582b00446407cd0b100252046032300950bf068f8606840b14bf69b71c0f25d0188476068fff70aff65602068a575002818bffff703ff00202060a060208202b0bde8b040704700bf2de9f04f81b04ef66c654ff29c56ccf2ff05c2f229064ff6ff7700244ff0010a47f67f7b4ff07f08009006e048f2a351c0f24501bff32f8f8847d6f80090bff35f8f3068bff35f8f01466ff39601b1f1005f06d10168a94203d14168b1f57e7f3dd04ff47e7001f0efffb8b36ff0070142180831b1f57c7f147254729472d472147354739473d473f2d14ff47e710560416080f80ea0a0f8c4b180f8c381078447848784c784078547858785c785078647868786c786078747878787c78756e8001f4945b2d1bff35f8f00bf46e8000129b156e8001f4945f8d0a7e700200099002801eb410100eb011118bf01f51b7001b0bde8f08f00bfb0b5c4b0dc08202c03d94ff0ff3044b0b0bd0df107048df807008df80810a01c11461a461d46fbf72bfca81c4af6610582b2c0f24605f02021460023a84744b0b0bd00bf2de9f04f89b0064618469a4617468946fff758ff002800f09983044696f908000796b0f1ff3f00f003050add264616f8110f00283fd12068002818bffff73cfe2de3207c10b3607c00b34ff000082046394652460323cdf800800af081ff606848b14bf69b71c0f25d0188476068fff723fec4f80480206884f81680002818bffff71afe00202060a06020822068002818bffff711fe4ff480710020218207992060a0608978a081092004f11106e174a174257560760799a07c8978884240f0d382217da94240f0cf82411ca9f10b00627e01961e2828bf1e209042a17488bf6076a9f10200039787b20a2f4ff00005c0f0db82092241f2210809200497cdf808a017e02068049f002818bffff7d4fda089002d00f10100069d26602674a660a08118bf0625059e06eb0b0082b2ba4280f0bb82217c80b20429064600f28080079b461c9a5c4b1c0129237405dd022906d0032968d1e28106e021b9627503e0238943ea02222281be4280f09e82042966d0079a831c925d8f1c0129277406dd049fff290bd003290bd11e464ce000291cbf278947ea0222049f228102e0627500e0e281bb4280f08082022935d8079ac61cd25ccb1c0129237405dd022933d0fe2905d1627506e021b9238943ea0222228100e0e281be4280f0678202292fd0079a031d925d41f00407fc2927740add049ffd290cd0fe2903d0278947ea0222049f228105e0049f0029bed1e28100e06275bb4280f0498209b11e4610e0461d0798c25c05202074e189208941ea0221e18128b1fff71cfd0028206000f06682b4f808906089a9eb00011ffa81fbb1b27a1a5a45b8bf93465fea0b420ad022681044079a11441ffa8bf2fbf7e7fa6089b4f80890584481b2494560817ff454afd4f800a0607dbaf1000f05964ff000060df1230108bf8a460f288df8236006d8217d00f00302511ab1fa81f14e0900074ff0000706d4217e607e814238bf20760fe000bf606840b14bf69b71c0f25d0188476068fff7f0fc6760607e20760120e0820695a6b1607da67d400715d4002e4ff0000500f089811ffa89f100294ff6ff7300f00a8101295cd10020cfe000bf607d400750d4002577e14ff48030fff7a7fc002e824600f06f81a07d002800f06b81baf1000f00f067816668002e00f0fb8020890428c0f05f8121680a1812f8043c002b40f0588112f8033c002b40f0538112f8023cff2b40f04e8112f8012cff2a40f049814ff4803531607060c6f80ca03561002800f0648107464bf69b70c0f25d0000f5857230460021904740b9316931b170688d420d46ebd187420d46e8d15546002728e14ff48030fff758fc054622e14ff6fe7000ea0900ac4642426ff001000aeb0007be78ff7883ea06231eb25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead5355e0085ea430336b25d002db208ead63686ea430308ead53686ea430383ea07231fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead73787ea430308ead6365f0086ea43033fb25e0036b208ead737023087ea430308ead6371618023687ea430395d10230002765465feac97232d01af8000083ea002002b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead333420083ea400012b243001bb208ead23282ea400008ead33282ea4003e0899ab2824273d15046ddf808a05346fbf79dfa00286bd10026012378e03820fff799fb002862d00646077047708770c770077147718771c771077247728772c772077347738773c773077447748774c774077547758775c775077647768776c776077747778777c77780f8287080f8297080f82a7080f82b7080f82c7080f82d7080f82e7080f82f7080f8307080f8317080f8327080f8337080f8347080f8357080f8367080f837704ff28d60cff6ff70784430624ff2d960cff6ff70784470624bf69b70c0f25d0045f6e46200f13c0730460f21c0f27c0238230025b84738b33046fff75bfb2f46554600e05546606840b14bf69b71c0f25d0188476068fff74dfb6760ddf808a000260323a77503991ffa89f72046524600970af093fc002d294605463ff460ad0846fff737fb5be50027666077e6c5f580390027b5f5803f55463760f7607ff649aed0e70025204639465246032300950af074fc606840b14bf69b71c0f25d0188476068fff716fb65602068a575002818bffff70ffb0020307000202060a06020820a2551e00798007a40064dd5207c00b301980078e0b10399002520465246032300950af04afc606840b14bf69b71c0f25d0188476068fff7ecfa65602068a575002818bffff7e5fa00202060a06020820b252068002818bffff7dbfa00202060a060208220e001980078e0b10399002520465246032300950af01ffc606840b14bf69b71c0f25d0188476068fff7c1fa65602068a575002818bffff7bafa00202060a06020820625284609b0bde8f08f00bf2de9f041f0284bd100294ff00b0000f07f80022a7cd345f64d50c0f246000e4617468047811eb1fa81f14c09012808bf0224002c4ff00a006ad07578e91ec9b2fe2938bfbde8f081307833463946032860d002282dd001281cbf0a20bde8f081ac4204bf0020bde8f0814808842884bf0b20bde8f081881e03f1020887b240463946fff717fb002869d006462846fff76dfb21462a46fff741fb3046bde8f08145f64d57c0f2460707f5e27cbde8f0416047ac421cbf0020bde8f081a1f1210010f1160f48d36ff0480048432330c0b2242841d81a4612f8020f40f00207032f4bd19b796340032b47d10b2904d0032804bf0b20bde8f081881e4ef60b6783b2c0f247070120f021b847002818bf0620bde8f081ac422dd1a1f10c0010f1030f1ad31a4612f8020f042815d158796040032811d1d879a0f1310717f1300f0bd39b79984208d9a1f10807c01a874284bf0b20bde8f081cfe70b20bde8f081b07a204207d04046394622462b46bde8f041fff79abb0020bde8f0810a20bde8f08140f20d00c0f2000042f6653c7844c0f2440c012100220023604700bf80b582b04ff4f0704af61f4e01904ff4207cc0f2470e0020002100220023cdf800c0f04702b080bd4ff29c51c2f229010968bff35f8f0a466ff39602b2f1005f19d10a684ef66c63ccf2ff039a4212d14a68b2f57e7f0ed1d1f86c1159b147f64c62c2f207021268891a012903db0178042938bf7047002101707047b0b541f23154c0f252041d46a0474ff29c51c2f229010968bff35f8f0a466ff39602b2f1005f0cd10a684ef66c63ccf2ff039a4205d14a68b2f57e7f18bf002100e00021421c18bf002900d1b0bd95f84d20002afad091f84721002a08bfb0bd46f25863c2f206031a68132aeed8c2ebc20403eb04135b6801ebc2014ff40042c1f8e431a1f8ea212a7a01f5f271002a0fbf802248f20112ca808122ab7c33b1ab7d23b1022342f002028b71ca7195f820303bb195f8243023b1032342f004028b71ca7195f846304bb195f8443042f008020b7195f84530ca714b71b0bd48f27342c2f207021378002b14bf9378ff230b711378002b14bf5278ff224a71b0bdf0b589b048f66502c0f24b020c46054690474ff29c51c2f229010e68bff35f8f31466ff39601b1f1005f0cd131684ef66c62ccf2ff02914205d17168b1f57e7f08bf092d01d009b0f0bde1082c29fad896f847110029f6d045f64d51c0f2460107468847014638460129ecd1ff22079244f6435246f258610020cff60172c2f20601089006920b685a1e132a4fd8c3ebc30501eb05111a1fa1f5de7191f85451ad0618d4d51c42d091f8e450ad0616d4951c3cd091f87450ad0613d4551c36d00d79ad0610d4043aa1f5e071151da3f10403e3d12be05a1e01f5a87104e09a1ee03101e0da1e703106ebc203096893f9eb21b2f1ff3f1adc03f5f2731e688e4215d11e798df81b605e798df81c609b798df81e200a0a8df820108df821200a0c090e8df81d308df822208df823100f228df8012010228df80220522208218df80420b4f5804f4ff080028df800108df8061038bf4ff48042b4f5001f6ff07f0604f07f0138bf0026802c28bf80318df807109df809509df80a108df8030004d29df808200223002415e0c4f3c610b4f5804f024403d20323012400200be0b4f5001f03d204230224012003e0052303240120002135468df8053004f108038df808208df809508df80a1070b96846a222c118c254062048700c208870c81c06a90c22faf7f3fd04f117034ff225066a46c0f2470601200821b047384609b0f0bd70b582b00546ff208df8040044f25220c0f20100009040f2c960c0f2480016460c46804798b148f27e30c2f2070000880122c1b264298df8032008d80721b0f5807f38bf03218df803108df80400301b28bf08280cd3d221281929550621417005218170033069460522faf7affd0834204602b070bd00bf024600284ff0ff3009d0022918bf70471078112801d1507810b14ff0ff30704710b586b045f64d50c0f24600804701284ff000003ed1cde9020040f20830c0f210000190ff208df8140044f25220c0f20100049040f2c960c0f24800804798b148f27e30c2f2070000880122c1b264298df8132008d80721b0f5807f38bf03218df813108df8140040f2d260adf80800052001ac8df80a00e01d04a90522faf759fd4ff2250cc0f2470c0120092122460c23e04706b010bd024600284ff0ff3021d0012918bf704710781f2819d110b545f64d54c0f24604a04701281cbf002010bd4cf2b661c0f2000104f5e2747944e02029220023a047002818bf4ff0ff3010bd4ff0ff3070474ff29c50c2f22900016808466ff39600b0f1005f1ad108684ef66c62ccf2ff02904213d14868b0f57e7f0fd1d1f83c0160b147f64c62c2f207021268801a0028cebf01200020c1f83c017047002070474ff29c50c2f22900026810466ff39600b0f1005f32d110684ef66c61ccf2ff0188422bd15068b0f57e7f27d1d2f86c0120b347f64c61c2f207010968401a0028c4bf01207047d2f8701100200029c2f86c0182f86a01c2f87001c2f82003a2f88c0308bf704780b548f2a352c0f24502084690470020bde88040704700207047f0b101684ef66c62ccf2ff02914218bf704790f8461199b110b54af273644ff0000cc0f24604864680f846c10120002100220023aef844c1a446bde810406047704700bf02464ff6ab70cff6ff7042f6653c7844c0f2440c00210023604700bf70b5002866d0044600796179a279e37940ea012040ea024050ea036007d00e2803d0032856d1032502e0042500e00225fff74eff00284dd04ff29c50c2f22900066830466ff39600b0f1005f42d130684ef66c61ccf2ff0188423bd17068b0f57e7f18bf70bd45f64d50a478c0f24600804701282ed1082086f88402032086f88502102086f88602b22086f88802062086f8890286f88a02462086f88b0243204ff0000e86f88c0201204ef6057c06f5217286f887e286f88d0286f88e5286f88f42c0f2470c09210d2386f890e2bde87040604770bd00bf2de9f04f81b04ef66c694ff29c560446ccf2ff09c2f229064ff6ff77002547f67f7b4ff07f0806e048f2a351c0f24501bff32f8f8847d6f800a0bff35f8f3068bff35f8f01466ff39601b1f1005f06d10168494503d14168b1f57e7f3ed04ff47e7000f057ff002864d06ff0070100bf42180831b1f57c7f157255729572d572157355739573d573f2d14ff47e7141600121c0f800908173a0f8c4b180f8c381078447848784c784078547858785c785078647868786c786078747878787c78756e8001f5145afd1bff35f8f46e8000121b156e8001f5145f8d0a5e7002780f85b712a270821032380f85c71042780f8581180f85931102380f85d7180f85e1101214ff2250c074600f5ac7280f85a3180f85f1180f86031002c18bf0124c0f2470c012010210a2387f8614101b0bde8f04f604701b0bde8f08f00bf80b582b04ff0010ccdf800c000f002f802b080bd2de9f04381b04ff29c57c2f229073f68ddf820803c466ff39604b4f1005f10d13e684ef66c65ccf2ff05ae424ff0000904d17e68b6f57e7f08bfb946012804d013e04ff0000901280fd11c4615460e460746fff729fe2346044631462a463846002c18bfb9f1000f07d14af2736cc0f2460c01b0bde8f043604799f8460180b1b8f1010f7cd1d9f84001002189f84611a9f84411a0b342f68d41c0f2440188472ee0b9f844010121013080b2012898bf0846a9f84401d9f8400142f68d44c0f2440489f8461128b94846fff777fec9f8400140b1a047d9f84001a4f140024ff4c8719047a8b199f84601002848d0d9f84001002189f84611a9f8441100b1a0474af2736cc0f2460c0120002100220023afe745f64d50c0f24600804701282fd1082089f84801032089f84901102089f84a01002089f84b01b22089f84c01062089f84d0189f84e01462089f84f01432089f85001012089f85101b9f844014ef6057c070a09f5a47289f8528189f85301c0f2470c012009210d2389f8547178e701b0bde8f08300bf80b582b04ff0050ccdf800c0fff734ff02b080bd2de9f04f83b04568002d00f060828368002b00f05c8205eb03080024002614e047f64c63c2f207031b6845f69077c0f201073b44c6f83c310aeb0b03002443451d464ff0000680f04282a94619f9013b03f07f07a740002b46ea070610d406f00703012b16dc0bb3012b40f03082a8eb0903082bc0f02b8205f10903dee700bfc14580f02482182c04f107044d46dcd91de200bf022b3ad0052b40f01882a8eb0903042bc0f013826b1dc7e7c14580f00e8295f90130002b05f10203bed5434580f0058295f90230b3f1ff3f05f10303b4dc434580f0fb8195f90330b3f1ff3f05f10403aadc434580f0f18195f90430b3f1ff3f05f10503a0dc434580f0e78195f90530002b00f1e281ab1d96e7c14580f0dd8195f9013005f1020a002b03f07f0b3dd5c24580f0d28195f90270eb1c07f07f04b7f1ff3f4beac41b02ddd1469a462de0434580f0c28195f9037005f1040a07f07f04b7f1ff3f4bea843b01dd99461de0c24580f0b28195f9043005f1050c03f07f07b3f1ff3f4bea475b02ddd146e2460ce0c44580f0a18195f90530002b00f19c8105f1060a4bea037be146a8eb0a039b4500f29281f308822b23d0672b19d0652b7ff43fafbbf1060ffff43baf9af80030462b7ff436af99f80230432b7ff431af99f80330012b7ff42caf0290cde900211de0054650460e465946144601f0c1fe06e0054650460e465946144600f00bfb31462246284614e748f2a3513046c0f24501bff32f8f8847dde9002102984ff29c53c2f229031c68bff35f8f1e68bff35f8f33466ff39603b3f1005f0ad133684ef66c67ccf2ff07bb4203d17368b3f57e7f50d04ff47e7000f0e3fcdde9002106460298002e3ff4e4ae6ff00703002500bff7180833b3f57c7f3d727d72bd72fd723d737d73bd73fd73f2d14ef66c63ccf2ff0333604ff47e7373600123b37347f67f73a6f8c4317f2386f8c3314ff6ff734ff29c5733847384b384f38433857385b385f38533867386b386f38633877387b387f387c2f2290757e8003fa34292d1bff35f8f47e800632bb157e8003fa342f8d088e7002599f8043099f8057099f80640032b47ea042736dd052b54dc042b71d0052b7ff48caed6f86c313bb147f64c67c2f207073f68db1b002b17dcd6f87031002786f86a71c6f87071c6f82073a6f88c735bb10c4648f2a35181461846c0f245011546884721462a46484647f64c63c2f207031b6845f69077c0f201073b44c6f86c315be6012b3ff44dae022b7dd0032b7ff454ae14468946fff7bafb0346029849462246002b3ff449ae96f84631002b3ff444ae304641f28831a6f844710af0d9f943e0062b45d0072b7ff437ae81464df6db50c0f24a0016460d46804703465f1e294632464846012f3ff627ae981eb0fa80f04009fff78ffc2946324648461ce614468946fff783fb0346029849462246002b3ff412ae96f84631002b3ff40daeb6f84431bb427ff408aed6f840310027002b86f84671a6f844713ff4fead42f68d411846c0f244018847029849462246f3e5d6f87031c6f86c51002b86f86a51c6f87051c6f82053a6f88c533ff4e5ad0c4648f2a35105461846c0f245011646884721463246c1e696f84631c6f83c51002b3ff4d2ad0546d6f8400189461446002186f84611a6f8441120b142f68d41c0f2440188474af273670120002100220023c0f24607b847284622464946b4e54ff2a513c0f2490303b0bde8f04f184700bf7fb50646002806d1fff710fb002807d19de80f00064649f29b1cc0f24f0c60477fbd00bff0b583b01d46144609294ed106460f46f22d10d8a22160196155062141700b2181704bf6a141c0f20001033079440b22faf710f80e35204629464ff4807200f03df80546ff208df8080044f25220c0f20100019040f2c960c0f24800804798b148f27e30c2f2070000880122c1b264298df8072008d80721b0f5807f38bf03218df807108df80800f82d0cd8d221601961550621417005218170033001a90522f9f7d8ff0835394630464ef60577c0f2470722462b46b84703b0f0bd70b58ab00c464ff29c51c2f229010b68bff35f8f19466ff39601b1f1005f16d119684ef66c66ccf2ff06b1420fd15968b1f57e7f0bd1694605461846164601f0dffe324628462825a24231d244e04d218df8001043218df8011001218df80210002115258df803108df804108df805108df806108df807108df808108df809108df80a108df80b108df80c108df80d108df80e108df80f108df810108df811108df812108df813108df81410a24213d3111b022910d30fd003398d420cd8c22201190255062048708d70c81c69462a46f9f762ff6019c41c20460ab070bd00bf2de9f04f81b0044600f1e20900f16005663004274ff0080b00900fe004234ff22506012009212a46c0f24706b0470af10100013fbff35f8f60603dd0d4f804a02068bff35f8f824536d00af01f00792110fb0191032011f8016b84f86100102084f8620070b24ff0010884f860b0002848bf4ff00208c8f17c02b2424ff0000284f86320cad39a22b0f1ff3f84f8642084f865b084f8660001dd012003e0f00984f867000220009a10443246f9f704ff06eb0800831db2e704f124050121bff35f8f00bf55e8000f45e80012002af9d1bff35f8f00bb48f67766c0f24d060820b047a8b10146422008704b204870fe2088700020c87008714871c871887143f6ba60c2f20700007806f11c02904703e00020bff35f8f28600020bff35f8fa062e06abff35f8f38b92068bff35f8f6168bff35f8f88420ed004f128050121bff35f8f00bf55e8000f45e80012002af9d1bff35f8f10b101b0bde8f08f206a42f64d42c0f244021421904700281ebfbff35f8f0020286001b0bde8f08f2de9f04f81b00d46804600f06bf9002800f02b8145f64d50c0f246008047012840f023814ef66c6a4ff29c57ccf2ff0ac2f229074ff6ff7400264ff07f0b06e048f2a351c0f24501bff32f8f8847d7f80090bff35f8f3868bff35f8f01466ff39601b1f1005f06d10168514503d14168b1f57e7f40d04ff47e7000f0c7f9002800f0f3806ff0070142180831b1f57c7f167256729672d672167356739673d673f2d14ff47e7141600121817347f67f71c0f800a0a0f8c41180f8c3b1048444848484c484048544858485c485048644868486c486048744878487c48757e8001f4945add1bff35f8f47e8000121b157e8001f4945f8d0a3e7d0f8f413bff35f8f11b348f6776905f10800c0f24d0980b2c847002800f0a9800146422008704b204870fe20887000202a0a002dc8700d714a71c871887100f0c180042d05f0030080f096800022a7e098f80310022900f28c80074641f2040041f2040400f056f9002800f08280064607f57d7900206ff019010022b318b05432327718a24201f1320158709870d870187158719871d871187258729872d872187358739873d873187458749874d874187558759875d87587f8320087f8330087f83400d876187758779877d87783f8200083f8210083f8220083f8230083f8240083f8250083f8260083f8270083f8280083f8290083f82a0083f82b0083f82c0083f82d0083f82e0083f82f0083f8300083f83100b1d14ff6614042f66534cff6ff70c0f244047844002132460023a0470028306250d059e8000f50b9bff35f8f49e8006000283ff45faf59e8000f0028f6d0bff32f8fbff35f8f306a04f5c771884748f2a3513046c0f2450188474be701b0bde8f08f25f0030308f10107002200bfbe1816f8015c8c182572bd5c0432657275789342a572b678e672f1d180b118f8027001f1080301289f5409d0571c18f807600228de5503d0901c18f800201a5443f6ba60c2f20700007809f11c0201b0bde8f04f104748f2a3513046c0f2450101b0bde8f04f0847024600284ff0000000f08c80a1f1510313f1490fc0f0868010784b2808d15078422805d19078012802d1d3780c2b01d900207047082ba1f1080019dd0a2b26dc092b3bd00a2b57d104281cbf00207047107a517a08434ff0000008bf7047917ad27a41ea0221b1f5007f98bf01207047042b1ad0072b43d0082b3dd101284ff000004fd1117a022938bf012070470b2b25d00c2b30d1002804bf00207047117a1029c5d84900013125e007284ff0000038d1117a042938bf012070470428b7d1107a517a50ea01214ff000002ad0937ad27a43ea02228a4228bf01207047a1f10c001228a4d8117a537a1943a0d0917a01299dd8d17a401ab0fa80f04009704703284ff000000dd1117a537a927a41ea032141ea024144f24022c0f20f02914238bf0120704700bfb0b54ff2a054c2f22904216846f23f52c5f28802b2eb510f48f25f514cf67e25c0f24501caf2101518bf25608847002804bf691c2160b0bd2de9f04f87b04ff29c50c2f229000068bff35f8f02466ff39602b2f1005f17d102684ef66c63ccf2ff039a4210d14268b2f57e7f0cd1d0f8f44300294ff00000bff35f8f18bf002c06d107b0bde8f08f002007b0bde8f08f8878fe2826d1088844f64232904221d108794a7940ea0225aab2002a4ed0502a00f2988101f108000e461146fff70cff002800f08f81f17a307b737b3246012940ea032900f04f81002940f0b08194f856004be1204600f003fc94f8561039b994f8571021b994f85a10002900f0f2800121bff35f8fe16204f128050122bff35f8f00bf55e8001f45e80023002bf9d10029bff35f8facd10646206a42f64d42c0f244021421904700281ebfbff35f8f00202860304607b0bde8f08f0020bff35f8f606247f64c60c2f207000568606900284bd0281a49d494f85600e6688df8120094f8570094f858108df8130094f859008df814108df8150094f85c0094f85a108df81700300a8df81900300c8df81a00300e8df81b000a20628e02900df112008df81610019000272046012108238df81860009709f007fde068b04208bf26616761e765678684f8597094f8571061b194f85b0048b901204ef2f53384f85b00c0f24c0303201322984794f85a00002860d0e069281a5dd446f6cc10c2f207000078002856d143f63c40c2f20700817a29b10178ff2902d14178ff294ad090f83a1039b190f83010ff2903d190f83110ff293fd090f86a1039b190f86010ff2903d190f86100ff2834d0002784f85a7094f85600e6688df8120094f8580094f857108df8140094f85c008df813108df81700300a8df81900300c8df81a00300e94f859108df81b000a2002900df112008df81510019020460121002208238df816708df81860009709f08dfce068b04208bf2661a069281ab0f57a7fc0f28980a56194f8560094f85720b8b194f85a101ee0e16822698b1a18bf01239142bff35f8fe3627ff407af2168bff35f8f6268bff35f8f91423ff4bbaefce694f85a1032b921b9e1682269914262d0002100228df8120094f85800e5688df8140094f85c008df813208df81700280a8df81900280c8df81a00280e94f859208df81b000a2002900df112008df815208df816108df81850019000272046012100220023009730e0012084f856008df8120094f85700e5688df8130094f8590094f858108df8150094f85c008df814108df81700280a8df81900280c8df81a00280e94f85a108df81b000a2002900df1120000268df816108df8185001901ffa89f2204601210023009609f0fefbe068a84208bf256194f8560030b994f8570018b994f85a0000284ad00120bff35f8fe06204f128050121bff35f8f00bf55e8000f45e80012002af9d1bff35f8f58b9206a42f64d42c0f244021421904718b10020bff35f8f2860012007b0bde8f08f907bd37b278e40ea0320b84233d1022961d1002384f8563094f85710a4f85e30002984f8593084f85d3000f0a88094f85b00002840f0a38001204ef2f53384f85b00c0f24c03032013229847002396e0e0682169421a18bf01228842bff35f8fe262aed12068bff35f8f6168bff35f8f8842a6d1c0e794f85600e5688df8120094f8570094f858108df8130094f859008df814108df8150094f85c0094f85a108df81700280a8df81900280c8df81a00280e8df81b000a2002900df112008df816108df81850019000271ffa89f22046012104232ee794f8560078b3052938d0042902f110082bd0032941d194f85a0068bb94f8570050bb09f023fb38b3012047f64c6184f85a00c2f20701096841f6583211448df8120041f2883049f61347e161002500900df11202c0f257070120002101230195b8472b4620e002231ee094f8570018b994f85a00002859d0032315e094f85710002000294ff00003a4f85e0084f8590084f85d007ff460af06e094f8580010b194f85b0078b3062394f85600e5688df8120094f8570094f858108df8130094f859008df814108df8150094f85c0094f85a108df81700280a8df81900280c8df81a00280e8df81b000a2002900df112008df81610019000271ffa89f2204601218df81850abe608292bd0072916d006293ad194f8570009f053fc68b947f64c60c2f2070000684ef660216ee0307c1136314609f0e9fbe8b30346b5e794f85e00002800f0cd80002584f85e5094f8570046f28563c0f24e030321424698472b46a2e794f85f00002800f0ba80002584f85f5094f8570098f8001040f23922c0f2550290472b468fe794f85900002840d00c2940d198f80080b8f1000f55d006f11100b8f1040f08f0030e039051d20023002577e098f8005044f2a932c0f248022846314690474df249270346c0f251070120294632460125b847011f11f1030f01d2052360e784f85700208e47f23051013080b2012888bf054647f64c602586c2f207000068a4f832900844606100234ae7072348e794f85c0000287ff42caf327c737cb77cf07c42ea032247ea00230929a4f83290a2865bd00a295bd118044ff0060008bf05205be0002384f85d302ae708f0fc0a0023002506eb450797f811b0ba7cf87c397d42ea0b0241ea000b797db87d97f817c03f7e120640ea010008bf01235fea0b6247ea0c0108bf0123000608bf0123002905f1040508bf0123aa45dad1bef1000f18d0039901eb450011f8157045782f4308bf0123bef1010f0cd08778c5782f4308bf0123bef1020f04d007794079384308bf0123180401d00123e1e6b8f1040f84f85d802bd2002247e0022005e0b07c00284ff00a0008bf092084f85c0047f64c60c2f20700006847f230573844606194f8570006f11407a5f10c06b6b292b29bb20196009709f079fb00287ff4ccad0020092384f85c0060866061b0e608f0fc00002206eb42014b7c8f7c43ea072304eb4207fb86cb7c0d7d043243ea05233b874b7d8d7d904243ea05237b87cb7d097e43ea0121b987e4d1bef1000f27d00399bef1010f01eb420011f81210437804f1360041ea032120f8121018d0039f511c07eb410317f811705b78bef1020f47ea032320f811300ad0039b911c03eb410213f81130527843ea022220f81120002365e6002904bf002070472de9f04790b08a780446d5b2202d35d1208ee56801302086280a8df81e00280c8df81f00280e00278df820000a20a765e76567866761a4f8567002900df11700019020460121002200238df817708df818708df819708df81a708df81b708df81c708df81d50009709f03af9e068a84208bf2561002010b0bde8f087a2f12400c0b2022843d894f85a0000283fd0262d63d0252d01d0ca7812b1002084f85a008df81b0094f85c00e56894f856208df81c00280a8df8172094f857208df81e00280c94f858308df81f00280e8df8182094f859208df820000a208df81930cb7802900df1170000278df81a208df81d500190204601210022009709f0f1f8e068a84208bf2561012010b0bde8f08794f857000028aed00b888342abd1901ec0b2162855d8a2f10d00c0b2012800f2a28094f8560038b194f8590020b194f85b00002800f03d810e2dddd194f857004af25971c0f24c018847d5e794f85620002a9ed091f80890b9f11f0fccd8cb7a032bc9d8d1f804e0bef1000fc4d00e7b4d7b8df818608e7b8df817304b7a8f7a8df81950cd7b8df81a600e7c497cb9f1000f0df117088df81b508df81c608df81d108df81e308df81f708df8209000f05781b9f1040f09f0030c80f02781002738e1a2f12700c0b20d2812d36ff0380050fa82f01e2807d8012202fa00f08122c4f20002104204d1a5f135000228bff43aaf4df2c307c0f2510708468846b84798f802104046322901d027291dd1017843f6c40201eb0111c2f2070252f8211099b943f62d4ac0f2480a0120d047064600204ff00009d047042e00f29f80014631444046092900f2998007f1a00188472b2d21dc272d40463ed0282d00f083802b2d26d055e094f85c00a8427ff444af0020628e84f85c0060866061c8784f894e68098945ea0023cde9016120460221009709f01ef82fe72c2d404630d02d2d07d02e2d35d10179002900f00681002201e00022626194f85710a4f85e20002984f8592084f85d2000f0fa8094f85b20002a40f0f580e4e0c278b2fa82f1490984f858100021002a616100f0c88084f85b10a4f8581084f85710e1656186dfe0c178b1fa81f1490984f8591000216161d6e0352d40f0d480012184f85f10427c017c837c1204c77c42ea016141ea03214df683623944c4f21b32a1fb02239a0c43f609535a43a1eb82118df813100a0a090c8df8151000218df814208df816100df11301ade0002184f85b10a4f8581084f85710e16561866161a1e094f85710a4f85e90002984f8599084f85d903ff45faf94f85b0000287ff45aaf01204ef2f53384f85b00c0f24c030320132298474ee794f85d80b8f1000f3ff4bdae4f89c8f1000ca8f1010e002604eb4602d08eb84200f0b980b6453ff4aeae138fbb4200f0b2800ceb0603981c3ff4a5ae508fb84200f0a980d81c3ff49eae908fb84200f0a2800436b045dfd195e609f01c060ef101050027eb1913f8011c08eb070258789b789172e95d0437be42d17210735373f0d1bcf1000f12d01ef8070008f10a06bcf1010ff0550ad0781c1ef80010bcf1020f315403d0b81c1ef80010315409f10a0000210091c7b22046052100220023cdf80480029708f02bff3ce694f8561011b194f85b10d1b194f85710002284f85b20a4f85e2084f8592084f85d2071b101204ef2f53384f85b00c0f24c03032013229847404602e0012184f85e10011dc0780027352d4ff0000608bf042745ea00232e2d08bf0227cde90061204604210022029708f0f4fe94f85600e5688df8170094f8570094f858108df8180094f859008df819108df81a0094f85c0094f85a108df81c00280a8df81e00280c8df81f00280e8df820000a2002900df117008df81b10019020460121002200238df81d500096d1e5486809890022cde90101204603212b46009708f0bafeebe500bf07b5fff7e5f80028bde8074006d138b584b04cf2f11cc0f24c0c6047704700bf4ff29c52c2f2290212688c4613466ff39603b3f1005fbff35f8f1bd113684ef66c61ccf2ff018b4214d15168b1f57e7f10d1d2f8f423bff35f8f5ab192f8561041b192f857202ab190f83d00904208bf4ff0040c604670472de91b50eff30084284609680979fff7cbff024684f30088bde81b90b0b50c4648f6776180b2c0f24d01884700b1b0bd4ff29c51c2f229010968bff35f8f0a466ff39602b2f1005ff1d10a684ef66c63ccf2ff039a42ead14a68b2f57e7fe6d1d1f8f413bff35f8f0029e0d091f85720002adcd02388934218bfb0bd8a68cb6801328a605a1cca600122bff35f8fca6201f12804bff35f8f54e8003f44e80025002df9d1002bbff35f8fc0d1096a42f64d42c0f244020546084614219047014600291ebfbff35f8f002121602846b0bd2946fff7a3bf00bf70b50d4648f6776180b2c0f24d01884700b170bd4ff29c51c2f229010968bff35f8f0a466ff39602b2f1005ff1d10a684ef66c63ccf2ff039a42ead14a68b2f57e7fe6d1d1f8f443bff35f8f002c08bf70bd0646a068e1680130a060481ce06020462946fff768fc94f8560028b994f8570010b994f85a0020b30120bff35f8fe062304604f128050122bff35f8f00bf55e8001f45e80023002bf9d10029bff35f8fb6d1206a42f64d42c0f2440214219047014600291ebfbff35f8f00212960304670bde0682169421a18bf012288423046bff35f8fe262d4d12168bff35f8f6268bff35f8f914293d0cbe73146fff787bf00bf46f65450c2f20700016840f2230cc0f2000cfc44c26861454ff001034ff0040008bf0223624508bf0820002a08bf1046002918bf184370472de9f04f81b04ff29c53c2f229031c68bff35f8f23466ff39603b3f1005f40f0cc8023684ef66c67ccf2ff07bb4240f0c4806368b3f57e7f40f0bf80d4f8bc310133c4f8bc314ff6ff739a4238bf134694f87471a4f8c03184f8c2011fb1002a18bf002907d1b4f8c6010130a4f8c60101b0bde8f08f94f87b010028f3d0d4f8840170b147f64c69c2f20709d9f80030c01a002805dd94f87501012809d101270ce0b4f8c8010130a4f8c80101b0bde8f08f94f87771012f18bf022794f87a510020eb0793468846adf80200adf8000012d0022f10d194f8790168b90df1020641f281556b46c0f25b05404611463246a84794f87a515a461646b2f5c86f28bf4ff4c86606f1150a5046fef707ff002856d0bbf5c86f88bf45f08005d9f80010d4f8802153230271120a42710a0a8171c2710a0c090e03704d234172a02143700123c17200218370c57002728772017394f87911bdf802204173bdf800108373c173090a0174110a8174310a017500f115014274c6740746084641463246f8f765fb4ff27d12c0f2470238465146904710f1800fd8bf6ff07f007e28a8bf7e20d4f8801184f8c501481c48f2a351c4f88001c0f245013846884701b0bde8f08fb4f8ca010130a4f8ca0101b0bde8f08f10b301684ef66c62ccf2ff0291421bd190f87b11c1b1d0f88411b1b147f64c62c2f207021368cb1a012b0edb1268d0f88801002808bf7047891a42f64d42c0f2440208bf01211047704710b590f875210021c0f8841180f87b11511eb1fa81f149f259624909c0f25902044640f20b10904710f1800fd8bf6ff07f007e28a8bf7e2084f8c4014ef6e374c0f25a04a04704f1bc00bde81040004700bf2de9f04f81b00429c0f09180824600784d2840f08c809af80100432840f087809af80200012840f082804ef66c684ff29c570d46ccf2ff08c2f229074ff6ff7600244ff07f0b06e048f2a351c0f24501bff32f8f8847d7f80090bff35f8f3868bff35f8f01466ff39601b1f1005f06d10168414503d14168b1f57e7f40d04ff47e70fef715fe002851d06ff0070100bf42180831b1f57c7f147254729472d472147354739473d473f2d14ff47e7141600121817347f67f71c0f80080a0f8c41180f8c3b1068446848684c684068546858685c685068646868686c686068746878687c68757e8001f4945add1bff35f8f47e8000121b157e8001f4945f8d0a3e79af80310022905dc01290ed0022900f09e800ce003290dd0042908d190f8741129b101b0bde8f04fdce00d2d06d201b0bde8f08f044600f031f987e090f87b1119b390f87521002180f87b11511eb1fa81f149f259624909c0f25902044640f20b1090474ef6e37510f1800fd8bf6ff07f00c0f25a057e28a8bf7e2084f8c401a84705f1bc00804720469af804100446012988bf002180f875119af8051001f00302012a4ff0010198bf0a4680f877219af80630012b88bf002380f878319af80730022b88bf002380f879319af808309af8097043ea0723502b98bf5023b3f5f07f28bf4ff4f073a0f87c319af80a309af80b7043ea072341f28837bb4238bf1f46a0f87e719af80c3080f8741103f0030380f87a3102f00103002103eb5202c0f88011c0f8bc11a0f8c01180f8c211c0f8c811a0f8c6117f2180f8762180f8c51100f009f8204600f04cf8204601b0bde8f04f78e000bfb0b5044690f87a01800758bfb0bd94f875014ef633750128c0f25a0507d105f1b000804705f58b71002088470ee005f5b670804794f87501012801d1002004e094f87701013818bf0120a84794f875014ff6d5220138b0fa80f0cff6ff7249f2015341097a44c0f2590340f20b10984710f1800fd8bf6ff07f007e28a8bf7e2084f8c301012084f87b01b0bd70b5044647f64c60c2f20700006894f87b1145f69075c0f2010500292844c4f8840108bf70bdd4f8880142f66536c0f2440658b94ff64140cff6ff707844002122460023b047c4f8880150b106f594718847d4f8880106f1e8022946bde87040104770bdb0b5044600f5c675082084f88c01032084f88d01102084f88e01002084f88f01c22084f89001062084f8910104f29311204600f065f84ff0280e4ef6057cc0f2470c012009212a462f2384f892e1bde8b040604770b54ff29c50c2f229000468bff35f8f20466ff39600b0f1005f46d120684ef66c61ccf2ff0188423fd16068b0f57e7f18bf70bd94f87b010025c4f8845100b394f8750149f259620138b0fa80f04109c0f2590240f20b1084f87b5190474ef6e37610f1800fd8bf6ff07f00c0f25a067e28a8bf7e2084f8c401b04706f1bc008047d4f8880184f8745170b142f68d45c0f24405a847d4f8880105f166018847002804bf0020c4f8880170bd70b505464d200870432048700120887095f874010c46c87095f87501087195f87701487195f87801887195f87901c87195f87c01087295f87d01487295f87e01887295f87f01c87295f87a01087395f87b01487345f64d50c0f246008047a073d5f880010026e073d5f88001000a2074b5f88201607495f883012675a074a020e074d5f8bc016075d5f8bc01000aa075b5f8be01e07595f8bf01207695f8c001607695f8c101a07695f8c201e07695f8c601207795f8c701607795f8c801a07795f8c901e07795f8ca0184f8200095f8cb0184f8210095f8c30184f8220095f8c40184f8230095f8c50184f82400fff711fc84f82500d5f88401a0b147f64c61c2f207010a68821a012a0bdb0968401a44f6d35100f2e730c1f26201a0fb01018e0900e00026300a84f8266084f8270070bd00bf2de9f04182b04ff29c51c2f229010c68bff35f8f21466ff39601b1f1005f79d121684ef66c62ccf2ff02914272d16168b1f57e7f6ed194f8cc1179b394f8ce01c0070ad0d4f86c0178b347f64c61c2f207010968401a002827dd47f24c45c2f2070555f8040c002854d042f29707c0f24c074af6e908002607f5437101a8c0f24b0801968847a8b1032084f8cf612860b4f8d001c04702b0bde8f081d4f8d811c1b302b0bde8f0410847204602b0bde8f04133e0019841f60d56c0f24c06a861b04706f5af708047e861b847012084f8cf0103202860b4f8d001c047d4f8e001a0b10199d4f8dc21b4f8d271531a38bf8b1abb420ad2b4f8d41159b147f64c62c2f207021268101a884203d32046022100f078f802b0bde8f08100bfb0b590f8cc41002c4cd044f28442c2f200021188082911462cd0114631f8083f082b27d0114631f8103f082b22d0114631f8183f082b1dd0114631f8203f082b18d0114631f8283f082b13d0114631f8303f082b0ed0114631f8383f082b09d0114631f8403f082b04d032f8481f0829114614d14a68b2f5870f10d36ff35602012a0cd14a684ff65363cff6ff737b449a4204d1d0f8d821002a18bf4a60002180f8cc1190f8cd11b1b1002180f8cd1145f60a61c2f20701097869b947f24841c2f20701096839b14af68171c0f24b010546042088472846002c08bfb0bd0321bde8b04000e000bfb0b588b0044645f64d50c0f246000d468047012840f08f8008208df8010003208df8020010208df8030000208df80400ca208df8050006208df8060018208df8070047f26440c2f2070050f81c2c94f8cc11002a18bf0122002945f60961c2f207014b7818bf0232002b94f8cf3118bf0432002b4ff0410318bf08328df808304c238df8093001238df80a308df80b508df80c2050f8182c4ef605758df80d200268c0f24705130a8df80e208df80f30130c120e8df810308df811204268130a8df812208df81330130c120e8df814308df8152002698df81620120a8df8172009788df8181081688df819106821c2f2000109688df81a10090a8df81b1047f64c61c2f207010a68130a8df81c208df81d30130c120e8df81e308df81f2000680df10102c4f8dc0108680921c4f8e00101201f23a84708b0b0bd00bf2de9f04f83b0022902d24ff0ff359ee0cde901100120cff680704ef66c644ff29c56ccf2ff04c2f229064ff6ff77851c4ff0000847f67f7a4ff07f0b07e000bf48f2a351c0f24501bff32f8f8847d6f80090bff35f8f3068bff35f8f00ea0501b1f1005f06d10168a14203d14168b1f57e7f45d04ff47e70fef7bcf90028c4d06ff0070142180831b1f57c7f82f8088082f8098082f80a8082f80b8082f80c8082f80d8082f80e8082f80f80ead14ff47e714160012104608173a0f8c4a180f8c3b1078447848784c784078547858785c785078647868786c786078747878787c78756e8001f4945aad1bff35f8f00bf46e8000121b156e8001f4945f8d09fe7044645f64d50c0f24600804701281dd1029d6978022916d00129204607d000297ff473af00210025fff7ccfe0fe0019f41f28831022f0ed14ff4fa730022012741f2883624e02046fff748fe0025284603b0bde8f08faa78052f11d3eb782e79072f43ea062310d395f805c0ae79092f4cea0627e4d3ee792d7a46ea052607e041f288364ff4fa7301e041f288360127642b98bf64238b4228bf0b4690f8cc1180f8ce21a0f8d031a0f8d271a0f8d46171b147f24841c2f20701096800295ed001210446fff77efe0025c4f8e051bee744f28442c2f200021188082911462cd0114631f8083f082b27d0114631f8103f082b22d0114631f8183f082b1dd0114631f8203f082b18d0114631f8283f082b13d0114631f8303f082b0ed0114631f8383f082b09d0114631f8403f082b04d032f8481f0829114632d14a686ff00105b2f5870ffff483af0123cff680731a40012a7ff47caf4b684ff65d22cff6ff727a44934214bfc0f8d831d0f8d831002b3ff46daf4a60012180f8cc1199e74af60771c0f24b010420884720b105462046fff7a4fd5be70121204684f8cd118fe76ff0010553e700bf70b582b00c464df6cb61c0f245018847002c18bf002801d102b070bd0168e029fad10546fdf72cf8014628460029f3d0a278e3782679217842ea0322637942ea0642042942ea036604d16178002908bf0d2e1fd026f001010629ddd147f29120c0f246008047014628460029d4d04ff65914062e4ff00f034ff00006c0f24e044ff000004ff000014ff0000208bf0c2301960ae004204ff6591401900026c0f24e040020002100220e230096a047284602b070bd3146fff7a3bf00bfb0b582b00c460546fcf7dcff0146002d4ff0000018bf002901d102b0b0bd47f2fc70c2f2070000684df6cb61c0f24501884790b10068e0284ff00000edd129784ff6591c0191c0f24e0c0021002223460090e047012002b0b0bd002002b0b0bd08b530460921fff7cbff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf08b530460a21fff7b7ff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf08b530460b21fff7a3ff002805d002b045f28310c0f24400004744f62703c0f24603984708bd00bf01280bd1002908bf704710b5896804460846fcf7dbff2046bde81040704700bf10b5059c4ff20340c0f2460080472146fff7e6ff10bd00bfb0b5c4b0044600284ff0000000f0c78089b20b2940f0c380207838b96078092804d1a078612801d1e07810b1002044b0b0bdfcf73fff0028f8d045f64d50c0f24600804701281cd00228efd103208df8070001200df107058df80800a81c21460b22f7f725fc4af66104c0f24604f02029460d220023a047b0fa80f0400944b0b0bd4ff29c50c2f22900006801466ff39601b1f1005fc9d101684ef66c62ccf2ff029142c2d14168b1f57e7fbed122797f21042a06dc012a0cdcbab1012a08bf00211ae0082a0bdc052a11d0082a08bf0a2112e0022a0dd0042a08bf01210ce0092a09d00a2a08bf0e2106e0092104e0022102e0032100e00b2180f80b1310216a2580f80c13a22180f80653152580f80e13062180f807531a2580f80f130c2180f80853132580f8101352210822022380f8095380f811134921012580f8042380f8053380f80a2380f80d3380f8121380f8135380f81453217900f5417280f815136179192380f81613a17980f81713002180f81813e17980f81913217a80f81a13617a80f81b13a17a4ff2250480f81c13c0f247040120e021a047284644b0b0bd00bf1fb5fff72bff002803d0bde81f4000207047bde81f4038b584b049f21f13c0f24703184710b5f0281bd1d1b1cab10c78032c16d10d2a1cbf0b2010bd487801281cbf0a2010bd45f64d50c0f246000c468047012803d1a01c0b21fff7fffe002010bdbde81040fcf7dfba00bf002804bfa3207047017e427e837ec07e41ea0221184300064ff0a40008bfa320a4220a2928bf1046704700bf4ff29c52c2f229021268bff35f8f13466ff39603b3f1005f10d1d2f800c04ef66c63ccf2ff039c4508d15368b3f57e7f02bf0023c2f8fc32c2f8003347f2c942c0f24d02104700bf4ff29c50c2f229000068bff35f8f01466ff39601b1f1005f0fd101684ef66c62ccf2ff02914208d14168b1f57e7f02bf0021c0f8fc12c0f8001347f2d940c0f24d0000472de9f04184b0dde90a76022f16d340f64705a94212d08eb13578412d0ed175784e2d0bd1014602f0bf0012284ff00d0008bf002b0ed004b0bde8f0810c9d0097cde9016546f63916c0f24d06b04704b0bde8f081082feed3b078012802d1f078022803d90d2004b0bde8f081002953d045f6f444c2f2060414f8040c81424bd12068002848d048f22732c0f254020d4608460221904700283ed024682088d8b36088c8b3a088b8b3e088a8b330797179b279f37940ea012040ea024050ea0368d0d04ff29c50c2f229000068bff35f8f01466ff39601b1f1005f1bd101684ef66c62ccf2ff02914214d14168b1f57e7f10d1f178a1b190f8fc22aa420cd1d0f80023424508d101295bd1082faad100f09bf875e0f07818b1082004b0bde8f081082f9fd1f8f744fec8b10646d0f86c010028f1d047f64c61c2f207010968401a0128e9db96f8fc0268b196f8fd02032809d00628e0d1304600f076f8dce7112004b0bde8f08146f63917c0f24d0707f53a60804707f539622846214690470120002786f8fd020df10f02304600210123a6f8fe7286f8fc52c6f800838df80f70adf80c7000f07ef861884af2bd6603abc0f24c0628460222b047384604b0bde8f081a7f1510189b24ff6b87291424ff00d0119d390f8fd02032808467ff42baf334613f8080fa7f108018ab280b9052a0ed9a1884af2bd67c0f24c072846b847002004b0bde8f081084604b0bde8f08101280dd1042a0bd3981810f8021c00297ff420af10f8010c00287ff41bafe0e702284ff00d0008bf062a7ff4fcae707b01283ff60fafd4e790f8fd120a1f022a38bf7047022905d0012907d1042180f8fd127047052180f8fd12704780b582b0052180f8fd120121adf8061045f6f441c2f2060190f8fc0209684af2bd6c49880df10603c0f24c0c0222e04702b0bde8804070472de9f04fc7b0054690f8fc0203920591d8b145f6f041c2f206010978884214d148f22732c0f2540202211c46904760b195f8fc0240f66502c0f255020021904718b100690088172802d247b0bde8f08f033880b2f42828bff42007af0b3807f101084ff000094ff0000a01900495029414e000bf0699cde94509adf810112121adf8121143f23d5144a8c0f255018847049d029c1ffa8af0a042d6d2a4eb0a01019a1ffa81fbb5f8fe1241235a45b8bf93468df81c304e234a1c8df81d300123a5f8fe22d5f800238df81e30059b1ffa8af08df81f30130a8df82410090a8df820208df82130130c120e8df82510b0fa80f18df823204a091ffa8bf111fa8afaa2458df8223008bf0232bbf1000f8df826202fd001390329039901eb000c01d2002115e04ff6fc700bea00020cf10103002100bf5e1816f8014c7d187078ec725c5cb67804318a422c736873ae73f1d1049d1bf003020dd01cf80160cb19012ade7207d00ceb01004178022a19731cbf8078587395f8fc020bf10b0406900b2010fa84f649f6cd713046c0f24c01884700283ff47eaf26f003031ffa84fc06f003025e426ff00303c1180433f518043581f8049081f8059081f8069081f80790f2d152b10344012a83f8049005d0022a83f8059018bf83f806900bf10e0202701b22442108230272220480f801908170c370417283723ff43dafbcf1040f01d2002214e047f6fc710cea0103002200bfb95c8618f17218f8021008eb020531736978ad78043293427173b573f0d11cf003033ff41fafbe5c00f10b01012b8e543ff418af561cbd5d022b8d553ff412af0232bb5c8b540de7f0b583b04ff29c51c2f229010c68bff35f8f21466ff39601b1f1005f4bd121684ef66c62ccf2ff02914244d16168b1f57e7f40d194f8fc12e9b3002840d002888a423dd145f6f446c2f2060616f8041c8a4235d1316899b3356894f8fd12032919d8d4f86c1139b147f64c62c2f207021268891a00290edc02218df80b100df10b020746204600210123fff78dfe2046fff75cfe38468278092a1bd141896b8894f8fd72994217d1032f3adc012f6ad0022f3dd004e018b181780939022901d203b0f0bd47f6ed31c0f24d0103b0bde8f040084794f8fd72032ff1d8a2f10d0102290cd2c178d1b302208df8040001aa204600210123fff757fe03b0f0bd092a08bf032fdcd14189aa889142d8d1c078002800f0818002200df105028df80500e6e7052f04d0042fcad1c07805262fe0c078002848d0062084f8fd0202208df807000df10702204600210123fff72cfe052fb5d02046fff7f9fd03b0f0bd4268002aadd00389a3f2012189b2b1f57e4fa6d34089082b48d12988884245d12046012108234ce0c0780526002808bf022650b102208df80a000df10a02204600210123fff701fe6988012294f8fc024af2bd67adf8082002abc0f24c07022284f8fd62b84703b0f0bd052f15d1002094f8fc523668c4f8fc02c4f8000347f2c944c0f24d0404f11000804728463146224603b0bde8f0401047032084f8fd0201208df806000df1060272e7e98888427ff457af2046022103e0204603210022002303b0bde8f040bfe506290ad14178012907d18178653911f1630f02d3c178012902d94ff0ff307047f0b581b00179427941ea022540f6b8318d421fd80646fcf747fad8b1f8f726fbc0b10446d0f8d80342f66537c0f2440758b941f28b30c0f200007844012100220023b847c4f8d80320b107f1e8022821904718b14ff0ff3001b0f0bdb078f178d4f8e4230023c7f6e07340ea452003ea425240ea0120bff35f8f1043bff35f8fc4f8d403002001b0f0bd00bf02293cbf4ff0ff3070472de9f04f99b00278437842ea0322b2f5007f089204d94ff0ff3019b0bde8f08f4ef66c694ff29c56ccf2ff09c2f229064ff6ff77002547f67f7b4ff07f080391069008e000bf48f2a3512046c0f24501bff32f8f8847d6f800a0bff35f8f3468bff35f8f20466ff39600b0f1005f06d12068484503d16068b0f57e7f3ed04ff47e70fdf72cfac0b304466ff0070021180830b0f57c7f0d724d728d72cd720d734d738d73cd73f2d14ff47e7060600120c4f80090a073a4f8c4b184f8c38127846784a784e78427856785a785e78527866786a786e78627876787a787e78756e8000f5045afd1bff35f8f46e8004028b156e8000f5045f8d0a5e700240898ddf80cb058b1fcf785f90146002c4ff0ff3018bf002902d119b0bde8f08f08980021b0fa80f040098df824108df825108df826108df827108df828108df829108df82a108df82b108df82c108df82d108df82e108df82f108df830108df831108df832108df833108df834108df835108df836108df837108df838108df839108df83a108df83b108df83c108df83d108df83e108df83f108df840108df841108df842108df843108df844108df845108df846108df847108df848108df849108df84a108df84b108df84c108df84d108df84e108df84f108df850108df851108df852108df853108df854108df855108df856108df857108df858108df859108df85a108df85b108df85c108df85d108df85e108df85f108df860108df861108df862108df86310b4b1d4f870219ab14ff4006305e000bf3f683b44b3f5403f0ad2d718be680136f6d07e68033626f0030631441031efe7089a4ff0020a002a00f0f780abf102020a2ac0f0f28000260df1240e069800eb0a0c9cf801704ff0ff30012f3ff648af9cf802209cf803309cf8045042ea03229cf8053042ea054949ea0368a8f1011212f5803ffff434af9cf808209cf80930029242ea03250af10a020592abeb02020795013d9542bff423af9cf806509cf80720019545ea022bb8eb0b050496fff417af079eae423ff613af069810f80a5045ea072a4feada001ef8006005f007050127af40374240f0eb821ef8005047ea05074ff6ff75c0f202050ef800703cb3d4f8700120b316021a0200924ff4006283189f6857453ed01b681a44aa4217d883189f68574536d01b681a44aa420fd883189f6857452ed01b681a44aa4207d883189f68574526d01b681a44aa42dfd9bbf1000f40f0b4824ff6fc7209f10300c0f203021040084400f11001ddf80cb00798059a049e00eb020a0898013686424ff0000028bf01204fd2abeb0a02092a3ff65caf49e05868404540f09182d8685845c0f08d82e1d9079aa0eb0b00824200f286821046aab30298009addf80cb002eb00090198c9f1000e304403eb0008a9f10106002308eb03020ceb0307107cbd7aa84240f06c829e4218d0507cfd7aa84240f065820eeb0300851c0fd092f812a03d7baa4540f05b82033007d0d07c7a7b904240f0548204339945dbd10df1240ea5e7ddf80cb0a3e7002800f04882baeb0b0018bf0120b1f53e3f4ff0000188bf0121014308980028c1f100003ff44fae00297ff44caed4f870b1bbf1000f40f08b804ff44030fdf726f8002800f02782834600206ff0200100220beb02030bf8020040320beb0107b2f5006f01f1400158709870d870187158719871d871187258729872d872187358739873d873187458749874d874187558759875d875187658769876d87618775877987787f8400087f8410087f8420083f8220083f8230083f8240083f8250083f8260083f8270083f8280083f8290083f82a0083f82b0083f82c0083f82d0083f82e0083f82f0083f8300083f8310083f8320083f8330083f8340083f8350083f8360083f8370083f8380083f8390083f83a0083f83b0083f83c0083f83d0083f83e0083f83f0093d14ff43e30cbf800080020cbf804084ff0ff31cbf80c084ff40060c4f870b1cbf80818c4f820034ff6ff760221c0f202064ff0000a09e008980af1010a09eb080182454ff000003ff4a9ad069807914518405ca9782a7a6f780391eb7895f8049095f805c0a97995f807e005926a7a40ea072804925cb3012f29d84ff400670beb0705a868404500f0a38028680744b7421dd80beb0705a868404500f0998028680744b74213d80beb0705a868404500f08f8028680744b74209d80beb0705a868404500f0858028680744b742d7d90398cdf808a040ea032040ea094040ea0c67f81c20f00300d4f8209300f1100a0020cde900e10397b9f1000f26d00beb09035bf809105a68514580f09b80eab10beb02005bf80210d0f80490514580f08c80b9f1000f11d00beb09035bf809105a68514580f0868042b10beb02005bf80210d0f804905145d6d376e000204ff400694ff4006504e000bf3d44b5f5403f23d20beb05018a685bf805700132f4d04868ca68033020f0030000f110060beb09001032f6f7d3fb4168c2684bf809608368d4f870b18a424ff00001b14408bf00f110014bf82310d7e7c9f540310f294ff00002c4f8202310d90beb09004bf809104ff0ff3142608160c260c4f820930ae0e868079adde9043760e010b10268114401604ff000090020b9f1000f76d00beb09035bf809105a68514522d2002a6dd00beb02005bf80210d0f80490514513d2b9f1000f62d00beb09035bf809105a6851450ed2002a59d00beb02005bf80210d0f804905145d7d30546cc469146184601e01d469446a1eb0a0110290fd309eb0a020beb02034bf802104ff0ff31c3f804c0996000219446d960c5f800a0ddf808a0079adde900e1dde9043700280cbfc4f820c3c0f804c003984ff6ff7668600020c0f20206c5f80880e86041ea0e2147ea0329814202f10a087ff4c4ae05f11007781806994a464144f6f7ebfae9686868aa68d4f870b14944e96081424ff0000018bf07464bf82270ace600204ff400684ff4006703e02f44b7f5403f23d20beb07018a685bf807500132f4d04868ca68033020f0030000f110060beb08001032f6f70bfb4168c2684bf808608368d4f870b18a424ff00001b04408bf00f110014bf82310d7e7c8f5403200210f2ac4f820130dd90beb08034ff0ff304bf8082059609860d960c4f8208319b0bde8f08f00281ebf0168114401604ff0ff3019b0bde8f08f00bf02293cbf4ff0ff3070472de9f04f8bb00278437842ea0325b5f5007f00f2988005eb4502022303eb4202914240f090800590fbf775fd002800f08a804ef66c694ff29c56ccf2ff09c2f229064ff6ff77002447f67f7a4ff07f0806e048f2a351c0f24501bff32f8f8847d6f800b0bff35f8f3068bff35f8f01466ff39601b1f1005f06d10168494503d14168b1f57e7f3ed04ff47e70fcf7a9fd002858d06ff0070100bf42180831b1f57c7f147254729472d472147354739473d473f2d14ff47e7141600121c0f800908173a0f8c4a180f8c381078447848784c784078547858785c785078647868786c786078747878787c78756e8001f5945afd1bff35f8f46e8000121b156e8001f5945f8d0a5e7d0f870c10495bcf1000f20d000234ff4006104e03f683944b1f5403f0bd20ceb0107be680136f5d07e68033626f0030633441033eee775b9b3f53e3f40f2e0804ff0ff310bb0bde8f04f08467047002d00f0d680002305994ff0000901f1020a153103914ff0ff31059109eb49060aeb46056c784ff0ff31012ce3d8af78ea7857ea022e1ebf2a796d7952ea0528d9d0bef5207fd6d8b8f5f07fd3d80ef10102520802fb08fb4ff6fb724ff6ff779345c0f20207c6d81af81610059e41ea0421039cb9f1000f28d014f8132c14f8125c42ea05228a42b3d0feb114f80d2c14f80c5c42ea05228a42aad0012e15d014f8072c14f8065c42ea05228a42a0d0022e0bd014f8012c257842ea05228a4297d0043e721c04f11804d6d15646bcf1000f2fd00bf105054ff400640ceb040adaf808208a4230d0daf800201444bc4220d80ceb040adaf808208a4225d0daf800201444bc4215d80ceb040adaf808208a421ad0daf800201444bc420ad80ceb040adaf808208a420fd0daf800201444bc42d3d94ff6fc720bf10801c0f201021140194401f1100320e0daf80410a9427ff44fafdaf80c10a9427ff44aaf9af8101004297ff445af9af811109af8122041ea022171457ff43caf9af813109af8142041ea022141457ff433af049909f1010989450599b24601f1010105917ff43dafb3f53e3f3ff624af00240025019019e000211fe7d0f870c14a688b684ff6ff7793454ff00002c0f20207c1f80cb008bf01f110024cf82320013575454ff000013ff408af05eb45000aeb40011af8100091f8018091f802e091f803b091f804904979bcf1000f40ea082605912cd0b8f1010f29d84ff400610ceb01039a68b24200f0a8801a681144b9421dd80ceb01039a68b24200f09e801a681144b94213d80ceb01039a68b24200f094801a681144b94209d80ceb01039a68b24200f08a801a681144b942d7d94eea0b21059b013149ea0322490801fb02f75a4607f1050b8df81d004fea1b208df820004fea1b408df8210005208df82500042001218df8270048468df81b1003908df82a000df11b0011218df81c408df81e808df81fb08df822408df824408df823408df82640cdf808e08df828e091468df829208df82b30fff75ff900287ff482ae01980021d0f870c1bcf1000f3fd0ddf810e0b8f1010f3cd84ff400630ceb03018a68b24235d009680b444ff6ff71c0f202018b4226d80ceb03018a68b24228d009680b444ff6ff71c0f202018b4219d80ceb03018a68b2421bd009680b444ff6ff71c0f202018b420cd80ceb03018a68b2420ed009680b444ff6ff71c0f202018b42cbd9002104e0ddf810e02ee7ddf810e0002f3ff41aaf4fea0922029f059b42f001023a44039f1b0252083b4353435a1e032a01d200220ae023f0030700228e18043297427475b475f4753476f7d113f003033ff4f8ae01f11507012bbc543ff4f2ae3a44022b547018bf9470ebe62de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010947f67f7a4ff07f0b07e000bf48f2a351c0f24501bff32f8f8847d5f80080bff35f8f2868bff35f8f01466ff39601b1f1005f06d10168a14203d14168b1f57e7f3ed04ff47e70fcf723fb002800f0b2806ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ff47e710460416080f80e90a0f8c4a180f8c3b1068446848684c684068546858685c685068646868686c686068746878687c68755e8001f4145b0d1bff35f8f00bf45e8000121b155e8001f4145f8d0a5e70446d0f8880310b101b0bde8f08f4ff41630fcf7ddfa00284ff000016ad00022831881544032b2f5163f59709970d970197159719971d971197259729972d972197359739973d973197459749974d974197559759975d975197659769976d976197759779977d97783f8201083f8211083f8221083f8231083f8241083f8251083f8261083f8271083f8281083f8291083f82a1083f82b1083f82c1083f82d1083f82e1083f82f1083f8301083f8311083f8321083f8331083f8341083f8351083f8361083f8371083f8381083f8391083f83a1083f83b1083f83c1083f83d1083f83e1083f83f109ad1c4f8880301b0bde8f08f002001b0bde8f08f2de9f04f93b04ff6ff75a9424ff0000c2cd0dde91c874ff4805ecde90aecd0f89ce3cde90087229fdde920a9dde91e6b249c0697239f0aadcdf840c0cde911eccde90845cde9026bcde904a90546079704f004fe84464cb1bcf1000f06d19df8480095f8a013084385f8a003604613b0bde8f08f2de9f04f93b00446002047f64c68a4f8a003c2f20708d8f80000002a8b461abfc4f894030146d4f89413401ac4f89c03fbf7b0f9002800f00381d4f88803002800f0fe8004f032ff002800f0f9800646b4f88c03002853d0a0f10108d4f89c0300254ff4a0714ff4f0774ff48059cde911050df1280acde901152046414632464ff42073cde90a951095cdf824a0cde90755cde90555cde90355009704f0a4fd002840f0cd80d4f89c034146cde91105012008904ff4a0700190204632464ff420734ff4f077cde90a951095cdf824a0cde90655cde90455cde90255009704f083fd002840f0ac809df8480094f8a01347f64c68084384f8a003c2f2070806e0d4f8881330464ff41632f5f741fe4ef66c694ff29c57ccf2ff09c2f229074ff6ff76002507e000bf48f2a351c0f24501bff32f8f8847d7f800a0bff35f8f3868bff35f8f01466ff39601b1f1005f06d10168494503d14168b1f57e7f42d04ff47e70fcf77df900286fd06ff0070100bf42180831b1f57c7f157255729572d572157355739573d573f2d14ff47e7141600121817347f67f71a0f8c4117f21c0f8009080f8c311068446848684c684068546858685c685068646868686c686068746878687c68757e8001f5145acd1bff35f8f00bf47e8000121b157e8001f5145f8d0a1e7054604f061fe002d18bf002803d101208bf8050022e0c5f864014ff001094ff4f07085f8689101904ff420704af61f460090c0f2470600200021002200230027b04730b185f86871c5f864718bf8059004e09bf805008bf8049030b14ff0ff3013b0bde8f08f0025cbe794f8a00384f8a10348b3d4f8900342f66535c0f2440528b1d8f800102d31c4f8981311e044f67360c0f200007844002122460023a847c4f89003d8f8001001f12d01c4f8981320b105f1e8022d21904728b1002084f8a10313b0bde8f08f002013b0bde8f08f80b582b04ff4f0704af61f4e01904ff4207cc0f2470e0020002100220023cdf800c0f04702b080bd022a3cbf4ff0ff3070472de9f04fadf2345d239008784f780a4450ea072001f10206249002f07983002725932292964202f06d83701c904202f0698330787178b31c40ea0121d01a81422c932e9102f25e832598ddf880253690ddf85805ddf878153790ddf85c053f913890ddf8600527973990ddf864053a90ddf868053b90ddf86c053c90ddf870053d90ddf874053e901068411e0028116002f038832e98002802f034832e98841c032c02f02f83f778072f02f22b832c9890f80090f80702d106f1040e27e02e9820f00100022802f01d8396f804a0757923984aea052b594636aa02f022fb002842f01083ddf8640506f1060e012d3a900dd8ddf88005806948b14feadb020af00701835c012505fa01f119438154b80706eb04002a904cd44ff0000a042f71d32a9fbaf1000f4cd1be454ad0724612f8011b3a98ba4268d09ef801200ef10203120642ea0141bb4200eb214c69d00ef103029ef80210ba425fd09ef803200ef10403120642ea0141bb424fea214154d00ef105039ef80420bb4200f09f8738469ef805700ef10603834242ea072200f0be870ef107079ef80630874201f035839ef807700ef1080e3f024ff0000a3fe000bf864508d01ef9014b4ff0000af04606e03a98002121e000244ff0010a804645f64d55c0f24605a847012808bf0134601e81b2660800ebd130002c48bf4610a84701283a9808bf76423044c6463a90042f8dd2ddf8a8802fe0be4600eb010c4ff0010a0022002108e04ff0010a002203e04ff0010a00220021be46002300273b433b9f62440b447fb1dde93c76dde93e40bc45d8bfbc46b142d8bf3146a242a8bf22468342a8bf0346ddf8a8800120cde93cc1cde93e233b90baf1000f42f04982b9f1040f40f38280b9f1060f40f3f280b9f1070f00f05e82b9f1080f00f06b81b9f1090f42f03582c64502f032821ef801abc64542f02d82baf10f0f02f22982ddf87c05002801f077833b993698dde93829002900f030863799dde93d733f9e994227eae775b8bf0b46b242b8bf1646b542359681f260833c994fea630c21eae17b4fea0a11339135990bf10104491b4fea5b0e4aea0a1211f003084fea54013494329100f000879b4581f2898205fb09045feacb7171465e4609d014f80e10349e01f0f00141ea0a0104f80e10329961452144319681f2658204eb0c060c4604f8012bb44281f05f828f1cb7424a7081f05b82cf1cb7428a7081f056820f1dca70b7423946ead301f04fbab9f1020f37dcb9f1010f00f01c81b9f1020f42f0b88138983aae33903998dde9367b3490ddf8800572cec069dde93e324ff000094290c64528a8cde946e8cdf82091cdf80c91cdf8c8b02d922b9362c02f94359700f021820ef1010046909ef80090404500f019820ef1020046909ef80100060214e2b9f1030f00f04381b9f1040f42f08081dde93a70dde936c232903c98dde938543090ddf88005dde93d3addf8fc90c0694ff0000bc64542aecde942e8cdf810b14090cdf804b13592cde9334c319300f050820ef1010042909ef800b0404500f048820ef1020042909ef801004fea002843e2b9f1050f00f0a081b9f1060f42f04781c64502f044810ef10100404502f03f810ef10200404502f03a810ef10300404502f035810ef10400404502f030810ef10500404502f02b810ef10600404502f026810ef10700404502f021810ef1080ca8eb0c001028c2f01a810ef11800404542f015819ef804009ef8051050ea01261ebf9ef806009ef8071050ea012502f006819ef800009ef80120379940ea0224081bc2f0fc80864202f2f9809ef802009ef80330389a40ea0327d01bc2f0ef80854202f2ec80ddf87c05002801f03a8239980df1e80e369b34909ee8014fcdf8d4e0cde906478de8010f1846dde93437cdf828c0cde90865059704f077f801f021ba36983999339037983591349038983a9931904046cde94ee0ddf880053291c06900214eac46aedde93b7bdde93da5ddf8fc805091cde946012046314602f075fb81462046314602f070fb5099002900f07d824ff0ff33279f1c4651e2c64502f09d80724612f8010b012802f29780369900283091dde93751359139993191dde93ac134913c992d913d992b913e9929913f99289100f03383424502f07f800ef10202424502f07a800ef10302424502f075800ef10402424502f070800ef10502424502f06b800ef10602424502f066800ef10702424502f061800ef10802424502f05c809ef801209ef802309ef8046042ea03239ef803209ef805409ef80610774642ea062e44ea012af9793a7a07f109041a9441ea022112e3a8eb0e06052ec2f03c800ef10509c14502f037800ef106059ef80540a8eb0500a042c2f02e802819404542f02a8036981f90dde93780cdf8d4e0289039981e90dde93aa034903c9832903d983190dde93eb03390b4b1002703e000bf0137a74210d2e85d01381e28f8d9e819e11b4eaa46ab02f00bff002802f003804e980744a742eed3ddf87c05002801f04d813498cdf8c0a0002800f00f843298444620eae07032903198d84520eae0702090a8bf5c462898ddf8cc804045a8bf4046289000f0febbc64501f0dc870ef10100404501f0d7870ef10200404541f0d287704601784078dde93b5441ea0021ddf880050df1d80c0990ddf87c059ce80c10089004a8dde93976ddf8f490ddf8f8e0ddf8fc8080e810422398cde900c7cde90265cdf81c8004f0acf804465be1ddf880050df1f00ac069dde936c1dde93853dde93a629ae89004ddf8fc904ff0000b4290c64531a8cde946e8cdf820b1cdf80cb1cde934512d9480e80c10cde92f76cdf8ac9000f022810ef1010046909ef800b0404500f01a810ef1020046909ef801004fea002815e101204890002646ad42af2846394602f034fa83462846394602f02ffa48998046002900f01b8100240020319001204890002046af0df5847a30903846514602f01cfa05463846514602f017fa4899002940f0fb808446dde94601279fa24688424ff0ff3440f0f480bbf1000f00f1f080b8f1000f00f1ec80ddf880254398116a46ea0906084310623598ddf8c8e04e9033985b4650904ff6fe7086423498cdf83ce1519000f04f844ff6ff70864240f02b842398d0f888934ff420704f904ff4f07050904ff4a070519000f03ebc012044904ff0000840ac3046214602f0cdf9314606460846214602f0c7f94499002940f0ab80dde94212914200f0a68011f801eb914240f0a180ddf8803541991a6a1143239a1962002a00f09780d2f870114ff0ff34002900f0928048ea0b030022b2eb532f40f08b8051f82320002a00f08680a2eb01085fea887240f080806ff44032a44640f60f044244cff6fd74a242644674d301eb080c5cf8081c99426cd15cf80c1ca1f1011212f5803f65d3bcf1000f4ff0ff3462d05cf8042c8a425ed1c8f5403291425ad82d90ddf880052f938069cdf8ace058b12f9a0bf0070ed30810f80380012202fa0ef242ea0802c2546046002246ab01f0eefe00284ff0000408bf4ff0ff343ad0ddf87c05b8b3a6f1011010f1021f4ff0000430d92d98a0f1011010f1021f2ad93298002300284e9301f00b83309820eae072319820eae07335985045a8bf504635904d45a8bf4d4601f0fcba012048904ff0000846af42ac3846214602f021f981463846214602f01cf94899002900f080804ff0ff34279f229a002c00f09f8701f048bedde9460188423ff4e0ae024612f8014b8a4246923ff4daae821c469243788a4244ea03243ff4d2aec21c469283788a4231933ff4cdae011d4691c0780002cae6dde94ec2cdf8c08094453ff47cad0cf1010191423ff477ad0cf1020191423ff472ad0cf1030191423ff46dad0cf1040191423ff468ad0cf1050191423ff463ad0cf1060191423ff45ead0cf1070191423ff459ad2d909cf800009cf8041056460cf1080abe465c46cdf8a8902b909cf801709cf802309cf8030029919cf805909cf806b09cf80710a2eb0a08b8f1010f2f9140f0a88692453ff435ad9cf808100f293ff630ad0cf1090a00f09dbedde946218a423ff47baf134613f801cb8b423ff475af951c56784a1bb2424ff0ff34fff46fafaa198a427ff46bafddf8803543991a6a1143239a1962002a3ff461afd2f87021002a3ff45caf48ea0b0e0021b1eb5e2f7ff455af52f82e1000293ff450af891a8b077ff44caf6ff4403340f60f070b44cff6fd77bb42fff442af531853f8082c72457ff43caf53f80c7ca7f1011212f5803ffff434af28aa002b82e86040cdf884c026903ff42baf53f8040cb8427ff426afc1f540302a9987423ff620afddf880051e4680693d4640b1ca080bf0070c835c012101fa0cf119438154c12dfff40eaf307801287ff40aaf2998002801f0bf81dde928b8a6f13f0400f0b6bf424501f04c850ef10202424501f047850ef10302424501f042850ef10402424501f03d859ef801209ef80260714693004fea460eca780e7905314fea820a1a917100baf1000f1b9101f029851b99002901f02585ea1ac1f02285924501f21f853599b1eb0e02c1f01a851b99914201f21685349903eb0c06084301d000230be05feacc704ff0000306d1002e04d40aeb0600a842d8bf01231a9c1b9aa8eb04001890ddf87c0502fb0af9b0fa80f0400918430027c0074ff0000b19931f902f95cdf8709023e0dde9303002fb003c4a081cf80230339803f00f0803f0f0030344c907329808bf48ea0003ddf8a8800cf8023000bf26988344dde9200181424ff0000088bf01200743f80708bf0c44f90704d0d94507d801f0c2bc00bf444518bfd94540f29e81b8eb040001f0b88421780b0901d0012211e0012801f0b08463780bb102220ae00428c1f0a984a278e37852ea032301f0a384042200bf2192a9eb0b02934201f29b8420901f9826930028c0d101f00f003390269809010128cde91d4732912dd14ff0000c2698ddf8a8801e9fdde91c94c007acd00ceb0b00b0fbfaf101fb1a0001eb0e02811952ea0100a0d4a9429ed2359882429bd2349800283ff481af2d98814294db2b98824291db29988142bff68eaf28988242fff673af88e720f001014ff0000c16e0dde93030339f04fb00305308c45cd20704f00f0504f0f0043c44329a08bf45ea02042f9dc4540cf1020c6145b7d00beb0c02b2fbfaf404fb1a2704eb0e0907eb060859ea080427d4a84525d23598814522d2349858b12d9880451ddb2b9881451adb2998804517da2898814514dadde930304fea580709fb00343398e35d03f00f0503f0f00303445feac870329808bf45ea00032f9de355501cb0fbfaf202fb1a0002eb0e04821954ea0200bbd4aa42b9d235988442b6d234980028a0d02d988242b0db2b988442addb29988242aada2898844294dba6e70aeb0a1109fb02f2f4f78efe00f038bd0020209032904446052e01f0de831f98002801f0da83faf7adf8002801f0d58399f8009009f10600864241f0ce8347f65420c2f207000768002f01f0c683387b797bba7bfb7b40ea012040ea024040ea0363a3f1810010f1800fc1f0b683387c797cfa7c40ea0120b97c40ea014040ea02601090813810f5817f41f2a683b9f1000f31931897349477d0359a002300270ae000bf00f100404ea941f8260001374f4506f1010316d2e85d1e46411e1e29f0d9e819a9eb070146aa42ab02f08afa00283ff431ad429846994eaa42f82600359a0f44e4e7002b00f0ed80a3f1010a77424ff000094eac0ce0359a5b46ca4509f10109a6f1010604f1040407f1010700f0d7804ea850f829100029efd49b46ca4513d10022189846ab42ad009502f0e5fa00283ff400ad42980028ddd04af20d3146a8c0f24e018847d6e7a6f1010c002304eb83004268002ae4d59c45e1d08268b2f1ff3fdedcfd18aa1cdad0c268b2f1ff3fd7dcea1cd4d00269b2f1ff3fd1dc04339e42e4d1cce7359a012000239be000234ff0010abe46fff7b3b8444508bfd94541f01983ddf87c05002818bf012019990840012840f06284dde9300318990efb03004fea5a0700eb56021b98009701901a9801f0d1fb002840f0508401f0fbba00234ff0010a8646fff78ab82f4600f040bc239831464eaacdf898c0744601f0f9fa002857d1ddf88005ddf898c08069a6465b4660b10021b1eb562f08d1f20809f00701845c012606fa01f121438154ddf83891b9f1000f3dd0baf1000f4ff0ff341cbfdde9301050ea01003ff475ac4f999942fff471acc91a8a453ff66dac50994145fff469aca1eb080188423ff664acddf87c15002400293ff45eaca5f1011111f1021f7ff658ac2f99002900f02585299921eae1722a9921eae1762b998e45a8bf8e4633992d9ca142a8bf2146339100f015bd4ff0ff34fff73ebc002001e00023012092f800c0144692f801e091781279e77895060f2402f00f0604eae575754389246543ed0a8df808510e25339212f0200f08bf012506fb05f504fb05f54fead5258df809514ff00d0508bf022506fb05f504fb05f54fead5258df80a514ff00c0508bf032506fb05f504fb05f54fead5258df80b514ff00b0508bf042506fb05f504fb05f54fead5258df80c514ff00a0508bf052506fb05f504fb05f54fead5258df80d514ff0090508bf062506fb05f504fb05f54fead5258df80e514ff0080508bf072506fb05f504fb05f54fead5258df80f514ff0070508bf082506fb05f504fb05f54fead5258df810514ff0060508bf092506fb05f504fb05f54fead5258df811514ff0050508bf0a2506fb05f504fb05f54fead5258df812514ff0040508bf0b2506fb05f504fb05f54fead5258df813514ff0030508bf0c2506fb05f504fb05f54fead5258df814514ff0020508bf0d2506fb05f504fb05f54fead5258df815514ff0010508bf0e2506fb05f504fb05f54fead5258df816514ff0000508bf0f256e436643f60a00284ff000048df817617ff46dab38064fea0e6240ea014042ea0c41309a349c02eb2149591e13913199ddf860a001eb2040c3f1000b4ff000084ead1a460f9012930ce001f01f000b3808f101088144013a043598450bf1010b00f028864ea850f82810b1f1ff3fecdd13981992804540f0dc810022504646ab40af1a95009702f012f900283ff42dab409900291c9100f0f2819df820019df82111ddf880c050ea0120cde9148bcdf85c902d9000f0ad819df824719df825613f0447ea0667109e2d9d9df81f019df81e112e440f9d4fea002e41ea00229df8220106eb27479df82331ed1b4ff0010800042b95179d219208eb520240ea03601b920eeb0102031405eb2046571e1d97ef1801f00300e91a731c1693b31c11931c9b2690101addf8c8b03190c8070df5847a5d1c08eb52034ff000093090f80735962a932f9008e000bf2d9809f1010981452a98054400f05c812b9809eb00026245f2db28988242efda21980028ecd0dde91e10002702fb010e1d982995032880f0a5802698ddf880c0299d0028dcd0dde91b10012209fb01083398790818f8011000f0100082ea1013c8b201f00f02fe0708bf02091046002a18bf0120184301281dd135983d185d4519dba54217da68081ef800101af802209b46334601f00f0601f0f0011143ed0708bf46ea02111e465b46ddf8c8b00df5847a0ef800102698299d0128a0d0781c400818f80000002ec1b24fea111c08bf00f00f0c5ffa8cf0002818bf0120184301281ed116983a185a451adba24218da50081ef8001042acb34614f80c6001f00f0501f0f0013143349cd20708bf45ea0611299d5e46ddf8c8b00df5847a0ef800102698ddf880c002283ff469afb81c400818f80000002e00f00f02c1b208bf0a091046002a18bf0120184301287ff457af11983b185b45fff652afa342bff64faf58081ef800101af8022001f00f0701f0f0011143db0708bf47ea02110ef800103de7ac4606e031980437b8420cf1020c3ff452af33981cf8012c00f01001012080ea1113d5b200210f2d88bf012135981943012900eb07021ad15a4518dba24216da290955081ef805401af8011004f00f0004f0f004359e0c43f607ddf8c8b008bf40ea01140ef80540349c0df5847a1cf8010c10f00f08404618bf01201843012819d1551c5d4516dba54214da68081ef800101af8084001f00f05309e45ea041501f0f001002eddf8c8b008bf41ea0405349c0ef800509cf80000c5b200200f2d88bf01201843012817d1911c594514dba14212da490828091ef801401af8000004f00f0504f0f0042f9e0443002e08bf45ea00140ef80140349c9cf8000010f00f05284618bf0120184301287ff47aafd11c5945fff676afa142bff673af48081ef800101af8052001f00f03309d43ea021301f0f001002d08bf41ea02030ef800305fe74af20d3146a8c0f24e0188479df81c019df81d11129bdde9179adde9148b2ae0501e002305eb83077a68002a7ff51dae0beb0306b21c3ff417aeba68b2f1ff3f3ff713aef21c3ff40faefa68b2f1ff3f3ff70bae321d3ff407ae3a69b2f1ff3f3ff703ae04339842dcd1fde59df81c019df81d11129b40ea0120dde91925dee500274ff0010a8646fef70dbd0f4600e04f1cd90708d03199994205da3978339c01f00f0121433970b8f1010f05f1010700f0b1809b456fda07fb09045feacb7171465e4609d014f80e10349e01f0f00141ea0a0104f80e10329961452144319614da04eb0c060c4604f8012bb44247d28f1cb7424a7044d2cf1cb7428a7040d20f1dca70b7423946edd33ae00f4638e0102192457ef48cae2b9a984652ea072c4ff0ff333ef486ae58ea002228923ef481aebcf5207f3ef67dae289ab2f5f07f3ef678aebbf10f0f2691cdf880b03ef671ae2f9910293ef66daeddf88035479a196a1143ddf87c25196232b132992a9a614449428a4280f2d0810023fef75abe4f1cd90708d03199994205da3978339c01f00f0121433970b8f1020f05f1020739d09b4536da07fb09045feacb717146d8460ad014f80e10ddf8d08001f0f00141ea0a0104f80e1032996145214414da04eb0c060c4604f8012bb4420fd28f1cb7424a700cd2cf1cb7428a7008d20f1dca70b7423946edd302e00f4600e04f1cd90707d0984505da3978339c01f00f0121433970ef1c3599691a11f1040f11d9229a279f2498013787422c982e9900eb01067ef432ab00f0a6be00bf359904378f42edd09b4539da07fb09045feacb7171465d4609d014f80e10349d01f0f00141ea0a0104f80e1032996145214418da04eb0c060c4604f8012bb44280f0cd8001f10208b0454a700cd201f10308b0458a7007d201f10408ca70b0454146e9d300e08846d90709d09d4207da98f80010339c01f00f01214388f800109b4536da791c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c04314601f8012ba14280f09580b11ca14272700ad2f11ca142b27006d2311df270a1420e46ecd300e03146dc0707d09d4205da0c78339d04f00f042c430c709b4536dab91c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c0400bf314601f8012ba14260d2b11ca14272700ad2f11ca142b27006d2311df270a1420e46edd300e03146dc0707d09d4205da0c78339d04f00f042c430c709b45bff64baff91c01fb09015feacb7474465d4609d011f80e40349d04f0f00444ea0a0401f80e40329c644501eb040615da01eb0c0400bf314601f8012ba1422ad2b11ca14272700ad2f11ca142b27006d2311df270a1420e46edd300e03146dc073ff41baf9d42bff618af0c78339d04f00f042c430c7010e701f10108d9077ff442af4ae7711cdc077ff478af7ee7711cdc07acd1b3e7711cdc07e3d1fde6b8f1010800f003821bf8010b411e1f29f6d341b22029fef63faf04eb400114f81000497840ea0122c12afef435af304629464eab00f0defd0028e1d1fef72cbf00260022724545da33998e4242da289900240d447545bef622af33998c45bef61eafa2eb0a018d427ef719af311a8c457ef715af571b1146b8bf2946aa4262464ff0000cd8bf6746c34607eb0308aaeb0704b71ad8bf6746c51bb242aeeb0100c8bf1646844238bf2046339b92469b1b9d422f9328bf1d46359b2d95994507eb0b03cde92a363fd12a9b9e422ddd4ff0010c39e00024fef7e2be3499329a0023891a2a9a8a42bef685ac28992d9a49428a42fef67fac2d9a31998a42bef67aacbef1000f00f0c58124eae4712191349926eae67aa942a8bf29463491dde93041a142a8bf21463191b7e1dde92a734145a3eb0703b3fa83f34fea53134ff00007c8bf012703ea070c2d9b002b00f08981042222ea88071a9708eb000743184fea5805013f01f0010603f001041b957d08199522ea8705371918952546c21bdde930477018274408eb060488ea01084908179159082b9b169107eb0a01ddf8bce0c91a4fea520b714538bf8e460121cdf8bce0bbf1010f88bf510801f00303159343082693359b21f0030103eb5000431c033814904feac87021904ff0ff3000eb52001291610831906ff00100289109eb540100eb52003090881eddf844e113906ff0020000eb52004ff00008109311911c922090cdf87cc02995cde91de608e02f9808f10108279f80454ff000043ef436ae6fea08014046bcf1000f2d9a18bf50182a9900eb010202fb0e910eb9002305e01b9b1a9ccb5ce34003f00f03359f33930db9002304e0199b189ccb5ce3401b0132932b9b349c034403fb0475219f2698002f289faa46284439441dd15a46f3f772fedde91de6ddf87cc046b11799339a1af8010000f0f00010440af80100299d002db4d01699329a1af8010000f00f0010430af80100aae75c43bcf1000f02fb0ef23ed01c980228dfd31398149910442144002200eb0b039c785f78319dc4f3031444ea071701eb0b049542a770ccd05f7810f80b50c7f3031747ea0517309d67709542c1d010f80b7013f8015cc7f3031747ea0517209d01f80b709542b4d013f8017c13f8023cc7f30317043247ea031304389345a1f1040104f8013cc9d1a3e71c9b022ba0d31c9b082b01d200222be0119bddf848e003eb020c109a144400220ceb02077d781cf80260c5f3031545ea0616a51805f8016cbe787b78c6f3031646ea0313a354fb78be78c3f3031343ea06136b703b79ff780432c3f3031343ea07139645ab70dbd1159bddf87cc0dde91de6002b3ff468af531ccf5c8d5c159cc7f3031747ea0517012c87543ff45caf941c0f5dcd5cc7f3031747ea0517159dc754022d3ff450af0a44d278095dc2f3031242ea0111015546e7ddf87c0530b3a9f1011010f1021f4ff000047ef63cad2698a0f1011010f1021f7ef635ad3198002300284e9300f062832d9820eae0722f9820eae07335985045a8bf5046359034982b998842a8bf0846349050e30024fef71abd00224ea806902b98f11905902d98359fcde903102f980097cde90150dde9331001f08afb0446fef705bd00214ff0000a219129994ff0000e41ea0921b1eb5c0f28bf4fea5c01289ab1eb520f28bf51081c91013938bf714610912d99baeb0104d8bf7446319e711a9142a8bf11468c421f91bef68baa4fea002e32982a993b020f181c9921984a00494389001e921b918742c8bf3846349d0ceb0702aa424ff000012a92b8bf1546bcf1030f38bf0121289e0022032e38bf012211431a91410819912b990eeb080219444b08b3eb520f269b1d9000f1010c4fea031015904fea520243ea031038bf4a08149029984fea09294844691029951891824228bf0246109b03fb03f080000d906ff0080000eb420016902d985045c8bf8246339835992b9701fb0a002f99309000203290701e1790b01e139058001290781c119008010f9041ea011026460e904fea5c004ff0000acdf830c00b9010e001780f9a01f00f0111430170359c319e30980136204430901f9800238642bef608aa2899f04308448642b8bf30461e996fea400008440128319638db1b994ff0ff3200fb10101c99a1eb0a01012902eb41013bdb01fb01f2824237dd1699a1eb4a0202f10803032b02f1060126db01fb01f7874222dd052b02f1040121db01fb01f787421ddd072b02f102011cdb01fb01f7874218dd0af1040a092ba2f1080103db524382420a46dbdc08310ee02d983399359c269a4ff0000a39e00af1010a04e00af1020a01e00af1030abaf1010f29db08318a1f5243824224dcbaf1020f16db0a1f5243824215dcbaf1020f0fd08a1e5243824211dcbaf1040f08db01fb01f282420ddcbaf1040a01f10801e1d14ff0000a07e0aaf1010a04e0aaf1020a01e0aaf1030a2d983399359c269a319e30442b9b00fb04192a985344102aa0eb0a0800f08b8034988342b8bf18461d99814239da1d9f199af90739460ad0199f269a19f8071001f0f001114309f80710dde90b21b2eb600f09eb020715da149d09eb60063a4602f8015bb2420fd2ba1cb2427d700cd2fa1cb242bd7008d23a1dfd70b2421746edd302e03a4600e07a1c359c319ec70707d0814205da1078159900f00f0008431070ddf884c0e045c8bfc4462998844541da5feacc700bd04fea5c0019f80010269a01f0f00111430cf1010c09f800101898b0eb5c0f1add1898309e149d4fea5c0209eb0007b018044604f8015bbc4210d2811cb94225700fd2c41cbc420d700ad20436b118b9422570ecd305e009eb5c0102e0411c00e021462998359c319ec00708d02998844505da0878159a00f00f00104308702f9810280bd10120029020982199349a01904846cdf8008002f033fbcae6b6fa86f01a99400908434ad11798864247d01399701e891b8842b8bf01466fea4100129908440128c0f29f800d99329a00fb101010998a1a4ff0ff31012a01eb42016ddb01fb01f7874269dd5100a1f1090202f10807032f02f1060157db01fb01f6864253dd052f02f1040152db01fb01f686424edd072f02f102014ddb01fb01f6864249dd3299092f01f104013291a2f1080103db524382420a46d9dc08313ee021988342d8bf034634988045a8bf80464345bff66daed80709d0580819f800102f9a01f0f0011143013309f800105908b1eb680f17da309f0e9d09eb68027c18264606f8015b96427ad2a01c904235707bd2e61c9642057076d20437781890423570ecd371e009eb53006ee0329a013204e0329a023201e0329a03323292329a012a23db08318a1f524382421edc329a022a19db0a1f5243824200f3ba80329a022a11d08a1e5243824200f3b580329a042a09db01fb01f2824200f3b080329a0831043a3292ded1002032901198329900eb010c21988342d8bf0346ddf8d0e0f445b8bfe646734543dad80709d0580819f800102f9a01f0f0011143013309f800105a08b2eb6e0f17da309e0e9d09eb6e07b018044604f8015bbc4212d2811cb94225701ad2c41cbc420d7015d20436b118b9422570ecd310e009eb53010de0601c02e0411c09e030465feac8713ff4cfad4345fff6c6adcae521465feace7007d0734505da08780f9a00f00f001043087032982a99c0430e18012002902098219f349c01904846394622466346009602f017fabe42d8bf3e46a045a8bfa0464645bff6a5adf00709d0700819f800102f9a01f0f0011143013609f800107108b1eb680f17da309b0e9d09eb68025c18274607f8015b974210d2a01c90423d700fd2e71c974205700ad20433581890423d70ecd305e009eb560002e0601c00e038465feac8713ff473ad4645fff66aad6ee53298013858e73298023855e73298033852e700223098359f09eb00014ea8089029980097079028980690219805902698cde903102a98029034980190dde9321001f07afd0446fef7b1b94ff0ff300df2345dbde8f08fb01a18bf4ff0ff300df2345dbde8f08f00bfb0b586b008b3d0f87001f0b10023b3eb512f1ad150f82130bbb11b1a9d0714d16ff4403540f60f041d44cff6fd74a5420bd3184450f8085c8d4206d150f80c1ca1f1011515f5803f03d24ff0ff3006b0b0bd50f8045c8d42f7d1c3f540339942f3d80028f1d0037813f00b0fedd1144601ab0022002500f011f80028e5d00198dde903122060481c40086160a260e06028462561656106b0b0bd00bf91429cbf002070472de9f041855c4ff0050c6e0758bf4ff0030c15f0f30f02d1891a614502d20020bde8f0818418627894f802e0002e05d5e078267942ea0e2240ea062e002a4ff0000018bfbef1000fead0b2f5207fe7d8bef5f07f88bfbde8f081082d38bf0120072d18610ad8501c400800fb0ef0a1eb0c018842d3d804eb0c0828e004eb0c080efb02f5002000bf00eb0c04a142c6d008eb00073e78360903d00127b54213d2bde70c1b012cbad07e781eb10227b5420ad2b4e7042cb2d3bc78fe7854ea0626add00427b542aad3ad1b3844dcd158600120c3f800809a60c3f80ce0bde8f0812de9f04f89b0dde91257069005fb07f000294fea4007029100f0d48100200390089002984ff0010e00264ff0000b4ff000084ff0000c4ff000090497079205930be000bf4ff0000c4ff00308cdf80ca009f10109814500f0ba81bcf1000f40f0b4810699b8f1020f11f809a0ead0b8f1010f15d0ddf81cc0b8f1000f40f086805fea1a100af00f01089100f092800499814280f09a804ff0010c4ff0000882e1079abaf1000f00f07f800499514576d3a1eb0a010491089901eb01100901019114e000bfa15d089f01f0f0013943a1550136aaf1010a4ff0010eae4224bf00260bf1010bbaf1000f00f0598113998b45d1d20bfb0324bef1000fe3d0a91bb1eb5a0f88bf4fea5a0141b38d0804eb060817d0002208f10107a2eb850c6ff003057b1904350ceb05020432d870187158719871f5d1059b079a2f1d11f0030504d10ce0002711f0030508d0012d08f8070004d04744022d787018bfb870aaeb410abaf1000f0e440dd0129dae42b5d2a15d019f01f00f013943aaf1010a4ff0000ea155afe7129d4ff0000aa6e7039a52ea0a2213d004990392914280f08f804ff0010c4ff0000853e74ff0000c4ff002084ee74ff0000c4ff00108f4e000214ff0010c4ff00008039142e7089a091a049102eb02111201cdf80090019214e000bf1af80670089a07f0f00717440af80670013601384ff0010eae4224bf00260bf1010b002800f0d680139a934580f0cd800bfb03cabef1000fe2d0ad1bb5eb500ff14688bf45087db3ac080aeb06081ed0002308f10107a3eb840c6ff0030400bf07eb040e04340ceb040304338ef803108ef804108ef805108ef80610f0d1059bddf81cc0271d15f0030404d10ce0002715f0030408d0012c08f8071004d04744022c797018bfb970a0eb45002e4488b1129dae4210d21af80620019f02f00f023a430af8062001384ff0000e0028abd180e000bf129d0020ce469de7891a0491089901eb011009010191114613e000bf1af80620089c02f0f00222430af80620013601394ff0010eae4224bf00260bf1010b002953d0139a9345bff4ccae0bfb03cabef1000fe3d0ad1bb5eb510f88bf4d085db3ac080aeb060819d0002208f10107a2eb840c6ff0030400bf3a1904340ceb04030433d070107150719071f5d1059bddf81cc0271d15f0030404d10de0002715f0030409d0012c08f8070005d04744022c787018bfb87000bfa1eb45012e4489b1129dae42b6d21af80620019f02f00f023a4301394ff0000e0af806200029b0d103e000bf129d0021a4e74ff000084ff0000c029852e64ff0010c4ff0000803e04ff000084ff0000c0298ddf8009045e60120012107e04ff0010cb8fa88f0049f8cf001014009b7fa87f252091140084009b0bde8f08f00bf2de9f041826882b10121816007220020511e20fa01f1c90708bfbde8f0814ff0ff3191400843bde8f0818c46056841688d42e9d06b1c03602c78ff2c11d18b4200f0dc80ac1c046095f90120b2f1ff3fd6b200f3d080bf2e22d806f03f0602238fe062b2b2f1ff3f02dd07222046cfe7bf2c09d804f03f070e224ff0010e4ff000084ff0000c2ee0df2c0fd804f01f0715224ff0000c4ff001084ff0010e22e0df2e0fd806f01f0603236ae0ef2c0fd804f00f071c224ff0010c4ff000084ff0010e10e0ef2e58d806f00f06042358e0f02c40f093804ff0000820224ff0000c4ff0000e00278b424fea072603d0af1c07606d7803e00125856000251f46c02c45ea06046cd35b1a7d1ab3fa83f3b5fa85f55b096d092b434fea042403d001258560002503e07e1c06603d783746b8f1000f44ea050453d17d1ab5fa85f56d092b434fea042403d001258560002503e07e1c06603d783746bcf1000f44ea05043ed1791ab1fa81f1490919434fea042131d001238360002030e0f02e3ed1002605234ff0010e00250127ea074fea062617d18c4215d0621c0260247801379f4246ea040623d000bf8a424fea062609d0541c0460127801371643bb422246f3d116e02246013701254ff0000e9f4214468560dad112e07b1c0360387840ea0104bef1000f20467ff413afbde8f08114465feace7202d0091b8e4204d9012181600020bde8f081a11907462046002263463960bde8f041ffe78446081ab0f5806f01d90020704761454ff00000fad0002a18bf70472de9f04fabb09fed251a9fed250a9fed253a9e4600264ff0ff380df12c090df10c0ab7ee002ab0ee084ab6ee005ab1ee006ab9ee007a00206746019009e000bf49f826500af8064001368f42bc4600f0cb8217f8012b501e01280fd8012a23d18f4274d09cf901000cf10207b0f1ff3fc5b240f38f8000220724f5e1052a37d0042a30d0032a49d1002e00f0d982701e59f820501af8004093e200bf0000004f000000cf000000008f4254d00cf102079cf801008f4247d09cf802200cf103078f4240ea02203fd09cf803200cf104078f4240ea024037d09cf804200cf10507130600223ae0002e00f0aa82013eace7022ec0f0a582b21e59f82230701e59f8205049f820301af802301af800400af8003049f822500af8024096e702f0f80010281fd1002e00f08b82701e1af80030002b40f0858259f82050152a6fd16d420022002406463de20023012206e001220724002588e101220020002343ea000501242fe2a2f12000062827d8002e00f06782731e1af80300002800f0618259f82300242a40f0858080f00045012400221e4617e2bf2d5ad801220292002205f03f000e244ff0000b00928f4200f019819cf802300cf10308002215e1322a51d002f0fe0030284dd0402a40f0a380032ec0f03682701e1af80020002a00f03082b21e1af80230002b00f02a82033e1af80630002b00f0248209eb8202d2ed000a09eb860209eb8000d2ed001ad0ed002a70eee10a62eea00a71eea00acee1002800f00e82023e1af80600002840f0088259f82600122a58dc102a00f03081112a00f03381122a40f02c81454354e1df2d44d8002205f01f00152400924ff0010b0122bae0002e00f0eb81a2f13100013eb0fa80f01af806304009834240f0e08159f82600302a7bd100ee900af8eee00a94e1002b00f0d481023e1af80630002b00f0ce8159f82630212a40f3ed80222a00f02581232a00f02981252a40f03a8100ee903a01ee900af4ee610af1ee10fa48bff0ee601a11ee905a71e1ef2d72d805f00f001c24012274e0a2f11303022b80f0c480002d00f0a381b0f1004f08bf15f1010300f0eb80132a40f0f18090fbf5f5f1e0a2f1480010f1070f4ff00000c0f05f81002e00f05c81013e1af80600002800f0858109eb8600d0ed000af4ee420af1ee10faf5ee400ac8bff0ee420af1ee10fa48bff0ee430a432a72ee601a00f3b480412a00f0f380422a00f00f81432a40f0008161eea10a72ee600a1de1312a40f0948000ee900a20f00040b0f1ff4f4ff00002f4ee410aa8bf0122f1ee10fa4ff0000080f21c81f4ee400af1ee10fa00f11681002a40f01381fdeee00a10ee905a98e0f02d4ff0000040f00981002220244ff0000b009202928f427ff4e7ae00230122b8460002c02d43ea000535d3781aa8eb0103b0fa80f0b3fa83f340095b0918434fea05270ebf18f8013b00230122bbf1000f43ea07051fd1a8eb0103b3fa83f35b0918430ebf18f8013b002301222f02009d002d43ea07050ed1a8eb0103b3fa83f35b0918434fea05230ebf18f8010b0020012240ea0305474602984ff0ff3838b1601e25fa00f0c0071cbf08fa04f005430024a3e0162a10d1a842b8bf054637e0202a4cd0212a51d100ee903a01ee900a70eee10a8ee005442ae0a842c8bf054626e0451b24e0002800f1c680def800200546824238bf15469042019888bf0120019015e0442a48d0452a5fd0462a4ed161eea10a61e00025132a4ff0000208bf4ff00045002469e090fbf5f202fb15050022002462e000ee903a01ee900a61eea00a57e000ee900af5ee400af1ee10fa00f0928001ee903ac1eea00a4ae000ee903a01ee900a71eea00a43e000ee903a01ee900af4ee610af1ee10fac8bff0ee601a11ee905a37e060eea01a70eea00a74ee600a61eea00a2ce0f4ee450af1ee10fa18d570eea01a60eea10a22e0f4ee450af1ee10fa15d560ee861a60eea11a60eea10a16e060eea00a13e060eea01a60eea10a0ee071eea10a61eea00a72ee600a07e061ee870a61eea00a61eea00a70ee820a10ee905a012400224ff000005ab9202e09d0002c3ff436ad25f00040b0f1ff4ffff630ad00202bb0bde8f08f56b3701e1af8001059f82000d9b102ee100a20f00040b0f1ff4f4ff00001b4ee412aa8bf0121f1ee10fa4ff00000e4dab4ee402af1ee10fadfd40029ddd1bdeec20a10ee100a019adef804101143cef804102bb0bde8f08f00202bb0bde8f08f80b5002970d090f900c0bcf1200f5ffa8cfc07db012010604ff0010ec3f800c0704680bdacf1c20ebef11d0f0fd801295ad090f9011011f1410f55dc02211160407800f03f006cf38a108446e4e70cf0f00ebef1e00f23d1032945d390f901e01ef1410f40dc90f9021011f1410f3bdcbcf1e00f5ffa8ef101d1a02934d3bcf1ed0f01d19f292fd80321116042784fea0c3189b2807802f03f0241ea821136e004294ff0000ebbd3acf1f50111f1050fb6d390f901e01ef1410f15dc90f9021011f1410f10dc90f9031011f1410f0bdcbcf1f00f5ffa8ef101d1902904d3bcf1f40f03d18f2901d9002080bd042111604ff4e011427801ea8c4c817802f03f02c0784cea023201f03f0142ea811100f03f0001eb000c7fe72de9f04188b04af2bb261c46c0f24e0613460a46ddf83880002706f1ae05214627706770a770e77027716771a771e77127726772a772e77227736773a773e77327746774a774e77427756775a775e77527766776a776e77627776777a777e777a8470028c8f800705cd020786178a278e3780843104318434ff0010008d0e179a27911431ebf617a227a51ea020102d108b0bde8f081a07b14284ff00000f7d1217d8df8040041f0010121758df805008df806008df807008df808008df809008df80a008df80b008df80c008df80d008df80e008df80f008df810008df811008df812008df813008df814008df815008df816008df817008df818008df819008df81a008df81b008df81c008df81d008df81e008df81f0001a92046b047c8f8000018b1012008b0bde8f08106f1520120468847d8f80000002818bf012008b0bde8f081002804bf4ff0ff3070472de9f04f95b00df1200c8ce80f00f7f794fc002800f0ab814ef66c6a4ff29c5bccf2ff0ac2f2290b4ff6ff764ff00008012447f67f754ff07f0907e000bf48f2a351c0f24501bff32f8f8847dbf80070bff35f8fdbf80000bff35f8f01466ff39601b1f1005f06d10168514503d14168b1f57e7f47d04ff47e70f8f7c4fc002800f075816ff0070100bf42180831b1f57c7f82f8088082f8098082f80a8082f80b8082f80c8082f80d8082f80e8082f80f80ead14ff47e71c0f800a041608473a0f8c45180f8c391068446848684c684068546858685c685068646868686c686068746878687c6875be8001fb942a6d1bff35f8f00bf4be8000121b15be8001fb942f8d09be7d0f87011209e4ff0ff3029b30022b2eb562f21d151f82600002800f02581431a98074ff0ff3017d16ff4403240f60f071a44cff6fd77ba420ed3ca1852f8080cb04240f0118152f80c1ca1f1011010f5803f04d24ff0ff3015b0bde8f08f002a4ff0ff30f8d052f8047c8f42f4d1c3f540339942f0d810ac1046002223464ff00009fef75fff002800f0ee80239b0f22990603f00f0002eae17101fb00f289214a43d20a8df830200e2213f0200f08bf4ff00f0908bf012200fb02f201fb02f24fead2228df831204ff00d0208bf022200fb02f201fb02f24fead2228df832204ff00c0208bf032200fb02f201fb02f24fead2228df833204ff00b0208bf042200fb02f201fb02f24fead2228df834204ff00a0208bf052200fb02f201fb02f24fead2228df835204ff0090208bf062200fb02f201fb02f24fead2228df836204ff0080208bf072200fb02f201fb02f24fead2228df837204ff0070208bf082200fb02f201fb02f24fead2228df838204ff0060208bf092200fb02f201fb02f24fead2228df839204ff0050208bf0a2200fb02f201fb02f24fead2228df83a204ff0040208bf0b2200fb02f201fb02f24fead2228df83b204ff0030208bf0c2200fb02f201fb02f24fead2228df83c204ff0020208bf0d2200fb02f201fb02f24fead2228df83d204ff0010208bf0e22424309fb00f04843c00a8df83f00c3f3001006900ca84a43cde9044008ac0b9dd20addf88880ddf884901f9f13cc1e9e8df83e2022462b46cdf80c80cdf808900197009600f02ef8dde91201a1454844c8bf4c46a8454144c8bf4546b042b8bf0646b942b8bf0f46a642c8bfaf4208dc002015b0bde8f08f4ff0ff3015b0bde8f08f249800680f28f2d8791b249f321b07ebc0030130dc801d815a8199813860e6e700bf2de9f04f8fb0dde91c5a0e9129691e9eddf868c0002900f05c812f68002e40f05381874200f050819af80f100f2940f04b819af80e100e2940f046819af80d100d2940f041819af80c100c2940f03c819af80b100b2940f037819af80a100a2940f032819af80910092940f02d819af80810082940f028819af80710072940f023819af80610062940f01e819af80510052940f019819af80410042940f014819af80310032940f00f819af80210022940f00a819af80110012940f005819af80010002940f000811b9fb2eb0c044ff00001d8bf0c46db1bd8bf0b46d5f808e0ea681d46e919189fa444aeeb0403a7eb0c070694bb42b8bf1f46199b521b0b91591a8a42b8bf1146012f0c910797c0f2e5820c990129c0f2e1820ef101014c08069900eb6c000a9048100990042020ea81000590079801310138cde903014810029004fb05f000f102094ff0000acde9005c089407e000bf0c980af1010a8245a14400f0bb821c980e9b01680aeb050000fb04120b980a9f504400fb03705feacc7303d1099fdde9063810e0099b2e46d35c059d0778eb4007f0f00703f00f033b4400f8013b049bdde902783546d619da074fea580b0d9208d131465a466446f1f7ecfea446089c68e000bfb8f1020f64d3abf10102032a04d200211bf0030e35d15be06ff0030202ea58034f44b646c3f1000c3944471c8e18f578b478c5f3031545ea0415bc18e5703579f378c5f3031545ea0313237173793579c3f3031343ea05136371b3797679c3f30313043243ea06130ceb02060436a371dcd1dde9005c089c111d76461bf0030e26d04b1cf75c3246765cc7f30317ddf804c047ea06171646bef1010f475417d08f1cd65dd55cc6f3031646ea0516009dddf804c0bef1020fc654164608d03144c978f25dc1f3031141ea0211c15500bf5feac8713ff45aaf0d9a16f80b10002a4ff0000208bf042210f80b30d14003f00f0242ea011100f80b1047e7874200f095810026a1e16d68002d00f0018200244ff000090ae000bfdde90c14d8f804500c44ddf874a0ac4280f0f281ddf870800d94d8f800100f5d3e0903d001210c910ce000bf2e1b012e00f0e28121444d78002d00f0628102210c912e4617f00f011e9f1af801a0b7fa87f74fea571718bf012147ea010e1b9f4fea0a1b16f003014c4600f08980cde90a16d8f808100026b9fbf1f404fb119161449142a8bf012606ea0e06012e18d13c449c4215db189da94212da199dac420fda0e9d4e0804fb0504c907a75d6ff00f01554604bf0f215d4639401b9f2943a1550a990b9e012909f1010458d0d8f80810b4fbf1f606fb1141002461449142a8bf012404ea0e04012c18d1f4199c4215db189da94212da199dac420fda0e9d574604fb05044d08c907665d6ff00f0104bf0f215f46314039431b9f61550a990b9e022909f102042ad0d8f80810b4fbf1f505fb1141002461449142a8bf012404ea0e04012c19d1ec199c4216db189da94213da199dac4210da0e9d574604fb05044d08c907665d6ff00f0104bf0f215f4631400b9e39431b9f615509f10304711e0329b14405d23ae700bf0434a1453ff436afd8f808100026b4fbf1f505fb114161449142a8bf012606ea0e06012e1bd13d449d4218db189eb14215da199eb54212da0e9ed04605fb06054e08c907af5d6ff00f0104bf0f21d84639401b9f41ea0801ddf87080a955d8f80810661cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e1cd13d449d4219db189eb14216da199eb54213da0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa955d8f80810a61cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e1cd13d449d4219db189eb14216da199eb54213da0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa955d8f80810e61cb6fbf1f505fb1161002661449142a8bf012606ea0e06012e7ff466af3d449d42fff662af189eb142bff65eaf199eb542bff65aaf0e9e574605fb06054e08c90715f806806ff00f0104bf0f215f4601ea0801ddf8708039431b9fa95544e7042e78d38e78c97856ea012673d0042188e61b99002901dd012609e0b1fa81f149090027bcf1000fc8bf012707ea0106d5f808e0d5f80cb00bfb0ef9b9f1000f59d01e990024b1fa81f149094ff0ff380d91f1070c9107e000bf01340bfb0ef94c45a8f1010846d20c991c9e0029214618bf09eb0801b1fbfef536680ef1010705fb1e117f0805fb07664f08f65d042727ea8107fe4016f00f094f4618bf01270d9e3743012fd8d161449142d5db1b9f3d449d42d1db189fb942ceda199fbd42cbda0e9f1af8096005fb070e4d081ef80570c90707f00f0907f0f00747ea06071c9908bf49ea06170ef80570d1f808e0d1f80cb0b1e70fb0bde8f08f00bf002804bf4ff0ff3070472de9f04f9bb01c461546cde91001f6f750ff002800f0a7814ef66c6b4ff29c59cde90e54ccf2ff0bc2f229094ff6ff7a0027012447f67f754ff07f0806e048f2a351c0f24501bff32f8f8847d9f80060bff35f8fd9f80000bff35f8f01466ff39601b1f1005f06d10168594503d14168b1f57e7f4fd04ff47e70f7f780ff002800f071816ff0070100bf42180831b1f57c7f177257729772d772177357739773d773f2d14ff47e71c0f800b041608473a0f8c45180f8c381a0f820a0a0f822a0a0f824a0a0f826a0a0f828a0a0f82aa0a0f82ca0a0f82ea0a0f830a0a0f832a0a0f834a0a0f836a0a0f838a0a0f83aa0a0f83ca0a0f83ea059e8001fb1429ed1bff35f8f00bf49e8000121b159e8001fb142f8d093e7d0f87021299c269d4ff0ff302ab30021b1eb552f21d152f82500002800f01881811a88074ff0ff3017d16ff4403340f60f070b44cff6fd77bb420ed3561856f8080ca84240f0048156f80c7ca7f1011010f5803f04d24ff0ff301bb0bde8f08f56f8040cb8424ff0ff30f6d1c1f540318f42f2d8002ef0d0c12feed33078012840f0e680a0060f2204f00f0102eae070484389225043c00a8df85c000e2014f0200f08bf012001fb00f002fb00f04fead0208df85d004ff00d0008bf022001fb00f002fb00f04fead0208df85e004ff00c0008bf032001fb00f002fb00f04fead0208df85f004ff00b0008bf042001fb00f002fb00f04fead0208df860004ff00a0008bf052001fb00f002fb00f04fead0208df861004ff0090008bf062001fb00f002fb00f04fead0208df862004ff0080008bf072001fb00f002fb00f04fead0208df863004ff0070008bf082001fb00f002fb00f04fead0208df864004ff0060008bf092001fb00f002fb00f04fead0208df865004ff0050008bf0a2001fb00f002fb00f04fead0208df866004ff0040008bf0b2001fb00f002fb00f04fead0208df867004ff0030008bf0c2001fb00f002fb00f04fead0208df868004ff0020008bf0d2001fb00f002fb00f04fead0208df869004ff0010008bf0e2001fb00f002fb00f04fead0204ff000038df86a0008bf0f2359432b9d51430020c90a002d8df86b103ff428afc4f300102a9ca6f13f080df148090d9001e0013d1cd014f8010b411e1f29f8d341b220290fdb08eb400118f81000497840ea0122c12a06d3304639464b46fef730f90028e5d14ff0ff301bb0bde8f08f0f992898dde92ab58842c8bf01462c98ddf89ca006300a910890cde90b76cdf8248004e050440b38013d824657d01bf8010b1f28f6d908eb400118f81000497840ea0122c12ad6d3304639464b46fef700f90028cfd00d98ddf83880069017a8cde90490ddf8a090249cdde910010f9b259e4246cde902a900940196fff791fadde91401c24550444944d8bfc246a0422246b8bf0246b142a8bf3146524517dd0a9b994214dd2c9b1b680f2b10d80a9ea2eb0a02a1eb060c089901ebc307ba802c9a21f833a0591c7e80a7f806c01160dde90b76ddf824800df14809a4e700201bb0bde8f08f2de9f04fd3b0dde95ce5dde9648cdde9629a0d9075b1dde96050dde95e47a94224eae47b27eae774a8bf29468242a8bf024602e000244ff0000b09eb0e0008eb00055845c8bf83468d420ceb0a07b8bf2946a24588bf54469742b8bf3a468b45b8bf944202db53b0bde8f08f669804f0010701974fea5b07033809970bf101070090580008974e080c90002701200df14c0e0df10c0c02948ce80e00cde90a6b06e000bf0798012700284ff00000dad0c00707906698069708bf0830ddf800906ff007086ff004044ff0000b4ff0000a0f9018bf09f10809cdf838900f994fea5a00085c102300f0f002cc46a14610901194cdf8488000bf1cf8041f0eeb08001cf8014c9cf8015042ea141704f00f041443447242ea111401f00f01847211430eeb0904217242ea15119cf802600772617205f00f011143a17242ea1611817306f00f01114308f10808083b09f10809c173d1d11098ddf83890000110224b465d4600bf13f8041f0eeb050713f8014c5e7840ea141804f00f0404437c7440ea111401f00f010143f97440ea161193f802c0397506f00f010143797540ea1c11b9750cf00f010143083a05f1080587f81080bc74f975d5d1ddf84880119c0af1020a08f120082034baf1100f0bf1200b84d101980699049a48400299059b00eb01090399dde90a6b9145bff65baf0d9803fb090807e000bf0c9809f1020991458044bff64faf0d98dc4609fb03045feacb700bd0099dddf820c0605d1ef8007000f0f00007f00f0738446055b6eb5c0f28d94fea5c0a04eb060b464616f80a0006eb0a041ef80050204600f8015b58451dd205781ef80570a51c5d45077017d228781ef800002870e51c5d4510d2287804361ef80000287006eb0a055d45ddd306e000bf04eb5c05c80705d1b4e7651cdde90a6bc807afd08c45adda28781ef8007000f00f0007f0f00738442870a3e72de9f04f8bb01d9d6c68072c00f286802cb12f89b94200f08180012c7bd100287cd0d0f87061002e78d00027b7eb512f74d156f82170002f70d0a7eb060c5fea8c776bd16ff440370ceb070e40f60f07cff6fd77be4561d306eb0c0e5ef8086c8e425bd15ef80c6ca6f1011717f5803f54d35ef8047cb74250d1ccf54037be424cd8bef1000f49d0032e47d39ef80070022f43d19446aa69ddf86ca0dde91987dde917b9b2b14fead10801f00704da464ff0010b4f4612f808900bfa04f444ea090402f80840d346ddf86ca0b946dde919876c6805eb44021181721e1c9e01346c600996169e0ef101010396159e0a950296149ecde904b9cde900366346cde90687cdf820a0fbf7f5fa6968013969600bb0bde8f08f6f89b94204d14ff0ff300bb0bde8f08f022c3ff479afaf89b942f4d0032c3ff473afef89b942eed0042c3ff46daf2f8ab942e8d0052c3ff467af6f8ab942e2d0062c3ff461afaf8ab9427ff45dafdae700bf70b5049d8b42c8bf19469542b8bf2a46914205dadde905e3bef1000f01d103b170bdbef10f0c18bf9c46cb070ed04b10c45cbcf1000f03d004f00f05ae4504d904f0f00444ea0e04c45401314c1000eb61035510bcf1000f00eb620049d0ac425fda00bf1c78764604f00f05beeb141f38bf2609754598bf754645ea06141d4605f8014b854265d25c78764604f00f05beeb141f38bf2609754598bf75469c1c45ea061584425d7040d29c78764604f00f05beeb141f38bf2609754598bf7546dc1c45ea061584429d702fd2dc78764604f00f05beeb141f38bf2609754598bf754645ea06151c1ddd7084422346b9d31ce0ac4219da4eea0e1500bf1c4604f8015b844226d29c1c84425d700ed2dc1c84429d700ad21c1ddd7084422346edd304e01c46d00704d17ae71c46d0073ff477af9142bff674af2078bcf1000f03d0beeb101f98bf70bd00f00f0040ea0e10207070bd5c1cd007ebd161e72de9f04f81b04ef66c644ff29c55ccf2ff04c2f229054ff6ff7600274ff0010947f67f7a4ff07f0b07e000bf48f2a351c0f24501bff32f8f8847d5f80080bff35f8f2868bff35f8f01466ff39601b1f1005f06d10168a14203d14168b1f57e7f3ed04ff47e70f7f7a5fa002800f0b2806ff0070142180831b1f57c7f177257729772d772177357739773d773f2d14ff47e710460416080f80e90a0f8c4a180f8c3b1068446848684c684068546858685c685068646868686c686068746878687c68755e8001f4145b0d1bff35f8f00bf45e8000121b155e8001f4145f8d0a5e70446d0f8980210b101b0bde8f08f4ff41630f5f711f900284ff000016ad00022831881544032b2f5163f59709970d970197159719971d971197259729972d972197359739973d973197459749974d974197559759975d975197659769976d976197759779977d97783f8201083f8211083f8221083f8231083f8241083f8251083f8261083f8271083f8281083f8291083f82a1083f82b1083f82c1083f82d1083f82e1083f82f1083f8301083f8311083f8321083f8331083f8341083f8351083f8361083f8371083f8381083f8391083f83a1083f83b1083f83c1083f83d1083f83e1083f83f109ad1c4f8980201b0bde8f08f002001b0bde8f08f70b5044690f8a00384f8a10350b3d4f8900347f64c6642f66535c2f20706c0f2440520b131682d31c4f8981310e040f22f00c0f200007844002122460023a847c4f89003316801f12d01c4f8981330b105f1e8022d219047002808bf70bd002084f8a10370bd00bf2de9f047a4b0d0f89442bff35f8fa4b142f691760546c0f2440620460021b04770b1d5f8900340b142f64d42c0f244022d2124b0bde8f047104724b0bde8f08747f64c69c2f20709d9f8007095f8a10300283fd0f6f726f9e0b3d5f89813781a17d495f8680110b995f82403e0b395f8a00385f8a10380b3d5f8900342f64d48c0f2440878b1d9f800102d31c5f898131de0d5f8900300b342f64d42c91bc0f24402904719e04ff64b70cff6ff70a8f1e807784400212a460023b847c5f89003d9f8001001f12d01c5f8981310b12d21c04710b1002085f8a10306f16601204624b0bde8f04708474af21f37c0f2470700200290adf80c00b84795f8680110b995f8240318b12846fff746ffe5e70df104084046f4f728fe02a9284600224ff0000afaf7f5fe81464046f4f7edfeb9f1000f02d085f8a1a303e00146284600f009f89df80c000028c7d107f14c008047c3e700bf2de9f04f90f8d13300f5697c4cf82310591c41f69a134b4390f8d0b31b0c03eb8303a1eb4301bbf1090f80f8d1139cbf0bf1010b80f8d0b3bbf1040f0bf0030e05d200244ff000094ff0000a2ee00bf0fc0800244ff000094ff0000a00eb8406d6f8a473d6f8a853b7fbfbf3d6f8ac1303eb090203fb1b73b5fbfbf7d6f8b06307fb1b5553443a44b1fbfbf72b44b6fbfbf53a4407fb1b1105eb020905fb1b6219440434a04502eb010ad7d1bef1000f1dd05cf82450bef1010fb5fbfbf606fb1b55b144aa4412d00ceb84056e68bef1020fb6fbfbf404fb1b66a144b24406d0ae68b6fbfbf505fb1b66a944b244bafbfbf202eb0901c0f8cc13bde8f08f00bff0b500294ff6ff7e00f0af80012903d10022c90775d1a8e021f00102c2f1000c6ff0010241f221038418a578e7788eea05252cb26e0036b203ead43484ea450503ead6366c0086ea450624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead53585ea460686ea07273eb27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead63686ea470703ead5357e0085ea470736b27d002db203ead636023286ea470703ead5360ceb0205023586ea470e95d10232c90733d0805c41f221038eea002001b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead232410082ea400009b2420012b203ead13181ea400003ead23181ea400e1ffa8ef0f0bd2de9f04fcbb00646c07c8b468df80600b08954998df80700000a8df808008df80a10080af1898df80b00080a17468df80d000020012b8df805308df809b08df80c108df80e008df80f008df810008df811008df812008df813008df814008df815008df816008df817008df818008df819008df81a008df81b008df81c008df81d008df81e008df81f008df820008df821008df822004cd1307e96f81780a0f1090144f62510c2f29240a1fb0002891a02eb510100970df10500b8eb910f88bf4fea9108c8ebc80706f11a0400f1010a00f10509093021463a46f0f7fffb06f1210506f1280029460722f0f7f7fb284621460722f0f7f2fb20465146032207f10905f0f7ebfb06f11d0049460422f0f7e5fbf07d02289cbf0130f075009fbb450cd0b8f1240f13d94ff0ff304bb0bde8f08fbb454ff00905f07509d14ef60b67abb20df10502c0f247070120f02115e002200df12304aab28df82300a01c0df105018df82470f0f7b9fba81c4af6610782b2c0f24607f02021460023b8474bb0bde8f08f2de9f04184b0044690f84d0000284ff0000000f09a8094f84f1042f28b0701f078018df8071094f85010c0f25b0701f007018df80610cde9020002a906200022b847054670b9002002adcde902000df1070128460122f0f77ffb012029460122b847054694f84e00a8b1002602a906200022cde90266b84760b9cde9026602ae04f1540130460122f0f766fb572031460122b8470543002602a906200022cde90266b84768b90df108080df1060140460122cde90266f0f74ffb312041460122b847054302a906200022cde90266b84768b9002002ae04f15301cde9020030460122f0f739fb462031460122b8470543002602a906200022cde90266b84768b90df1080804f1510140460222cde90266f0f722fb362041460222b847054302a9a3200022cde90266b847054302a997200022cde90266b84742f62b310543c0f2440102208847284615b104b0bde8f081002184f84e1084f84d10a16504b0bde8f08100bf2de9f04f8bb00190233002254ff000080df10c0a4ff001094ff0000b002402900be000bf09fa0bf0002f0bf1010b08bf0443bbf1070f354426d042f2ab60c0f20000784410f80b0042f2a561c0f20001794411f80b6042f2fb0351463246c0f25b03cde90988cde90788cde90588cde90388984707460028d4d10298514628443246f0f7b7facde742f2fb00c0f25b004ff60073002600f1340703a9c0f21f0381200c22cde90966cde90766cde90566cde90366b84730b9029803a928440c22f0f798fa8026ddf804c040f6b80146ea0400220ac2f200018cf823008cf824200a68002a00f0ad8045f2fd774ff6ff766ff0020241f22103c0f202070d681544ed7886ea052635b203ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea46060d6824b2154403ead4342d7984ea460686ea052635b203ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea460624b275002db203ead43484ea460603ead535740085ea46060d6824b2154403ead4346d7984ea460686ea052635b2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead434750084ea46062db2740024b203ead53585ea460603ead4350332ba4285ea46067ff460afb1b2090a01e0ff26ff218cf83e109cf84c109cf84d208cf83f1026218cf83d608cf84020ff288cf84b101cbf04208cf81c000bb0bde8f08f70b588b042f2fb0514460e46c0f25b05002181280791cde90511cde90311cde90111009107d11b023435694681202246a84720b905e069462246a84708b108b070bd6946054630462246f0f799f9284608b070bd2de9f0478cb08579972d17d00446fe2d0fd0fd2d2ad142f69570c0f25b008047002084f84e0084f84d00a0650cb0bde8f08720460cb0bde8f047cbe50020cde9040042f2fb00c0f25b00a0f1700304a9972000229847044642f62b31c0f244010220884720460cb0bde8f08742f2fb08002094f80c90677bc0f25b08cde90a00cde90800cde90600cde9040004a99f200422c047064620b901a804a90422f0f745f9002e6ff00100ddd19df80410bd29d9d19df805104029d5d19df806101029d1d194f84d00002852d047f64c60c2f20700006843f698210844a065002604a937200222cde90a66cde90866cde90666cde90466c047002840f0898002a804a90222f0f713f904a947200122cde90a66cde90866cde90666cde90466c047002875d10df1030004a90122f0f7fff80020cde90a00cde90800cde90600cde9040004a905200122c047002860d10df1020004a9012249ea0726f0f7e8f8352d5bdc002d00f08180012d70d19df8020082e0002604a9052001228df80e60adf80c600296cde90a66cde90866cde90666cde90466c047d8bb0df1080a04a950460122f0f7c4f804a935200122cde90a66cde90866cde90666cde90466c04738bb0af1010004a90122f0f7b1f8002604a937200222cde90a66cde90866cde90666cde90466c04798b90af1020004a90222f0f79df804a947200122cde90a66cde90866cde90666cde904660126c04778b14ff0ff300cb0bde8f087362d6ed0572d15d194f84e00002800f08580572039e00af1040004a90122f0f779f804f14f0051460722f0f773f884f84d603ee700208df801006946284601228df8009000f04ef9312d044627d036e09df80200002e00f0380618bf4036704010f0380f10d09df808009df8091042f2a2130e22c0f2000302ea96027b449a5a41ea0020904239d8012000218df80110694601228df8006000f024f904460df103014620012200f01df9054602a93620022200f017f945ea040141ea00040025a8f1700604a9a3200022cde90455b047044304a997200022cde90455b0470443aee69df802000e2101ea900042f22a11c0f200017944085a864204d96ff001000cb0bde8f0876946362002228df800708df8019000f0e6f80446d0e70020cde90a00cde90800cde90600cde9040004a9592001220125c04700287ff45caf04f1540004a90122eff7e5ff84f84e5060e740f6b800c2f200000168002904bf4ff0ff30704780b584b000684ef2173102904ff41630039002a8c0f2470188474ff4f07042f29f7e01904ff4207cc0f25b0e0020002100220023cdf800c0f04704b080bd00bf2de9f04340f6b801c2f2000109684ff0000e01f1020c4cf6cd4340f2762808e00ef1010ebef5f07f0cf5a07c08bfbde8f083aef1a0096ff00906644607e000bf07eb0711a170053445452e46e8d290f84c1006f10a054f1e112905fb03f208bf570d122908d1a6f1e6019f294ff000079cbfb9f19f0f077b07eb071104f8021c90f84c1006f10c024f1e112903fb02f208bf570d122908d1a6f1e4019f294ff000079cbfb9f19f0f077b07eb071104f8011c90f84c1006f10e024f1e112903fb02f208bf570d122908d1a6f1e2019f294ff000079cbfb9f19f0f077b07eb0711217090f84c1006f110024f1e112903fb02f208bf570d122908d1a6f1e0019f294ff000079cbfb9f19f0f077b07eb0711617090f84c1006f112024f1e112903fb02f208bf570d12298ad1a6f1de019f294ff000079cbfb9f19f0f077b80e700bf2de9f04383b042f28b0914460e460546c0f25b090027694606200022cde90077c84710b103b0bde8f083e846404631462246cde90077eff7fbfe284641462246c84703b0bde8f08370b50446d0f840010d4638b92046f5f74ffa0028c4f8400108bf70bd42f64d46c0f2440606f140018847d4f8400129463246bde87040104746f6cc10c2f20700007808b10020704743f63c40c2f20700817a29b10178ff2902d14178ff29f1d090f83a1039b190f83010ff2903d190f83110ff29e6d090f86a1039b190f86010ff2903d190f86100ff28dbd0012070472de9f04f97b0229d4af6ab261692826805f15f07c0f2aa26a7fb064e1491511c15918160002d08bf4ff0010ed0f800904168b5f5007fbff35f8f05d9c1680131c16017b0bde8f08f219f002db7fa87f72a464fea571718bf01221742eed1a1eb090120318e45e9d847f64c610290c2f207010868bef1000f139000f0bc800298209a00f1e20112911599008e0f0a11970f0c090ecde90e10000a0d9016984ff0000c000a0c90180a0b90100a0a90280a09901398ca46010a0891010c000e069021984ff000080130109707910190cde9033ecdf814900ae008f101080bf11801dc44f0450af1010a017000f0848008eb0901129801f01f017924a5eb0c0211fb04004fea1c21017593464b21602a28bf4ff0600b4170422181700121c170149965450171159943734171119945748171109980f813c0c1710e9901720f9941720d9981721699c1720c9901730b9981732099c1730a9901740999817413994175089981750799c17506990176b4d02b46042a01d200261ee0029a0af01f01792711fb0721019a0bf07c0402eb0c050026aa1912f8019c01eb060e8ef8fb90af5d04368ef8fc705778b4428ef8fd7092788ef8fe20ecd11d46dde9033eddf814901bf0030788d0219a00f1190102eb0c04a25d012f8a553ff47faf721c14f80290022f01f80290ddf814903ff475afb21ca75c8f5470e7bff35f8f029809eb0e01016000f128040122bff35f8f54e8001f44e80023002bf9d1bff35f8f11b117b0bde8f08f006a42f64d42c0f244021421904700281ebfbff35f8f0020206017b0bde8f08fb0b546f6cc12c2f2070212780ab10320b0bd43f64642c2f2070213783bb112f80a3cff2b03d112f8093cff2befd092f830303bb192f82630ff2b03d192f82730ff2be4d092f860303bb192f85630ff2b03d192f85730ff2bd9d0137892f8304092f86020b4fa84f46409002b08bf0134002a08bf44f001043cb144f2a932c0f24802904718b10020b0bd0520b0bd43f62d45c0f248050120a84704460020a8470146042c4ff0050088bfb0bd2144092998bf0020b0bd00bff0b581b043f6cc0200eb0011c2f2070212f821200ab1032121e043f6c402c2f2070202eb8104216889b943f62d470646c0f248070120b84705460020b847042d4ff005010bd828440928304607d84cf2e573c0f251030121224698470021084601b0f0bd2de9f04f81b088460b999b469246b8f1090f064605d0b8f10a0f05d1bbf1000f02d08946052505e003258946b8f10b0f08bfcd1c05f1080449f6cd71a0b2c0f24c018847034600284ff0000056d0ddf828e024f00301b44605f003024c426ff0030100bf5e1804316718043730717071b071f071f6d142b158180021012a017103d0022a417118bf8171280ab8f1090f1d7058700dd14fea1a2083f802a0d87083f804b04fea1b20022204210827052618e0b8f10a0f24d10c20bbf1000f08bf0a2018724fea1a2083f809a0987233d05ffa8bf04fea1b2106220c270b2683f802b0d9709855d9554af261560027c0f24c06604651460097b047012001b0bde8f08f5fea0b604ff0520008bf12204ff00a02187208bf09224fea1a20b9f1000f83f809a09872dfd0f046b9f1040f09f0030e03d2002715e00522d5e729f0030108f10106002700bff51915f8014cd819c472f45d043704736c78b9424473ac788473f1d1bef1000fbed018f8070003f10b01bef1010fc855b6d0781c18f80040bef1020f0c54afd0b81c18f800700f54aae700bf2de9f04f81b0934612788ab1022300bf0beb030717f8012c62b11bf8032062b17a784ab1ba780433002af1d1023b04e0002205e0013b00e0013303eb4302520042eae272931c02f1010c01eb810203f0030e23f0030a00eb8213a3f5a0784ff0ff3906e009f10109b9f10d0f08f5a0786bd009eb010202eb8202bcf1030f00eb821605d24ff0ff34bef1000f2ed1e9e70024474604e000bfa24507f1020721d0621cd209042a03d83a7802f0f0023a70a21cd209042a03d87a7802f00f027a70e21cd209042a03d87a7802f0f0027a700434e209042adfd86208b55c05f00f05b554d9e7013cbef1000fbbd0a21cd509042d08d85208b55ce7076ff00f0708bf0f273d40b554bef1010fabd0e21cd509042d09d85208b55ce7074ff00f0708bf6ff00f073d40b554bef1020f9ad0221dd509042d96d85208e407b55c6ff00f0408bf0f242c40b4548ce79bf80010cdf800b0002900f0ce80022041f2410a41f2420b41f2430808e0009a063012f8011f03330029009200f0bd80a1f17f0717f15f0ff1d341f25932c0f2000201eb41017a4402eb81014ff20014a1f5c079cff6ff7402e014f52074ded0494619f9027bc509042d09d8b7f1ff3f06dc1a1992f8016f46f0f00682f8016f5ffa87fe5fea4e6208d5042d06d81a1992f8017f47f00f0782f8017f5fea8e620ad540f27d22904206d81a1992f8027f47f0f00782f8027f5feace6209d5b0f51f7f06d81a1992f8027f47f00f0782f8027f5fea0e724fea900c09d5bcf19e0f06d81a1992f8036f46f0f00682f8036f5fea4e720ad540f27a22904206d81a1992f8037f47f00f0782f8037f91f90110042d09d8b1f1ff3f06dc1a1912f80a7047f0f00702f80a70c9b24a0608d5042d06d81a1912f80a7047f00f0702f80a708a060ad540f27d22904206d81a1912f80b7047f0f00702f80b70ca0609d5b0f51f7f06d81a1912f80b7047f00f0702f80b700a0709d5bcf19e0f06d81a1912f8087047f0f00702f8087049077ff565af40f27a2188423ff660af191911f8082042f00f0201f8082057e701b0bde8f08f00bf2de9f04381b04ff29c51c2f229010f68044638466ff39600b0f1005fbff35f8f0cd138684ef66c61ccf2ff01884205d17868b0f57e7f18bf002700e0002745f64d50c0f24600804741f23161c0f2000141f23662c0f2000279447a44022808bf0a4641f21861c0f2000179440128204618bf114600f03efe47b197f87b0180b141f21661c0f20001794419e041f20361c0f200017944204601b0bde8f04300f029be97f8740141f2f052c0f2000241f2ed51c0f2000179447a44002808bf1146204600f017fe97f8750141f2cd52c0f2000241f2d751c0f200017944012820467a4408bf114600f005fe41f2c551c0f200017944204600f0fdfd97f9c311204600f0ecfe41f2b151c0f200017944204600f0f0fdf6f7e6fd41f29358c0f2000841f29f56c0f200067e44054600f003003146f844012808bf414641f27d59c0f2000902282046f94408bf494600f0d2fda808012808bf4646022808bf4e462046314600f0c7fd41f25b51c0f200017944204600f0bffdd7f8840198b147f64c61c2f207010a68821a012a0bdb0968401a44f6d35100f2e730c1f26201a0fb0101890900e00021204600f0b4fe41f21d51c0f200017944204600f09cfdd7f8bc11204600f0a7fe41f20a51c0f200017944204600f08ffdb7f8c011204600f09afe41f2f241c0f200017944204600f082fd97f8c211204600f08dfe41f2db41c0f200017944204600f075fdb7f8c611204600f080fe41f2c845c0f200057d442046294600f067fdb7f8c811204600f072fe2046294600f05efdb7f8ca11204600f069fe41f29c41c0f200017944204600f051fdd7f88011204600f05cfe41f28741c0f200017944204600f044fd97f9c511204600f033fe41f27341c0f200017944204600f037fd97f9c411204601b0bde8f04300f023be00bf2de9f04f81b094464a1c00f08a804fea912e0026825d002a00f0638183195a78002a00f005819a78002a00f00381da78002a00f001811a79002a00f0ff805a79002a00f0fd809a79002a00f0fb80da79002a00f0f9801a7a002a00f0f7805a7a002a00f0f5809a7a002a00f0f380da7a002a00f0f1801a7b002a00f0ef805a7b002a00f0ed809a7b002a00f0eb80da7b002a00f0e9801a7c002a00f0e7805a7c002a00f0e5809a7c002a00f0e580da7c002a00f0e5801a7d002a00f0e5805a7d002a00f0e5809a7d002a00f0e580da7d002a00f0e5801a7e002a00f0e5805a7e002a00f0e5809a7e002a00f0e580da7e002a00f0e5801a7f002a00f0e5805a7f002a00f0e5809a7f002a00f0e580da7f002a00f0e5802036602e7ff47baf6026dfe00021425c002a00f0978143185a78002a00f09f809a78002a00f09f80da78002a00f09f801a79002a00f09f805a79002a00f09f809a79002a00f09f80da79002a00f09f801a7a002a00f09f805a7a002a00f09f809a7a002a00f09f80da7a002a00f09f801a7b002a00f09f805a7b002a00f09f809a7b002a00f09f80da7b002a00f039811a7c002a00f037815a7c002a00f035819a7c002a00f03381da7c002a00f031811a7d002a00f02f815a7d002a00f02d819a7d002a00f02b81da7d002a00f029811a7e002a00f027815a7e002a00f025819a7e002a00f02381da7e002a00f021811a7f002a00f01f815a7f002a00f01d819a7f002a00f01b81da7f002a00f01981203160297ff47baf1be1013656e0023654e0033652e0043650e005364ee006364ce007364ae0083648e0093646e00a3644e00b3642e00c3640e00d363ee00e363ce00f363ae0103638e0113636e00131f0e0123632e00231ece013362ee00331e8e014362ae00431e4e0153626e00531e0e0163622e00631dce017361ee00731d8e018361ae00831d4e0193616e00931d0e01a3612e00a31cce01b360ee00b31c8e01c360ae00c31c4e01d3606e00d31c0e01e3602e00e31bce01f36b1f5205f1ed3012164234ff47a7442f2107501eb81025200befbf2f70a2f13d301fb03f2befbf2f70a2f0dd301fb04f2befbf2f70a2f07d36943befbf1f2092ae7d802e0012100e011465f2eb24698bf4ff05f0a5e2e6ad84cf6cd49cdf800c0caf1000806f1040cccf6cc49befbf1f400eb0c0b04f1300209290bf8042c4ad908eb0c06032ea1fb09324ed004fb11e4d208b4fbf2f5642905f130030bf8033c3cd348f21f53c5f2eb13022ea1fb03733bd005fb12445a09b4fbf2f5b1f57a7f05f130030bf8023c2bd344f6d353c1f26203012ea1fb033627d005fb1242b609b2fbf6f542f2107705f13003b9420bf8013c19d341f25973cdf2b713a1fb03130cf1040c05fb162e08eb0c0104294fea5331abd109e0acf1030a06e0acf1020a03e0acf1010a00e0e246ddf800c0002100f80a102de00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2904d801444ff03f020a7003d1002180f85f1001e000224a700021425c002a00f0a08043185a78002a5ed09a78002a5dd0da78002a5cd01a79002a5bd05a79002a5ad09a79002a59d0da79002a58d01a7a002a57d05a7a002a56d09a7a002a55d0da7a002a54d01a7b002a53d05a7b002a52d09a7b002a51d0da7b002a50d01a7c002a4fd05a7c002a4ed09a7c002a4dd0da7c002a4cd01a7d002a4bd05a7d002a4ad09a7d002a49d0da7d002a48d01a7e002a47d05a7e002a46d09a7e002a45d0da7e002a44d01a7f002a43d05a7f002a42d09a7f002a41d0da7f002a40d0203160297ff49aaf44e001313ae0023138e0033136e0043134e0053132e0063130e007312ee008312ce009312ae00a3128e00b3126e00c3124e00d3122e00e3120e00f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2905d801444ff02f020a7040f09180002180f85f101cf1010100f090804fea9c210024025d002a00f0698103195a78002a00f00b819a78002a00f00981da78002a00f007811a79002a00f005815a79002a00f003819a79002a00f00181da79002a00f0ff801a7a002a00f0fd805a7a002a00f0fb809a7a002a00f0f980da7a002a00f0f7801a7b002a00f0f5805a7b002a00f0f3809a7b002a00f0f180da7b002a00f0ef801a7c002a00f0ed805a7c002a00f0eb809a7c002a00f0eb80da7c002a00f0eb801a7d002a00f0eb805a7d002a00f0eb809a7d002a00f0eb80da7d002a00f0eb801a7e002a00f0eb805a7e002a00f0eb809a7e002a00f0eb80da7e002a00f0eb801a7f002a00f0eb805a7f002a00f0eb809a7f002a00f0eb80da7f002a00f0eb802034602c7ff47baf6024e5e000224a701cf101017ff470af0021425c002a00f0988142185378002b00f09f809378002b00f09f80d378002b00f09f801379002b00f09f805379002b00f09f809379002b00f09f80d379002b00f09f80137a002b00f09f80537a002b00f09f80937a002b00f09f80d37a002b00f09f80137b002b00f09f80537b002b00f09f80937b002b00f09f80d37b002b00f03a81137c002b00f03881537c002b00f03681937c002b00f03481d37c002b00f03281137d002b00f03081537d002b00f02e81937d002b00f02c81d37d002b00f02a81137e002b00f02881537e002b00f02681937e002b00f02481d37e002b00f02281137f002b00f02081537f002b00f01e81937f002b00f01c81d27f002a00f01a81203160297ff47baf1ce1013456e0023454e0033452e0043450e005344ee006344ce007344ae0083448e0093446e00a3444e00b3442e00c3440e00d343ee00e343ce00f343ae0103438e0113436e00131f1e0123432e00231ede013342ee00331e9e014342ae00431e5e0153426e00531e1e0163422e00631dde017341ee00731d9e018341ae00831d5e0193416e00931d1e01a3412e00a31cde01b340ee00b31c9e01c340ae00c31c5e01d3406e00d31c1e01e3402e00e31bde01f344ff00109bcf5205f1fd364234ff47a7742f2107609eb89025200b1fbf2f50a2d12d309fb03f2b1fbf2f50a2d0cd309fb07f2b1fbf2f50a2d06d309fb06f9b1fbf9f2092ae6d800e091465f2ca44698bf4ff05f0c5e2c05d9002100f80c1001b0bde8f08f4cf6cd4accf1000e04f1040bccf6cc4ab1fbf9f400eb0b0704f13002b9f1090f07f8042c4bd90eeb0b06032ea9fb0a25e0d004fb1911ec08b1fbf4f5b9f1640f05f1300207f8032c3cd348f21f52c5f2eb12022ea9fb0232ccd005fb14115409b1fbf4f8b9f57a7f08f1300207f8022c2bd344f6d352c1f26202012ea9fb0225b8d008fb1411ac09b1fbf4f542f2107305f13002994507f8012c19d341f25972cdf2b712a9fb02230bf1040b05fb14110eeb0b02042a4fea5339a9d19ae7abf1030c97e7abf1020c94e7abf1010c91e7dc468fe70f311ee010311ce011311ae0123118e0133116e0143114e0153112e0163110e017310ee018310ce019310ae01a3108e01b3106e01c3104e01d3102e01e3100e01f315f2904d801444ff03f020a7005d1002180f85f1001b0bde8f08f0020487001b0bde8f08f00bf2de9f0411f22831813f81f7c002f00f0808013f81e7c002f7dd013f81d7c002f7bd013f81c7c002f79d013f81b7c002f77d013f81a7c002f75d013f8197c002f73d013f8187c002f71d013f8177c002f6fd013f8167c002f6dd013f8157c002f6bd013f8147c002f69d013f8137c002f67d013f8127c002f65d013f8117c002f63d013f8107c002f61d013f80f7c002f5fd013f80e7c002f5dd013f80d7c002f5bd013f80c7c002f59d013f80b7c002f57d013f80a7c002f55d013f8097c002f53d013f8087c002f51d013f8077c002f4fd013f8067c002f4dd013f8057c002f4bd013f8047c002f49d013f8037c002f47d013f8027c002f45d013f8013c002b43d0835c002b41d020327f2a7ff47baf64e01f3a3ae01e3a38e01d3a36e01c3a34e01b3a32e01a3a30e0193a2ee0183a2ce0173a2ae0163a28e0153a26e0143a24e0133a22e0123a20e0113a1ee0103a1ce00f3a1ae00e3a18e00d3a16e00c3a14e00b3a12e00a3a10e0093a0ee0083a0ce0073a0ae0063a08e0053a06e0043a04e0033a02e0023a00e0013a5f2a25d8c2f15d0cc2f15e0ec2f15f03c2f160080244002509e000bffc78002cf47008bfbde8f0810435a84510d04e5d565586b1ab420bd04f197c78561974704cb1ae4504d0bc78b47024b1ac45e5d1002180f85f10bde8f08100bf7f2905d140f2df71c0f20001794403e7b1f1ff3fc8bf0fe0b0b540f2c972c0f200027a440d4611460446fff7f5fe20466942bde8b040ffe72de9f04f0024025d002a00f0a18003195a78002a5fd09a78002a5ed0da78002a5dd01a79002a5cd05a79002a5bd09a79002a5ad0da79002a59d01a7a002a58d05a7a002a57d09a7a002a56d0da7a002a55d01a7b002a54d05a7b002a53d09a7b002a52d0da7b002a51d01a7c002a50d05a7c002a4fd09a7c002a4ed0da7c002a4dd01a7d002a4cd05a7d002a4bd09a7d002a4ad0da7d002a49d01a7e002a48d05a7e002a47d09a7e002a46d0da7e002a45d01a7f002a44d05a7f002a43d09a7f002a42d0da7f002a41d02034602c7ff49aaf60243ce001343ae0023438e0033436e0043434e0053432e0063430e007342ee008342ce009342ae00a3428e00b3426e00c3424e00d3422e00e3420e00f341ee010341ce011341ae0123418e0133416e0143414e0153412e0163410e017340ee018340ce019340ae01a3408e01b3406e01c3404e01d3402e01e3400e01f344ff0010a0a2920d364224ff47a7742f2107600bf0aeb8a035b00b1fbf3f50a2d12d30afb02f3b1fbf3f50a2d0cd30afb07f3b1fbf3f50a2d06d30afb06fab1fbfaf3092be6d800e09a465f2ca44698bf4ff05f0c5e2c04d9002100f80c10bde8f08f4cf6cd4bccf1000904f1040eccf6cc4bb1fbfaf500eb0e0705f13002baf1090f07f8042c4bd909eb0e06032eaafb0b34e1d005fb1a11e508b1fbf5f4baf1640f04f1300307f8033c3cd348f21f52c5f2eb12022eaafb0223cdd004fb15115d09b1fbf5f8baf57a7f08f1300207f8022c2bd344f6d352c1f26202012eaafb0224b9d008fb1511a409b1fbf4f542f2107305f130029a4507f8012c19d341f25972cdf2b712aafb02230ef1040e05fb141109eb0e02042a4fea533aa9d19be7aef1030c98e7aef1020c95e7aef1010c92e7f44690e70000434d01ffff0000000000000052420100ff000000080310000000000000000000080010631a2308011a1c0800100018c00420a0024801520964617368626f617264580162012028904e46616365636c61772f33390000000000000000000000000000002020202020002020000000505050000000000000000000005050f85050f85050000000002070a8a07028a8702000000048a85010202854480000000020505020689090680000002020200000000000000000000010204040404020100000000040201010101020400000000000005020f82050000000000000002020f82020000000000000000000000020204000000000000000f800000000000000000000000000202000000000080810102020404000000000708898a8c88888700000000020602020202020700000000070888808102040f8000000007088083008088870000000000818284888f8080800000000f88080f00808887000000000708080f08888887000000000f808081010202020000000007088887088888870000000007088888878080870000000000000202000002020000000000000202000002020400000000008102040201008000000000000f80000f8000000000000004020100810204000000000708888102000202000000000708898a8a89880780000000070888888f888888800000000f08888f0888888f000000000708880808080887000000000e0908888888890e000000000f88080f0808080f800000000f88080f0808080800000000070888080b888887000000000888888f888888888000000007020202020202070000000003810101010909060000000008890a0c0c0a090880000000080808080808080f80000000088d8a8a888888888000000008888c8a89888888800000000708888888888887000000000f0888888f080808000000000708888888888a87008000000f0888888f0a0908800000000708880700808887000000000f8202020202020200000000088888888888888700000000088888850505020200000000088888888a8a8d88800000000888850202050888800000000888850502020202000000000f8081020408080f8000000007040404040404070000000004040202010100808000000007010101010101070000000205088000000000000000000000000000000000000f80040200000000000000000000000000000700878888878000000008080f088888888f00000000000007088808088700000000008087888888888780000000000007088f8808078000000001820702020202020000000000000788888888878087000008080f08888888888000000202000602020202070000000080800180808080808483000004040485060605048000000006020202020202070000000000000f0a8a8a8a8a8000000000000f08888888888000000000000708888888870000000000000f088888888f0808000000000788888888878080800000000b8c0808080800000000000007880700808f00000000020207020202020180000000000008888888888780000000000008888505020200000000000008888a8a8a870000000000000885020205088000000000000888888888878087000000000f810204080f800000000182020402020201800000000202020202020202000000000601010081010106000000048a89000000000000000009f0535593747c181040101010201020c005353a829c51bd314a810260d5b0bfe096d6963205220006d6963204c20006d6963203f20006e6f206374780061726d200063666720006f6666200070646d00636f646563002072656720002074626c2000540053002d00206c65617365200073207461702000200042400020736b697020002f002066722000206e7466200020756e7265672000000000", "desc": "append injected blobs to main-app payload" }, { "offset": 779123, "old": "805a3900", - "new": "68703a00", + "new": "187c3a00", "desc": "main-app subheader payload size (ps)" }, { "offset": 152, "old": "005b3900", - "new": "e8703a00", + "new": "987c3a00", "desc": "main-app TOC entry size (ps + 128)" }, { "offset": 779243, "old": "805a3904", - "new": "68703a04", + "new": "187c3a04", "desc": "main-app preamble length (low 24 bits)" }, { "offset": 779247, "old": "effdbcea", - "new": "0b0c48b0", + "new": "ed6f6deb", "desc": "[5] ota/s200_firmware_ota.bin preamble crc32" }, { "offset": 156, "old": "c0c6322a", - "new": "52937d21", + "new": "7141aa39", "desc": "[5] ota/s200_firmware_ota.bin component crc32c (TOC)" }, { "offset": 779127, "old": "c0c6322a", - "new": "52937d21", + "new": "7141aa39", "desc": "[5] ota/s200_firmware_ota.bin component crc32c (subheader)" } ] diff --git a/app/g2/glasses-display-state.ts b/app/g2/glasses-display-state.ts index 20a7a736..869a154a 100644 --- a/app/g2/glasses-display-state.ts +++ b/app/g2/glasses-display-state.ts @@ -3,6 +3,8 @@ export type GlassesDisplayState = { silentMode: boolean; screenOn: boolean; battery: number | null; + /** The paired glasses' model, e.g. "G2" (glassesModelName). */ + glassesModel: string; /** * The charging case's last-known level, and whether it is on USB (null * while the glasses are out of the case). Shown only while charging, when @@ -20,7 +22,7 @@ export function glassesDisplayLabel(state: GlassesDisplayState): string { // Charging wins over every session-local state: the glasses are in their // case, so neither the lock screen nor the foreground window is visible. if (state.phase === "charging") { - return chargingDisplayLabel(state.battery); + return chargingDisplayLabel(state.battery, state.glassesModel); } // Preview mode has a live (simulated) screen despite the disconnected // phase, so fall through to the screen-state/foreground labels. @@ -63,8 +65,8 @@ export function glassesDisplayAsleep(state: GlassesDisplayState): boolean { ); } -export function chargingDisplayLabel(battery: number | null): string { - return validBatteryLevel(battery) ? `Charging · G2 ${battery}%` : "Charging"; +export function chargingDisplayLabel(battery: number | null, glassesModel: string): string { + return validBatteryLevel(battery) ? `Charging: ${glassesModel} ${battery}%` : "Charging"; } /** The shell's last-known battery levels (ShellChromeState["battery"]), as far as the phone shows them. */ @@ -78,16 +80,16 @@ export type BatteryLevels = { }; /** - * The phone Settings tab's battery row: each device whose level is known, + * The phone settings page's battery row: each device whose level is known, * e.g. "G2 100% · Case 98% ⚡ · R1 72%" (⚡ = charging), or "" when none * is. Levels are the last known ones (the case only reports while the glasses - * are docked), so ⚡ appears only while it is live: G2 and Case only with a - * link to the glasses (`glassesLinked`: connected or charging), and Case only - * while they are docked (caseCharging is null otherwise). + * are docked), so ⚡ appears only while it is live: the glasses and Case only + * with a link to the glasses (`glassesLinked`: connected or charging), and Case + * only while they are docked (caseCharging is null otherwise). */ -export function formatBatteryLine(levels: BatteryLevels, glassesLinked: boolean): string { +export function formatBatteryLine(levels: BatteryLevels, glassesLinked: boolean, glassesModel: string): string { const devices: Array<[string, number | null, boolean | null]> = [ - ["G2", levels.headset, glassesLinked && levels.headsetCharging], + [glassesModel, levels.headset, glassesLinked && levels.headsetCharging], ["Case", levels.case, glassesLinked && levels.caseCharging], ["R1", levels.ring, levels.ringCharging], ]; diff --git a/app/g2/ios-peripheral-identity.ts b/app/g2/ios-peripheral-identity.ts index 4dd32f12..41a31151 100644 --- a/app/g2/ios-peripheral-identity.ts +++ b/app/g2/ios-peripheral-identity.ts @@ -1,12 +1,26 @@ -import { classifyAdvertisement, hasEvenManufacturerSignature, type EvenAdvertisement } from './even-advertisement' +import { classifyAdvertisement, g1FromName, hasEvenManufacturerSignature, type EvenAdvertisement } from './even-advertisement' import { hexToBytes } from '../util/hex-util' export type IosAdvertisement = { identifier: string; name: string; manufacturerData: string; rssi: number; connectable: boolean } export type IosDevice = EvenAdvertisement & { identifier: string } +/** + * A G1 arm advertises no full MAC, and CoreBluetooth hides the real one. Faceclaw's addresses are MAC-shaped everywhere, so its + * address on this phone is made from the peripheral identifier. It's stable as long as the identifier is, which on firmware + * 0.5.66 and later is across installs too, and it only has to mean something on this phone: nobody types it in. + */ +export function g1IosAddress(identifier: string): string { + return identifier.replace(/-/g, '').slice(0, 12).toUpperCase().replace(/(..)(?=.)/g, '$1:') +} + /** Only a full vendor-advertised MAC may bind a manually entered address. */ export function identifyIosPeripheral(raw: IosAdvertisement): IosDevice | null { if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(raw.identifier)) return null + if (g1FromName(raw.name)) { + const arm = classifyAdvertisement({ ...raw, address: g1IosAddress(raw.identifier), source: 'scan', bonded: false, + txPower: null, seenAtMs: Date.now() }) + return arm && { ...arm, identifier: raw.identifier.toUpperCase() } + } if (!hasEvenManufacturerSignature(hexToBytes(raw.manufacturerData))) return null const candidate = classifyAdvertisement({ ...raw, address: '', source: 'scan', bonded: false, txPower: null, seenAtMs: Date.now() }) diff --git a/app/g2/ios-preview-controller.ts b/app/g2/ios-preview-controller.ts index 51b66869..6d9d617b 100644 --- a/app/g2/ios-preview-controller.ts +++ b/app/g2/ios-preview-controller.ts @@ -2,7 +2,6 @@ import { startRemoteInput } from "../remote/service" import type { KeyboardInputSession } from '../ui/shell/keyboard-input' import { acceptInput, resetRingInputFilter } from "../ui/input-monitor"; import { bindIosNotifications, iosNotificationsChanged, onIosNotificationPopup, readActiveNotifications } from '../native/notification-icons.ios' -import { shouldShowNotificationOnGlasses } from '../native/notification-sources' import { launcherEntries } from '../apps/launcher' import { discardZeroedEvenHubPackage, getInstalledEvenHubAppById, installedEvenHubPackageId, uninstallEvenHubPackage } from '../apps/evenhub/installed-apps' import { isInstalledPackagePresent } from '../apps/evenhub/updates' @@ -23,13 +22,17 @@ import { weatherBridge } from '../native/weather' import { FaceclawCommunicatorBridge, resolveIosPeripherals, type CommunicatorState, type RawInputEvent } from '../native/faceclaw-communicator.ios' import { PreviewDisplayTarget, type DisplayTarget } from '../native/preview-display.ios' import { AncsClient, ANCS_FIRMWARE_VERSION } from './ancs-client' +import { G1V0_IMAGE } from '../g1/firmware/g1v0-image' import { GlanceHost, type GlanceDisplay } from './glance-host' import { createLockScreenImage, LOCK_SCREEN_SURFACE_ID } from './lock-screen' import { OsEventTypeList } from './events' import { loadDeviceAddresses } from './device-addresses' import { updateGlassesPresence } from './glasses-presence' import { firmwareIncompatibilityMessage, hasCompatibleFirmware } from './firmware-compat' -import { isHaltedSessionPhase, suppressAutoReconnect } from './reconnect-policy' +import { keyboardService } from './keyboard/service' +import type { KeyEvent } from './keyboard/keys' +import { isHaltedSessionPhase, resumeAutoReconnect, suppressAutoReconnect } from './reconnect-policy' +import { WearRemote, type WearRemoteInputKind } from './wear-remote' 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' @@ -46,13 +49,13 @@ import { makeInputEvent, type InputEvent, type InputEventPayload } from '../ui/g import { noopLayerActions, type ContinuousCaptureOptions, type LayerActions } from '../ui/layers' import { TextViewerLayer } from '../apps/files/text-viewer' import { shell, rawInputEventToInputEvent, type ShellWindow } from '../ui/shell/shell' -import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, type ScreenRect } from '../ui/shell/geometry' +import { appViewportRect, isOnSwitcherEdge, sidebarStripVisible, windowEdges, type ScreenRect } from '../ui/shell/geometry' import { mirrorToPanelFraction, phonePreviewCrop } from './phone-preview-crop' import { onAnySettingChanged, previewColorSetting, lockScreenEnabledSetting, getBrightnessPreferences, getStringSettingById, nightscoutSiteUrlSetting, nightscoutApiTokenSetting, voiceProviderSetting, elevenLabsApiKeySetting, openAiApiKeySetting, sonioxApiKeySetting, whisperServerApiKeySetting, whisperServerLanguageSetting, - whisperServerModelSetting, whisperServerUrlSetting, ringConnectionModeSetting, saveTranscribeAudioSetting } from '../ui/dashboard-settings' + whisperServerModelSetting, whisperServerUrlSetting, ringConnectionModeSetting, saveRecordingSetting, glassesTypeSetting, shouldPopUpNewNotification } from '../ui/dashboard-settings' import { transcriptionKey, type VoiceProviderSelection } from '../native/cloud-stt-provider' import type { PhoneGesture } from '../phone-ui/phone-gestures' import { claimGlassesOnboardingAutoLaunch, ONBOARDING_APP_ID } from '../apps/onboarding/onboarding-progress' @@ -167,6 +170,8 @@ 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), @@ -210,9 +215,10 @@ export class IosPreviewController { prepareVoiceCapture: () => this.prepareVoiceCapture(), getScreenTimeoutMs: () => null, requestShellRender: () => this.requestShellRender(), - onWindowsChanged: () => { this.requestShellRender(); this.syncEvenHubPhoneUi() }, + onWindowsChanged: () => { this.requestShellRender(); this.syncEvenHubPhoneUi(); this.wearRemote?.schedulePublish() }, openNotificationsWindow: () => - this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, createNotificationsAppWindow), + this.openInProcessAppInBackground(NOTIFICATIONS_WINDOW_ID, NOTIFICATIONS_SURFACE_ID, + options => createNotificationsAppWindow(options, section => { void this.launchApp('settings', { section }) })), onSwitcherBarHeightChanged: () => { this.relayout() shell.foregroundWindow()?.requestRender() @@ -227,6 +233,8 @@ export class IosPreviewController { this.unblankAfterShellRender = on if (!on) void this.display?.setScreenBlanked(true).catch(error => this.fail(error)) this.requestShellRender() + this.wearRemote?.schedulePublish() + if (on) keyboardService.retryNow() }, }) const launcher = createLauncherWindow({ @@ -243,7 +251,7 @@ export class IosPreviewController { shell.focusWindow(launcher.windowId) onIosNotificationPopup(key => { const notification = readActiveNotifications(128).find(n => n.key === key) - if (this.glassesLocked || !notification || !shouldShowNotificationOnGlasses(notification.packageName)) return + if (this.glassesLocked || !notification || !shouldPopUpNewNotification(notification.packageName)) return const woke = !shell.isScreenOn() && shell.wake('sidebar') shell.openNotificationModal(key, woke) this.requestShellRender() @@ -265,16 +273,52 @@ export class IosPreviewController { assistantAvailable: () => shell.isAssistantAvailable(), assistant: text => shell.sendToAssistant(text), }) + // A keyboard paired through the glasses (the CFW keyboard bridge). The service decides what + // each key means (app/g2/keyboard/key-router.ts); its gestures share the controller queue + // with physical input, like the watch's. + const queueKeyboardInput = (run: () => Promise): Promise => { + const task = this.inputQueue.then(() => { this.onActivity(); return run() }) + this.inputQueue = task.catch(error => this.fail(error)) + return task + } + keyboardService.setHost({ + ready: () => this.state.phase === 'connected', + locked: () => this.glassesLocked, + wake: () => { void queueKeyboardInput(() => this.receiveInput(makeInputEvent({ type: 'display-wake' }))).catch(() => {}) }, + gesture: (gesture, origin) => queueKeyboardInput(async () => { + await this.receiveInput(makeInputEvent({ type: gesture, source: origin } as InputEventPayload)) + // A discrete hold includes its release. + if (gesture === 'long-press') await this.receiveInput(makeInputEvent({ type: 'long-press-release', source: origin })) + }), + log: line => this.logBluetooth(line), + // Only while the display is on: a keyboard that is switched off would otherwise keep the + // glasses' radio looking for it around the clock. + shouldReconnect: () => this.state.phase === 'connected' && shell.isScreenOn(), + }) // The header's EvenHub phone-UI button hides while that UI is showing. onPhoneShownChanged(() => this.syncEvenHubPhoneUi()) registerSystemTools() - registerWindowTools({ apps: ALL_APPS.filter(app => !iosAppUnavailableReason(app.appId)), + registerWindowTools({ apps: () => ALL_APPS.filter(app => app.isSupported?.() !== false && !iosAppUnavailableReason(app.appId)), launchApp: id => this.launchApp(id), requestShellRender: () => this.requestShellRender() }) registerNavigateTools(id => this.launchApp(id)) registerRoamTools(id => this.launchApp(id)) // 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 && app.isSupported?.() !== 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. */ @@ -341,7 +385,7 @@ export class IosPreviewController { this.logBluetooth(`Phone background; glasses ${this.state.phase}`) this.flushBluetoothLog() } - /** Overlay an EvenHub app's phone UI (the header's app-icon button). */ + /** Overlay an EvenHub app's phone UI (the app-icon button under the mirror). */ showEvenHubPhoneUi(windowId: string): void { showOnPhone(windowId) } @@ -399,6 +443,7 @@ export class IosPreviewController { this.logBluetooth(`Phone battery ${phone.battery ?? "unknown"}% charging=${phone.charging}`) this.offSettings = onAnySettingChanged(() => { this.syncLockSetting() + this.syncContinuousRecording() this.pushBrightness() this.relayout() shell.foregroundWindow()?.requestRender() @@ -443,6 +488,7 @@ 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) @@ -451,6 +497,7 @@ 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 @@ -483,7 +530,9 @@ export class IosPreviewController { await target.setSurfaceVisible(window.surfaceId, shell.foregroundWindow()?.windowId === window.windowId) } private relayout(): void { - const layout = shell.getWindows().map(window => JSON.stringify(appViewportRect(window.heightMode, window.appId))).join(";") + // Each window's rect, and what its edges touch (which sets its padding). + const layout = shell.getWindows().map(window => + JSON.stringify([appViewportRect(window.heightMode, window.appId), windowEdges(window.appId)])).join(";") if (layout === this.lastLayout) return this.lastLayout = layout for (const window of shell.getWindows()) { @@ -599,7 +648,25 @@ 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 { + 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 { + // 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 @@ -763,10 +830,11 @@ export class IosPreviewController { const display = this.display if (!display) return await display.configureSurface(id, { ...appViewportRect(heightMode, appId), zOrder: 0, transparency: 'opaque' }) - await display.setSurfaceVisible(id, visible) + await display.setSurfaceVisible(id, typeof visible === 'function' ? visible() : visible) }, setSurfaceVisible: (id, visible) => this.setWindowSurfaceVisible(id, visible), removeSurface: id => this.removeWindowSurface(id), + unhandledKey: event => keyboardService.handleUnhandledKey(event as KeyEvent), submitPixels: (id, pixels, width, height, draws) => { void this.submitWorkerPixels(id, pixels, width, height, draws).catch(error => this.fail(error)) }, @@ -788,6 +856,18 @@ export class IosPreviewController { this.state = { ...this.state, phase, status } this.logBluetooth(status) this.emitState() + this.syncKeyboardLink() + } + /** + * Tell the keyboard bridge whether the session can host a keyboard: a G2 on firmware with + * the bridge, connected. On a disconnect the user asked for, the link is still up when the + * phase turns, so the firmware is told to let the keyboard go first. + */ + private syncKeyboardLink(): void { + const up = !!this.communicator && this.state.phase === 'connected' && this.firmwareCompatible + && glassesTypeSetting.get() === 'g2' + if (up) keyboardService.linkReady() + else keyboardService.linkLost(this.state.phase === 'disconnecting') } /** Mirror the session into glasses-presence (read by EvenHub's device status and Timers). */ private syncPresence(): void { @@ -807,6 +887,7 @@ 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 { @@ -814,11 +895,16 @@ 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 }) } - async connect(): Promise { - if (!this.active || this.connecting || this.stopping) return + /** `fromBackground`: the watch asked, and the phone may be in a pocket with the app suspended. */ + async connect(fromBackground = false): Promise { + if ((!this.active && !fromBackground) || 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) { this.onError(error); return } + if (error) { + if (this.active) this.onError(error) + else this.logBluetooth(error) + return + } this.connecting = true this.sessionCreated = true try { @@ -836,7 +922,7 @@ export class IosPreviewController { return } if (this.communicator) await this.closeCommunicator() - const communicator = new FaceclawCommunicatorBridge(identifiers) + const communicator = new FaceclawCommunicatorBridge({ ...identifiers, glassesType: glassesTypeSetting.get() }) this.teardownPreviewDisplay() this.communicator = communicator this.wearDetectionRequested = false @@ -882,6 +968,7 @@ 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 @@ -889,6 +976,7 @@ 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 @@ -899,6 +987,7 @@ export class IosPreviewController { const firmwareWarning = firmwareIncompatibilityMessage(info) ?? '' if (firmwareWarning && firmwareWarning !== this.state.firmwareWarning) this.logBluetooth(`Firmware compatibility warning: ${firmwareWarning}`) this.firmwareCompatible = !firmwareWarning && hasCompatibleFirmware(info) + this.syncKeyboardLink() this.state = { ...this.state, leftVersion: info.leftVersion || this.state.leftVersion, rightVersion: info.rightVersion || this.state.rightVersion, capabilities: info.extension || this.state.capabilities, firmwareWarning } @@ -938,6 +1027,8 @@ export class IosPreviewController { // (or re-pairs / installs the custom firmware, which lift the suppression). if (isHaltedSessionPhase(state.phase)) suppressAutoReconnect() const phase: SessionPhase = state.phase === 'charging' ? 'connected' : isHaltedSessionPhase(state.phase) ? 'error' : state.phase + // The relay ends with the link, so a reconnected session has to ask for it again (syncNotifications). + if (phase !== 'connected' && this.notifications && this.notifications.state !== 'disconnected') this.notifications.stop() // Wear state is a per-transport snapshot: ask again on every new session. if (phase !== 'connected') this.wearDetectionRequested = false this.update(phase, state.status) @@ -988,6 +1079,11 @@ export class IosPreviewController { if (this.state.capabilities) notifications.stop(`Update glasses to Faceclaw firmware ${ANCS_FIRMWARE_VERSION} or newer for iPhone notifications.`) return } + // A G1 reports no revision that says so: its session knows from what the right arm answered. + if (!communicator.ancsRelayAvailable()) { + notifications.stop(`Update the glasses to Faceclaw's firmware ${G1V0_IMAGE.version} for iPhone notifications, then reconnect.`) + return + } if (notifications.state !== 'disconnected') return notifications.start((Date.now() ^ Math.floor(Math.random() * 0xffffffff)) >>> 0, communicator.rightWriteLimit()) } @@ -1061,8 +1157,8 @@ export class IosPreviewController { /** * Continuous capture on behalf of `client` (one id per window: Transcribe, * Translate, Teleprompter, Calculator); it runs while any client wants it, as - * on Android. `recordAs` names a WAV of the audio in Downloads when Save - * Transcribe audio is on. + * on Android. `recordAs` names a recording (.mka) of the audio in Downloads + * when Save Recording is on. */ private startContinuousVoiceCapture(client: string, options: ContinuousCaptureOptions = {}): void { this.continuousClients.set(client, options) @@ -1151,9 +1247,12 @@ export class IosPreviewController { private syncContinuousClaim(): void { voiceActivity.setActive(this.continuousClients.size > 0 && iosVoiceInput.continuousActive, CONTINUOUS_CAPTURE_HOLDER) } - /** Record to the first client's requested name while Save Transcribe audio is on. */ + /** + * Record to the first client's requested name while Save Recording is on (it is + * toggled from those windows' menus, so this also runs when a setting changes). + */ private syncContinuousRecording(): void { - const name = saveTranscribeAudioSetting.get() ? [...this.continuousClients.values()].map(options => options.recordAs).find(Boolean) ?? '' : '' + const name = saveRecordingSetting.get() ? [...this.continuousClients.values()].map(options => options.recordAs).find(Boolean) ?? '' : '' iosVoiceInput.recordTo(name) } /** diff --git a/app/g2/keyboard/bindings.ts b/app/g2/keyboard/bindings.ts new file mode 100644 index 00000000..fc70a4cf --- /dev/null +++ b/app/g2/keyboard/bindings.ts @@ -0,0 +1,266 @@ +/** + * What keys from a hardware keyboard do, apart from typing: the built-in + * defaults, the user's custom keybindings, and how the two combine. + * + * A key becomes one of the gestures the ring and the watch already have, so + * nothing downstream knows about keyboards. Three layers, first match wins: + * + * 1. Custom keybindings (Settings > Keyboard > Keybindings). These apply + * everywhere, including where the focused window takes keys for itself + * (a terminal session), since that is the point of binding a remote's + * few buttons. + * 2. Built-in bindings that also apply there: Escape with Shift, Ctrl or + * Alt goes back, which is the way out of a terminal session. + * 3. Built-in navigation, only for keys no window took: the arrows are the + * watch's four swipes, Enter selects, Escape goes back. + * + * No platform imports: this runs under node in the tests. + */ +import type { KeyEvent } from "./keys"; + +/** A gesture a key can stand for, named as the input pipeline names it. */ +export type KeyGesture = + | "swipe-up" + | "swipe-down" + | "swipe-left" + | "swipe-right" + | "scroll-up" + | "scroll-down" + | "click" + | "double-click" + | "long-press" + | "short-then-long-press"; + +/** + * What a custom keybinding does. "none" turns off the key's built-in + * navigation meaning; it does not stop the key being typed into a window + * that takes keys. + */ +export type KeyAction = KeyGesture | "none"; + +/** The actions, in the order the picker lists them. */ +export const KEY_ACTIONS: readonly { action: KeyAction; label: string }[] = [ + { action: "click", label: "Select" }, + { action: "double-click", label: "Back" }, + { action: "swipe-up", label: "Swipe up" }, + { action: "swipe-down", label: "Swipe down" }, + { action: "swipe-left", label: "Swipe left" }, + { action: "swipe-right", label: "Swipe right" }, + { action: "scroll-up", label: "Scroll up" }, + { action: "scroll-down", label: "Scroll down" }, + { action: "long-press", label: "System menu" }, + { action: "short-then-long-press", label: "App menu" }, + { action: "none", label: "Nothing" }, +]; + +export function keyActionLabel(action: KeyAction): string { + return KEY_ACTIONS.find((entry) => entry.action === action)?.label ?? action; +} + +function isKeyAction(value: unknown): value is KeyAction { + return KEY_ACTIONS.some((entry) => entry.action === value); +} + +/** A physical key with the modifiers held: what a keybinding is keyed on. */ +export type KeyChord = { code: string; shift: boolean; ctrl: boolean; alt: boolean; meta: boolean }; +export type KeyBinding = { chord: KeyChord; action: KeyAction }; + +const MODIFIER_CODES = new Set([ + "ControlLeft", "ControlRight", "ShiftLeft", "ShiftRight", "AltLeft", "AltRight", "MetaLeft", "MetaRight", +]); + +/** Shift, Ctrl, Alt and Meta themselves: they qualify a chord rather than being one. */ +export function isModifierCode(code: string): boolean { + return MODIFIER_CODES.has(code); +} + +export function chordOf(event: KeyEvent): KeyChord { + const { shift, ctrl, alt, meta } = event.modifiers; + return { code: event.code, shift, ctrl, alt, meta }; +} + +/** Canonical text of a chord ("Ctrl+Shift+Escape"): the stored form, and the lookup key. */ +export function chordId(chord: KeyChord): string { + return [chord.ctrl && "Ctrl", chord.alt && "Alt", chord.shift && "Shift", chord.meta && "Meta", chord.code] + .filter(Boolean).join("+"); +} + +/** The inverse of chordId, or null for anything it could not have produced. */ +export function parseChordId(text: string): KeyChord | null { + const parts = text.split("+"); + const code = parts.pop() ?? ""; + if (!/^[A-Za-z][A-Za-z0-9]{0,39}$/.test(code) || isModifierCode(code)) return null; + const chord: KeyChord = { code, shift: false, ctrl: false, alt: false, meta: false }; + for (const part of parts) { + if (part === "Ctrl" && !chord.ctrl) chord.ctrl = true; + else if (part === "Alt" && !chord.alt) chord.alt = true; + else if (part === "Shift" && !chord.shift) chord.shift = true; + else if (part === "Meta" && !chord.meta) chord.meta = true; + else return null; + } + return chord; +} + +const CODE_LABELS: Record = { + ArrowUp: "Up", ArrowDown: "Down", ArrowLeft: "Left", ArrowRight: "Right", + Escape: "Esc", PageUp: "Page Up", PageDown: "Page Down", CapsLock: "Caps Lock", + PrintScreen: "Print Screen", ScrollLock: "Scroll Lock", NumLock: "Num Lock", ContextMenu: "Menu", + Minus: "-", Equal: "=", BracketLeft: "[", BracketRight: "]", Backslash: "\\", IntlBackslash: "\\", + IntlHash: "#", Semicolon: ";", Quote: "'", Backquote: "`", Comma: ",", Period: ".", Slash: "/", + AudioVolumeUp: "Volume Up", AudioVolumeDown: "Volume Down", AudioVolumeMute: "Mute", + MediaPlayPause: "Play/Pause", MediaPlay: "Play", MediaPause: "Pause", MediaStop: "Stop", + MediaTrackNext: "Next Track", MediaTrackPrevious: "Previous Track", + BrightnessUp: "Brightness Up", BrightnessDown: "Brightness Down", + BrowserSearch: "Search", BrowserHome: "Browser Home", BrowserBack: "Browser Back", BrowserForward: "Browser Forward", + LaunchMail: "Mail", LaunchApplication1: "App 1", LaunchApplication2: "App 2", +}; + +/** A key as a person would name it. Unknown keys keep their HID usage number, which is all there is. */ +function codeLabel(code: string): string { + const known = CODE_LABELS[code]; + if (known) return known; + let match = /^Key([A-Z])$/.exec(code); + if (match) return match[1]!; + match = /^Digit([0-9])$/.exec(code); + if (match) return match[1]!; + match = /^Numpad(.+)$/.exec(code); + if (match) return `Numpad ${match[1]}`; + match = /^Usage([0-9a-f]+)$/.exec(code); + if (match) return `Key 0x${match[1]}`; + match = /^Consumer([0-9a-f]+)$/.exec(code); + if (match) return `Media key 0x${match[1]}`; + return code; +} + +/** A chord for display: "Shift+Esc", "Left", "Volume Up". */ +export function describeChord(chord: KeyChord): string { + return [chord.ctrl && "Ctrl", chord.alt && "Alt", chord.shift && "Shift", chord.meta && "Meta", codeLabel(chord.code)] + .filter(Boolean).join("+"); +} + +/** The most custom keybindings kept; far more than a keyboard has uses for. */ +export const MAX_KEY_BINDINGS = 64; + +/** + * Custom keybindings from their stored JSON. Lenient: whatever doesn't make + * sense is dropped, and a later entry for a chord replaces an earlier one. + */ +export function parseKeyBindings(raw: string): KeyBinding[] { + let parsed: unknown; + try { + parsed = raw ? JSON.parse(raw) : []; + } catch { + return []; + } + if (!Array.isArray(parsed)) return []; + const bindings = new Map(); + for (const entry of parsed) { + if (!entry || typeof entry !== "object") continue; + const { key, action } = entry as { key?: unknown; action?: unknown }; + const chord = typeof key === "string" ? parseChordId(key) : null; + if (!chord || !isKeyAction(action)) continue; + bindings.set(chordId(chord), { chord, action }); + if (bindings.size >= MAX_KEY_BINDINGS) break; + } + return [...bindings.values()]; +} + +export function serializeKeyBindings(bindings: readonly KeyBinding[]): string { + return JSON.stringify(bindings.map((binding) => ({ key: chordId(binding.chord), action: binding.action }))); +} + +/** Custom keybindings as the lookup resolveKey takes. */ +export function keyBindingMap(bindings: readonly KeyBinding[]): Map { + return new Map(bindings.map((binding) => [chordId(binding.chord), binding.action])); +} + +/** + * The built-in meaning of a key press, or null when it has none. + * `overridesTyping`: it holds even where the focused window takes keys. + * Built-ins go by the logical key, so both Enter keys select. + */ +export function defaultKeyAction(event: KeyEvent): { action: KeyGesture; overridesTyping: boolean } | null { + const { shift, ctrl, alt, meta } = event.modifiers; + if (meta) return null; + if (event.key === "Escape") { + // Plain Escape belongs to whatever takes keys (it is a keystroke in a + // terminal); with a modifier it always means "back out of here". + return { action: "double-click", overridesTyping: shift || ctrl || alt }; + } + if (ctrl || alt) return null; + switch (event.key) { + case "ArrowUp": + return { action: "swipe-up", overridesTyping: false }; + case "ArrowDown": + return { action: "swipe-down", overridesTyping: false }; + case "ArrowLeft": + return { action: "swipe-left", overridesTyping: false }; + case "ArrowRight": + return { action: "swipe-right", overridesTyping: false }; + case "Enter": + return { action: "click", overridesTyping: false }; + default: + return null; + } +} + +/** The built-ins, for showing to the user. Keep in step with defaultKeyAction. */ +export const DEFAULT_KEYS_HELP = + "Arrow keys: swipe up, down, left and right, as on the watch. Enter: select. Esc: back.\n\n" + + "In a terminal session those keys are typed instead, and Shift+Esc (or Ctrl+Esc, Alt+Esc) goes back.\n\n" + + "A custom keybinding replaces these for its key and works everywhere, terminals included. " + + "\"Nothing\" turns a key's meaning here off without stopping it being typed."; + +/** + * Whether holding the key repeats the gesture. Moving up and down a list + * does. Sideways swipes don't: depending on the layout they enter and leave + * things, and a held key would flap between the two. Selecting, backing out + * and menus act once per press. + */ +export function gestureRepeats(gesture: KeyGesture): boolean { + return gesture === "scroll-up" || gesture === "scroll-down" || gesture === "swipe-up" || gesture === "swipe-down"; +} + +export type KeyResolution = { + /** The key is spoken for: don't offer it to the focused window. */ + consume: boolean; + /** + * The gesture to perform: at once when `consume`, otherwise only if no + * window takes the key. Null for none (including a held key's repeats of + * a gesture that doesn't repeat). + */ + gesture: KeyGesture | null; +}; + +/** What one key press (or auto-repeat) means, given the custom keybindings. */ +export function resolveKey(event: KeyEvent, custom: ReadonlyMap): KeyResolution { + const repeatable = (gesture: KeyGesture): KeyGesture | null => + event.repeat && !gestureRepeats(gesture) ? null : gesture; + const bound = custom.get(chordId(chordOf(event))); + if (bound !== undefined && bound !== "none") return { consume: true, gesture: repeatable(bound) }; + // "none" takes the built-in meaning away and leaves the key to be typed. + if (bound === "none") return { consume: false, gesture: null }; + const builtIn = defaultKeyAction(event); + if (!builtIn) return { consume: false, gesture: null }; + return { consume: builtIn.overridesTyping, gesture: repeatable(builtIn.action) }; +} + +export type GestureOrigin = "ring" | "watch"; + +/** + * Which device a keyboard's gesture is presented as. Swipes are the watch's + * and scrolls the ring's; the two schemes differ in places (an icon grid + * moves by cell for the watch, by row and then cell for the ring). A tap, a + * double tap or a hold exists in both, so it goes with whichever the + * keyboard last moved with: arrow keys make the keyboard a watch, a remote + * bound to scroll makes it a ring. Before any movement, the watch. + */ +export class GestureScheme { + private scheme: GestureOrigin = "watch"; + + originFor(gesture: KeyGesture): GestureOrigin { + if (gesture.startsWith("swipe-")) this.scheme = "watch"; + else if (gesture.startsWith("scroll-")) this.scheme = "ring"; + return this.scheme; + } +} diff --git a/app/g2/keyboard/bridge.ts b/app/g2/keyboard/bridge.ts new file mode 100644 index 00000000..5dcfa78d --- /dev/null +++ b/app/g2/keyboard/bridge.ts @@ -0,0 +1,559 @@ +/** + * The phone side of the CFW keyboard bridge for one glasses session: the + * client, the remembered keyboard, reconnecting it, and what the UI shows. + * The session hands it field-131 records and a way to send controls; the + * rest stays in here. Modelled on the Glassly app's G2KeyboardBridge (MIT). + * + * The firmware keeps nothing across a reboot (it comes back with the bridge + * off), and holds the keyboard's connection only while told to. So the + * remembered keyboard is brought back whenever the glasses link comes up and + * whenever the keyboard drops, backing off while it stays away. The + * discovered handle mapping is good for one connection and is never stored. + * No platform imports: this runs under node in the tests. + */ +import { KeyboardClient, KeyboardClientError, type KeyboardStatus } from "./client"; +import type { HidKeyEvent } from "./hid"; +import { + KeyboardDm, + KeyboardError, + mergeKeyboardAdverts, + parseKeyboardAddress, + type KeyboardAdvert, +} from "./protocol"; + +export type SavedKeyboard = { address: string; addressType: number; name: string }; + +export type KeyboardBridgeState = + /** No glasses link that can host a keyboard. */ + | "unavailable" + | "idle" + | "scanning" + | "connecting" + | "pairing" + | "configuring" + | "connected" + | "error"; + +/** A pairing step waiting on the user. */ +export type KeyboardPairingPrompt = + /** Type this on the keyboard, then Enter. */ + | { kind: "display"; pin: number } + /** Confirm both sides show this value (answerCompare). */ + | { kind: "compare"; value: number } + /** The keyboard shows a code to enter here (answerPasskey). */ + | { kind: "entry" }; + +export type KeyboardBridgeSnapshot = { + state: KeyboardBridgeState; + saved: SavedKeyboard | null; + /** Name of the keyboard being connected or in use. */ + activeName: string; + error: string; + pairing: KeyboardPairingPrompt | null; + /** Advertisers from the last scan, HID devices first, strongest first. */ + scanResults: KeyboardAdvert[]; + /** A user-started scan or connect is running. */ + busy: boolean; + /** The remembered keyboard is away and the bridge keeps trying to bring it back. */ + waiting: boolean; +}; + +export type KeyboardBridgeHost = { + /** Queue a control record on the live session; false when there is none. */ + send(record: Uint8Array): boolean; + loadSaved(): SavedKeyboard | null; + storeSaved(saved: SavedKeyboard | null): void; + /** Key transitions from the keyboard (including forced releases). */ + onKeys(events: HidKeyEvent[]): void; + /** The keyboard stopped being usable; drop held-key state without releases. */ + onKeyboardGone(): void; + /** Something in snapshot() changed. */ + onChanged(): void; + /** + * A line for the log. `routine` marks the ones that repeat for as long as + * a remembered keyboard stays away, which only a verbose log wants. + */ + log(line: string, routine?: boolean): void; + /** A fresh six-digit pairing passkey from a good random source. */ + randomPasskey?(): number; + /** + * Whether looking for an absent keyboard is worthwhile now. Each attempt + * has the glasses' radio listening for the keyboard for up to half a + * minute, so the owner limits it to when the glasses are in use, and calls + * retryNow() when that starts. Default: always. + */ + shouldReconnect?(): boolean; +}; + +/** Delay before each automatic attempt after a failure; the last one repeats. */ +const RECONNECT_BACKOFF_MS = [2_000, 5_000, 10_000, 20_000, 30_000]; +/** After the glasses link comes up, before the first attempt. */ +const RESUME_DELAY_MS = 1_000; +/** After the keyboard drops (it may just be going to sleep). */ +const DROP_RETRY_DELAY_MS = 2_000; +const RELEASE_POLLS = 20; +const RELEASE_POLL_MS = 150; + +export class KeyboardBridge { + private client: KeyboardClient | null = null; + private available = false; + private state: KeyboardBridgeState = "unavailable"; + private saved: SavedKeyboard | null; + private activeName = ""; + private error = ""; + private pairing: KeyboardPairingPrompt | null = null; + private scanResults: KeyboardAdvert[] = []; + /** A user-started scan/connect holds the bridge. */ + private busy = false; + /** The keyboard is connected, encrypted and subscribed. */ + private ready = false; + private userDisconnected = false; + /** The keyboard was let go while the glasses were out of reach; tell the firmware when they are back. */ + private releaseOnLink = false; + private reconnectTimer: ReturnType | null = null; + private reconnectAttempt = 0; + /** Bumped whenever the client is replaced; work started for an older one stops quietly. */ + private generation = 0; + + constructor(private readonly host: KeyboardBridgeHost) { + this.saved = host.loadSaved(); + } + + snapshot(): KeyboardBridgeSnapshot { + return { + state: this.state, + saved: this.saved, + activeName: this.activeName, + error: this.error, + pairing: this.pairing, + scanResults: sortAdverts(this.scanResults), + busy: this.busy, + waiting: this.available && !!this.saved && !this.ready && !this.userDisconnected && !this.busy, + }; + } + + /** True while key events can arrive. */ + isConnected(): boolean { + return this.ready; + } + + // ---------- Link lifecycle (driven by the session owner) ---------- + + /** The glasses link is up on firmware with the bridge: bring the remembered keyboard back. */ + linkReady(): void { + if (this.available) return; + this.available = true; + this.userDisconnected = false; + this.reconnectAttempt = 0; + this.error = ""; + const client = this.replaceClient(); + this.setState("idle"); + if (this.saved && !this.releaseOnLink) { + this.scheduleReconnect(RESUME_DELAY_MS); + } else if (this.releaseOnLink && client) { + this.userDisconnected = !!this.saved; + client.query().then((status) => { + if (status.enabled || status.conn) return client.disable(); + }).catch(() => {}); + } + this.releaseOnLink = false; + } + + /** The glasses link is gone. Only the remembered keyboard survives. */ + linkLost(): void { + if (!this.available && !this.client) return; + this.available = false; + this.cancelReconnect(); + this.generation++; + this.client?.close(); + this.client = null; + this.busy = false; + this.pairing = null; + this.error = ""; + this.dropKeyboard(); + this.setState("unavailable"); + } + + /** + * The app is about to close the glasses link on purpose: tell the firmware + * to let the keyboard go, so it isn't left attached to glasses nobody is + * listening to. Best effort; nothing waits for the answer. + */ + linkClosing(): void { + const client = this.client; + if (!client || !this.available || !client.status.enabled) return; + client.disable().catch(() => {}); + } + + /** One field-131 payload from the session. */ + accept(payload: Uint8Array): void { + this.client?.accept(payload); + } + + /** + * The keyboard may be reachable now, or is wanted now (the display woke): + * if it is away and the bridge is waiting out a backoff, try at once. + */ + retryNow(): void { + if (!this.available || !this.saved || this.ready || this.userDisconnected || this.busy) return; + // No timer means an attempt is already in flight. + if (this.reconnectTimer === null) return; + this.reconnectAttempt = 0; + this.scheduleReconnect(0); + } + + // ---------- Commands (the settings UI) ---------- + + /** Scan for about five seconds; results accumulate in the snapshot as they arrive. */ + async scan(): Promise { + const client = this.beginUserOperation(); + const generation = this.generation; + this.scanResults = []; + this.error = ""; + this.setState("scanning"); + try { + await this.releaseLink(client); + await client.enable(); + await client.scan(); + if (generation === this.generation) this.setState("idle"); + } catch (e) { + if (generation === this.generation) this.fail(e); + throw friendly(e); + } finally { + if (generation === this.generation) this.endUserOperation(); + } + return sortAdverts(this.scanResults); + } + + /** Connect, pair and subscribe a keyboard, then remember it. */ + async connect(keyboard: SavedKeyboard): Promise { + if (!parseKeyboardAddress(keyboard.address) || keyboard.addressType < 0 || keyboard.addressType > 3) { + throw new KeyboardClientError("Invalid keyboard address"); + } + const client = this.beginUserOperation(); + const generation = this.generation; + this.userDisconnected = false; + try { + await this.connectWith(client, generation, keyboard, false); + } finally { + if (generation === this.generation) this.endUserOperation(); + } + } + + /** Try the remembered keyboard again now. */ + async reconnect(): Promise { + if (!this.saved) throw new KeyboardClientError("No remembered keyboard"); + await this.connect(this.saved); + } + + /** Drop the keyboard but keep it remembered. No automatic reconnect until the next explicit connect or glasses session. */ + async disconnect(): Promise { + this.userDisconnected = true; + this.cancelReconnect(); + const client = this.replaceClient(); + // A scan or connect this interrupts no longer owns the bridge. + this.busy = false; + this.dropKeyboard(); + this.pairing = null; + this.error = ""; + if (!client) { + this.releaseOnLink = true; + this.setState("unavailable"); + return; + } + this.setState("idle"); + try { + await client.query(); + await client.disable(); + } catch (e) { + this.host.log(`keyboard disconnect: ${messageOf(e)}`); + } + } + + /** Forget the remembered keyboard. The glasses keep their bond with it. */ + async forget(): Promise { + this.saved = null; + this.host.storeSaved(null); + await this.disconnect(); + this.scanResults = []; + this.activeName = ""; + this.host.onChanged(); + } + + /** Answer a "compare" pairing prompt. */ + async answerCompare(accept: boolean): Promise { + if (!this.client || this.pairing?.kind !== "compare") throw new KeyboardClientError("No pairing comparison is pending"); + this.pairing = null; + this.host.onChanged(); + await this.client.confirm(accept); + } + + /** Answer an "entry" pairing prompt with the code the keyboard shows. */ + async answerPasskey(pin: number): Promise { + if (!this.client || this.pairing?.kind !== "entry") throw new KeyboardClientError("No pairing code is pending"); + this.pairing = null; + this.host.onChanged(); + await this.client.authenticate(pin); + } + + // ---------- Internals ---------- + + private beginUserOperation(): KeyboardClient { + if (!this.available) throw new KeyboardClientError("Connect to G2 glasses running Faceclaw firmware first"); + if (this.busy) throw new KeyboardClientError("Another keyboard operation is in progress"); + // An automatic attempt may be mid-flight (a sleeping keyboard holds one + // for up to 30 s): a fresh client fails it at once and takes over. + this.cancelReconnect(); + const client = this.replaceClient()!; + this.dropKeyboard(); + this.pairing = null; + this.busy = true; + return client; + } + + private endUserOperation(): void { + this.busy = false; + this.host.onChanged(); + } + + /** Close the current client and, while the link is up, start a fresh one. */ + private replaceClient(): KeyboardClient | null { + this.generation++; + this.client?.close(); + this.client = null; + if (!this.available) return null; + const generation = this.generation; + const live = () => generation === this.generation; + const client = new KeyboardClient( + (record) => live() && this.host.send(record), + { + keys: (events) => { if (live() && this.ready) this.host.onKeys(events); }, + advert: (advert) => { if (live()) this.addAdvert(advert); }, + status: (status) => { if (live()) this.onStatus(status); }, + dm: (event, status) => { if (live()) this.onDm(event, status); }, + passkeyDisplay: (pin) => { if (live()) this.prompt({ kind: "display", pin }); }, + passkeyRequest: () => { if (live()) this.prompt({ kind: "entry" }); }, + compareRequest: (value) => { if (live()) this.prompt({ kind: "compare", value }); }, + servicesChanged: () => { if (live()) this.onServicesChanged(); }, + error: (message) => { if (live()) this.host.log(`keyboard: ${message}`); }, + log: (line) => { if (live()) this.host.log(`keyboard setup: ${line}`); }, + }, + { randomPasskey: this.host.randomPasskey ? () => this.host.randomPasskey!() : undefined }, + ); + this.client = client; + return client; + } + + private async connectWith( + client: KeyboardClient, + generation: number, + keyboard: SavedKeyboard, + resume: boolean, + ): Promise { + const live = () => generation === this.generation; + this.error = ""; + this.activeName = keyboard.name; + this.setState("connecting"); + try { + const status = await client.query(); + if (resume && status.enabled && status.connected && status.encrypted) { + // The glasses kept the keyboard through a phone-side drop (or an app + // restart): only the handle mapping is missing. + this.host.log("keyboard still connected to the glasses; rediscovering"); + } else { + await this.releaseLink(client); + await client.enable(); + await client.connect(keyboard.addressType, parseKeyboardAddress(keyboard.address)!); + } + if (!live()) return; + this.pairing = null; + this.setState("configuring"); + const config = await client.configure(); + if (!live()) return; + this.ready = true; + this.reconnectAttempt = 0; + // The list was for choosing; it is stale from here on. + this.scanResults = []; + if (!sameKeyboard(this.saved, keyboard)) { + this.saved = { ...keyboard }; + this.host.storeSaved(this.saved); + } + this.host.log( + `keyboard ready: ${keyboard.name || keyboard.address}, ${config.watched.length} of ` + + `${config.reports.filter((r) => r.type === 1).length} input reports subscribed, epoch ${config.epoch}`); + this.setState("connected"); + } catch (e) { + if (!live()) return; + this.ready = false; + this.pairing = null; + if (resume) { + // An automatic attempt: a keyboard that is asleep or out of range is + // the ordinary case, not an error to put in front of the user. + this.host.log(`keyboard reconnect: ${messageOf(friendly(e))}`, true); + this.setState("idle"); + } else { + this.fail(e); + } + throw friendly(e); + } + } + + /** + * The firmware refuses SCAN and CONNECT while it still owns a keyboard + * slot, and an interrupted connect keeps initiating until the close lands. + * DISABLE is epoch-checked and a fresh client hasn't seen the epoch yet, + * so QUERY first (it isn't, and its answer carries the epoch), then wait + * for the slot to clear. + */ + private async releaseLink(client: KeyboardClient): Promise { + const status = await client.query(); + if (!status.enabled && status.conn === 0) return; + await client.disable(); + for (let i = 0; i < RELEASE_POLLS; i++) { + if ((await client.query()).conn === 0) return; + await delay(RELEASE_POLL_MS); + } + throw new KeyboardClientError("The glasses are still closing the previous keyboard link; try again in a moment"); + } + + private cancelReconnect(): void { + if (this.reconnectTimer !== null) clearTimeout(this.reconnectTimer); + this.reconnectTimer = null; + } + + private scheduleReconnect(delayMs: number): void { + this.cancelReconnect(); + this.reconnectTimer = setTimeout(() => { + this.reconnectTimer = null; + void this.attemptReconnect(); + }, delayMs); + } + + private async attemptReconnect(): Promise { + const saved = this.saved; + const client = this.client; + if (!this.available || !client || !saved || this.userDisconnected || this.ready || this.busy) return; + if (this.host.shouldReconnect && !this.host.shouldReconnect()) { + this.parkFirmware(client); + this.scheduleReconnect(RECONNECT_BACKOFF_MS[RECONNECT_BACKOFF_MS.length - 1]!); + return; + } + const generation = this.generation; + try { + await this.connectWith(client, generation, saved, true); + } catch { + if (generation !== this.generation || !this.available || this.userDisconnected) return; + // Keyboards sleep, and the ring's own scan can hold the controller + // (BUSY): keep trying, less often, while the glasses stay up. + const backoff = RECONNECT_BACKOFF_MS[Math.min(this.reconnectAttempt, RECONNECT_BACKOFF_MS.length - 1)]!; + this.reconnectAttempt++; + this.scheduleReconnect(backoff); + } + } + + /** + * While it is enabled the firmware bridge runs a 20 ms timer and reports + * its status every second, keyboard or no keyboard. When nothing will be + * tried for a while, switch it off; the next attempt enables it again. + */ + private parkFirmware(client: KeyboardClient): void { + if (!client.status.enabled) return; + client.disable().catch(() => {}); + } + + private onStatus(status: KeyboardStatus): void { + if (this.ready && (!status.connected || !status.encrypted)) this.keyboardDropped("status"); + else if (this.state === "connecting" && status.connected && !status.encrypted) this.setState("pairing"); + } + + private onDm(event: number, status: number): void { + if (event === KeyboardDm.connClose || event === KeyboardDm.pairFailed || event === KeyboardDm.encryptFailed) { + this.host.log(`keyboard DM event 0x${event.toString(16)} status ${status}`); + if (this.ready) this.keyboardDropped("dm"); + } + } + + private onServicesChanged(): void { + this.host.log("keyboard services changed; rediscovering"); + this.dropKeyboard(); + this.setState("idle"); + if (this.saved && !this.userDisconnected && !this.busy) this.scheduleReconnect(0); + } + + private keyboardDropped(reason: string): void { + this.host.log(`keyboard disconnected (${reason})`); + this.dropKeyboard(); + this.setState("idle"); + if (this.saved && !this.userDisconnected && !this.busy) this.scheduleReconnect(DROP_RETRY_DELAY_MS); + } + + /** The keyboard is no longer usable: tell the host once. */ + private dropKeyboard(): void { + if (!this.ready) return; + this.ready = false; + this.host.onKeyboardGone(); + } + + private addAdvert(advert: KeyboardAdvert): void { + const index = this.scanResults.findIndex( + (a) => a.address === advert.address && a.addressType === advert.addressType); + if (index < 0) { + this.scanResults.push(advert); + } else { + const merged = mergeKeyboardAdverts(this.scanResults[index]!, advert); + const old = this.scanResults[index]!; + if (merged.name === old.name && merged.hid === old.hid && merged.rssi === old.rssi) return; + this.scanResults[index] = merged; + } + this.host.onChanged(); + } + + private prompt(pairing: KeyboardPairingPrompt): void { + this.pairing = pairing; + this.setState("pairing"); + } + + private setState(next: KeyboardBridgeState): void { + this.state = next; + if (next !== "pairing" && next !== "connecting") this.pairing = null; + this.host.onChanged(); + } + + private fail(error: unknown): void { + this.error = messageOf(friendly(error)); + this.host.log(`keyboard error: ${this.error}`); + this.setState("error"); + } +} + +function sameKeyboard(a: SavedKeyboard | null, b: SavedKeyboard): boolean { + return !!a && a.address === b.address && a.addressType === b.addressType && a.name === b.name; +} + +function sortAdverts(adverts: readonly KeyboardAdvert[]): KeyboardAdvert[] { + return [...adverts].sort((a, b) => Number(b.hid) - Number(a.hid) || b.rssi - a.rssi); +} + +/** + * Firmware BUSY nearly always means the ring's own scan or reconnect holds + * the radio; say that rather than the raw control error. + */ +function friendly(error: unknown): Error { + if (error instanceof KeyboardClientError && error.code === KeyboardError.busy) { + return new KeyboardClientError( + "The glasses' radio is busy (usually the ring reconnecting). Wait a few seconds and try again.", error.code); + } + if (error instanceof KeyboardClientError && error.code === KeyboardError.noSpace) { + return new KeyboardClientError( + "The glasses have no room for another connection or pairing.", error.code); + } + return error instanceof Error ? error : new Error(String(error)); +} + +function messageOf(error: unknown): string { + return error instanceof Error ? error.message : String(error); +} + +function delay(ms: number): Promise { + return new Promise((resolve) => setTimeout(resolve, ms)); +} diff --git a/app/g2/keyboard/client.ts b/app/g2/keyboard/client.ts new file mode 100644 index 00000000..474a8058 --- /dev/null +++ b/app/g2/keyboard/client.ts @@ -0,0 +1,709 @@ +/** + * Transport-independent client for the CFW keyboard bridge: enable, scan, + * connect and pair a keyboard through the glasses, discover its HID service + * over the relayed ATT operations, subscribe its input reports, and decode + * them into key transitions. From the reference client in g2flash demos/ + * (keyboard-client.ts), with the fixes its use in the Glassly app turned up. + * + * The firmware keeps almost no policy: it owns the connection and the bond, + * and forwards one ATT request at a time. Everything HID lives here. Handle + * numbers found by configure() are only good for one connection epoch. + * No platform imports: this runs under node in the tests. + */ +import { HidKeys, parseReportMap, reportHasKeys, type HidKeyEvent, type HidReport } from "./hid"; +import { + KeyboardDm, + KeyboardError, + KeyboardKind, + KeyboardOp, + KeyboardRecords, + keyboardControl, + keyboardErrorName, + le16, + parseKeyboardAdvert, + u16, + u32, + type KeyboardAdvert, + type KeyboardRecord, +} from "./protocol"; + +/** Queue one field-130 control record; false when the glasses link can't take it now. */ +export type KeyboardTransport = (record: Uint8Array) => boolean; + +export type KeyboardStatus = { + enabled: boolean; + /** The firmware's connection id for the keyboard, 0 when it owns none. */ + conn: number; + connected: boolean; + encrypted: boolean; + scanning: boolean; +}; + +export type KeyboardClientEvents = { + /** Key transitions from one input report (or the releases a gap forces). */ + keys?(events: HidKeyEvent[]): void; + advert?(advert: KeyboardAdvert): void; + status?(status: KeyboardStatus): void; + /** The stream may have lost records; held keys were released. */ + gap?(): void; + /** Device-manager event from the glasses' BLE host (KeyboardDm). */ + dm?(event: number, status: number): void; + /** The keyboard shows a six-digit passkey; answer with authenticate(). */ + passkeyRequest?(): void; + /** We chose a passkey and answered with it; the user types it on the keyboard, then Enter. */ + passkeyDisplay?(pin: number): void; + /** Numeric comparison: answer with confirm() once the user has compared. */ + compareRequest?(value: number): void; + /** The keyboard's GATT table changed; the mapping is void until configure() runs again. */ + servicesChanged?(): void; + error?(message: string): void; + /** Setup diagnostics: the keyboard's attribute table and what was made of it. Never key contents. */ + log?(line: string): void; +}; + +export type KeyboardReport = { + /** Handle of the HID service declaration the report belongs to. */ + service: number; + handle: number; + id: number; + /** 1 input, 2 output, 3 feature. */ + type: number; + ccc?: number; + /** From the characteristic's declaration; undefined when the keyboard wouldn't say (see declaredProperties). */ + properties?: number; + map: Uint8Array; +}; + +export type KeyboardConfiguration = { + epoch: number; + /** Every report found, input or not. */ + reports: KeyboardReport[]; + /** Handles of the input reports subscribed for keys. */ + watched: number[]; + serviceChanged?: number; +}; + +export type KeyboardClientOptions = { + /** A fresh six-digit passkey for display pairing. Default: Math.random (pass a stronger source). */ + randomPasskey?: () => number; +}; + +export class KeyboardClientError extends Error { + /** The firmware's control error code (KeyboardError), when that is what failed. */ + readonly code: number | undefined; + /** The keyboard's ATT error code, when it refused a read or write. */ + readonly attStatus: number | undefined; + constructor(message: string, code?: number, attStatus?: number) { + super(message); + this.name = "KeyboardClientError"; + this.code = code; + this.attStatus = attStatus; + } +} + +type Attribute = { handle: number; uuid: number | string }; +type Pending = { + op: number; + resolve: (r: KeyboardRecord) => void; + reject: (e: Error) => void; + timer: ReturnType; +}; +type Waiter = { test: () => boolean; resolve: () => void; reject: (e: Error) => void; timer: ReturnType }; +type Input = { report: HidReport; id: number; service: number }; + +const COMMAND_TIMEOUT_MS = 32_000; +const MAX_PENDING = 8; +const MAX_ATTRIBUTES = 512; +const MAX_VALUE = 512; +const MAX_WATCHES = 16; + +const UUID_PRIMARY_SERVICE = 0x2800; +const UUID_SECONDARY_SERVICE = 0x2801; +const UUID_CHARACTERISTIC = 0x2803; +const UUID_CCC = 0x2902; +const UUID_EXTERNAL_REPORT_REFERENCE = 0x2907; +const UUID_REPORT_REFERENCE = 0x2908; +const UUID_HID_SERVICE = 0x1812; +const UUID_SERVICE_CHANGED = 0x2a05; +const UUID_REPORT_MAP = 0x2a4b; +const UUID_REPORT = 0x2a4d; +const UUID_PROTOCOL_MODE = 0x2a4e; + +/** ATT error codes that end a paged read rather than failing it. */ +const ATT_INVALID_OFFSET = 7; +const ATT_NOT_LONG = 11; +const ATT_NOT_FOUND = 10; + +/** + * ATT UUIDs are little endian. A 128-bit UUID on the Bluetooth base collapses + * to its 16-bit form; vendor UUIDs stay as hex strings. + */ +export function attributeUuid(bytes: Uint8Array): number | string { + if (bytes.length === 2) return u16(bytes); + if (bytes.length !== 16) throw new KeyboardClientError("Invalid ATT UUID length"); + const base = [0xfb, 0x34, 0x9b, 0x5f, 0x80, 0, 0, 0x80, 0, 0x10, 0, 0]; + if (base.every((v, i) => bytes[i] === v) && bytes[14] === 0 && bytes[15] === 0) return u16(bytes, 12); + return Array.from(bytes, (x) => x.toString(16).padStart(2, "0")).join(""); +} + +export class KeyboardClient { + /** The firmware's connection generation; every control but QUERY/ENABLE must carry the live one. */ + epoch = 0; + status: KeyboardStatus = { enabled: false, conn: 0, connected: false, encrypted: false, scanning: false }; + configuration: KeyboardConfiguration | undefined; + + private serial = 0; + private closed = false; + /** The link under connect() went away (close, failed open, failed pairing). */ + private linkLost = false; + private readonly pending = new Map(); + private readonly waiters = new Set(); + private readonly keys = new HidKeys(); + private inputs = new Map(); + private readonly records = new KeyboardRecords(() => this.gap()); + private readonly randomPasskey: () => number; + + constructor( + private readonly transport: KeyboardTransport, + private readonly events: KeyboardClientEvents = {}, + options: KeyboardClientOptions = {}, + ) { + this.randomPasskey = options.randomPasskey ?? (() => Math.floor(Math.random() * 1_000_000)); + } + + // ---------- Inbound ---------- + + /** Feed one field-131 payload, in arrival order. */ + accept(data: Uint8Array): void { + if (this.closed) return; + const r = this.records.push(data); + if (!r) return; + this.epoch = r.epoch; + if (r.kind === KeyboardKind.status && r.data.length === 10) { + this.status = { + enabled: !!r.data[0], conn: r.data[1]!, connected: !!r.data[2], encrypted: !!r.data[3], scanning: !!r.data[4], + }; + if (!this.status.enabled || !this.status.connected || !this.status.encrypted) this.release(); + this.events.status?.(this.status); + } + const pending = this.pending.get(r.request); + if (pending && (r.kind === KeyboardKind.status || r.kind === KeyboardKind.att)) { + this.pending.delete(r.request); + clearTimeout(pending.timer); + if (r.kind === KeyboardKind.status && r.code) { + pending.reject(new KeyboardClientError( + `Keyboard command ${opName(pending.op)}: firmware ${keyboardErrorName(r.code)}`, r.code)); + } else { + pending.resolve(r); + } + } + if (r.kind === KeyboardKind.dm) this.acceptDm(r); + else if (r.kind === KeyboardKind.input) this.acceptInput(r); + else if (r.kind === KeyboardKind.advert) { + const advert = parseKeyboardAdvert(r.data); + if (advert) this.events.advert?.(advert); + } + this.checkWaiters(); + } + + private acceptDm(r: KeyboardRecord): void { + const event = r.code & 255; + const status = r.code >>> 8; + if (event === KeyboardDm.connClose || event === KeyboardDm.pairFailed || event === KeyboardDm.encryptFailed || + (event === KeyboardDm.connOpen && status !== 0)) { + this.linkLost = true; + this.gap(); + this.inputs.clear(); + this.configuration = undefined; + } + if (event === KeyboardDm.authRequest && r.data.length === 2) { + if (r.data[0]) { + this.command(KeyboardOp.disconnect).catch(() => {}); + this.events.error?.("This keyboard only pairs out of band, which isn't supported."); + } else if (r.data[1]) { + // KeyboardDisplay on our side: choose the passkey, show it, and + // answer at once; the user types it on the keyboard. + const pin = Math.min(999_999, Math.max(0, Math.floor(this.randomPasskey()))); + this.events.passkeyDisplay?.(pin); + this.authenticate(pin).catch((e) => this.events.error?.(messageOf(e))); + } else { + this.events.passkeyRequest?.(); + } + } + if (event === KeyboardDm.compare && r.data.length === 4) this.events.compareRequest?.(u32(r.data)); + this.events.dm?.(event, status); + } + + private acceptInput(r: KeyboardRecord): void { + const changed = this.configuration?.serviceChanged; + if (changed !== undefined && r.handle === changed) { + this.gap(); + this.inputs.clear(); + this.configuration = undefined; + this.events.servicesChanged?.(); + return; + } + const input = this.inputs.get(r.handle); + if (!input || this.configuration?.epoch !== r.epoch) { + this.gap(); + return; + } + try { + const events = this.keys.update(r.handle, input.report, r.data); + if (events.length) this.events.keys?.(events); + } catch (e) { + this.release(); + this.events.error?.(messageOf(e)); + } + } + + private release(): void { + const events = this.keys.reset(); + if (events.length) this.events.keys?.(events); + } + + private gap(): void { + this.release(); + this.events.gap?.(); + for (const [id, p] of this.pending) { + if (p.op < KeyboardOp.find) continue; + clearTimeout(p.timer); + this.pending.delete(id); + p.reject(new KeyboardClientError("Keyboard stream gap during ATT transaction")); + } + } + + /** The phone's link to the glasses dropped: release held keys and fail everything in flight. */ + lostPhoneLink(): void { + this.records.reset(); + this.cancel("Glasses link lost"); + } + + /** Stop for good; later accept() calls are ignored. */ + close(): void { + if (this.closed) return; + this.lostPhoneLink(); + this.closed = true; + } + + private cancel(reason: string): void { + for (const p of this.pending.values()) { + clearTimeout(p.timer); + p.reject(new KeyboardClientError(reason)); + } + this.pending.clear(); + for (const w of this.waiters) { + clearTimeout(w.timer); + w.reject(new KeyboardClientError(reason)); + } + this.waiters.clear(); + } + + private checkWaiters(): void { + for (const w of [...this.waiters]) { + let done = false; + try { + done = w.test(); + } catch (e) { + this.waiters.delete(w); + clearTimeout(w.timer); + w.reject(e instanceof Error ? e : new KeyboardClientError(String(e))); + continue; + } + if (!done) continue; + this.waiters.delete(w); + clearTimeout(w.timer); + w.resolve(); + } + } + + /** Resolve once `test` holds; it is re-evaluated after every accepted record. */ + private waitFor(test: () => boolean, timeoutMs: number, what: string): Promise { + if (this.closed) return Promise.reject(new KeyboardClientError("Keyboard client closed")); + if (test()) return Promise.resolve(); + return new Promise((resolve, reject) => { + const waiter: Waiter = { + test, resolve, reject, + timer: setTimeout(() => { + this.waiters.delete(waiter); + reject(new KeyboardClientError(`Timed out waiting for ${what}`)); + }, timeoutMs), + }; + this.waiters.add(waiter); + }); + } + + // ---------- Commands ---------- + + /** Send one control and await the STATUS or ATT record that answers it. */ + command(op: number, body: readonly number[] = []): Promise { + if (this.closed) return Promise.reject(new KeyboardClientError("Keyboard client closed")); + if (this.pending.size >= MAX_PENDING) return Promise.reject(new KeyboardClientError("Too many keyboard commands")); + const request = this.serial = this.serial % 65535 + 1; + return new Promise((resolve, reject) => { + const timer = setTimeout(() => { + this.pending.delete(request); + reject(new KeyboardClientError(`Keyboard command ${opName(op)} timed out`)); + }, COMMAND_TIMEOUT_MS); + this.pending.set(request, { op, resolve, reject, timer }); + let queued = false; + try { + queued = this.transport(keyboardControl(op, request, this.epoch, body)); + } catch { + queued = false; + } + if (!queued) { + clearTimeout(timer); + this.pending.delete(request); + reject(new KeyboardClientError("The glasses aren't ready for keyboard commands")); + } + }); + } + + async enable(): Promise { + await this.command(KeyboardOp.enable); + } + + /** Disconnect the keyboard and stop the bridge; the bond stays. */ + async disable(): Promise { + await this.command(KeyboardOp.disable); + this.release(); + } + + /** Ask for the firmware's state. Also the way to learn the live epoch: QUERY isn't epoch-checked. */ + async query(): Promise { + await this.command(KeyboardOp.query); + return this.status; + } + + /** + * Active scan for about five seconds; adverts arrive through events.advert. + * The firmware only clears `scanning` once the stock scanner is idle again, + * and a ring looking for its lens can hold that well past the window, so a + * lingering flag is not an error: the adverts already delivered stand. + */ + async scan(): Promise { + await this.command(KeyboardOp.scan); + try { + await this.waitFor(() => !this.status.scanning, 8000, "the scan to finish"); + } catch (e) { + if (this.closed) throw e; + } + } + + /** Connect, then pair unless the link comes up encrypted. `address` is LSB first. */ + async connect(addressType: number, address: Uint8Array): Promise { + if (address.length !== 6 || !Number.isInteger(addressType) || addressType < 0 || addressType > 3) { + throw new KeyboardClientError("Invalid BLE address"); + } + this.release(); + this.inputs.clear(); + this.configuration = undefined; + this.linkLost = false; + await this.command(KeyboardOp.connect, [addressType, ...address]); + await this.waitFor(() => this.status.connected || this.linkLost, 32_000, "the keyboard to connect"); + if (!this.status.connected) throw new KeyboardClientError("The keyboard didn't answer"); + if (!this.status.encrypted) { + // The keyboard's own security request may have started pairing already. + // BUSY is not success: the encrypted status below still decides. + try { + await this.command(KeyboardOp.pair); + } catch (e) { + if (!(e instanceof KeyboardClientError) || e.code !== KeyboardError.busy) throw e; + } + await this.waitFor(() => this.status.encrypted || this.linkLost, 65_000, "pairing to finish"); + if (!this.status.encrypted) throw new KeyboardClientError("Pairing with the keyboard failed"); + } + } + + async disconnect(): Promise { + await this.command(KeyboardOp.disconnect); + this.release(); + } + + /** Answer a pending passkey prompt. */ + async authenticate(pin: number): Promise { + if (!Number.isInteger(pin) || pin < 0 || pin > 999_999) throw new KeyboardClientError("Invalid pairing passkey"); + await this.command(KeyboardOp.auth, [pin & 255, (pin >>> 8) & 255, pin >>> 16]); + } + + /** Answer a pending numeric comparison. */ + async confirm(accept: boolean): Promise { + await this.command(KeyboardOp.compare, [accept ? 1 : 0]); + } + + private async att(op: number, body: readonly number[]): Promise { + const r = await this.command(op, body); + if (r.kind !== KeyboardKind.att) throw new KeyboardClientError("Expected keyboard ATT response"); + return r; + } + + /** Read a whole attribute: Read, then Read Blob until a short or empty reply. Never assumes the MTU. */ + async read(handle: number): Promise { + const parts: number[] = []; + for (;;) { + const r = await this.att(KeyboardOp.read, [...le16(handle), ...le16(parts.length)]); + const status = r.code >>> 8; + if (parts.length && (status === ATT_INVALID_OFFSET || status === ATT_NOT_LONG)) break; + if (status) throw new KeyboardClientError(`ATT read ${handle}: ${status}`, undefined, status); + if (!r.data.length) break; + for (const b of r.data) parts.push(b); + if (parts.length > MAX_VALUE) throw new KeyboardClientError("Attribute exceeds 512 bytes"); + if (parts.length === MAX_VALUE) break; + } + return Uint8Array.from(parts); + } + + /** Read a short attribute once (a Report Reference, a declaration, a service UUID). */ + private async shortRead(handle: number): Promise { + const r = await this.att(KeyboardOp.read, [...le16(handle), 0, 0]); + if (r.code >>> 8) throw new KeyboardClientError(`ATT read ${handle}: ${r.code >>> 8}`, undefined, r.code >>> 8); + return r.data; + } + + /** Write 1..18 bytes (an output report such as the LEDs, a CCC, the protocol mode). */ + async write(handle: number, value: Uint8Array, withoutResponse = false): Promise { + if (!value.length || value.length > 18) throw new KeyboardClientError("Keyboard write supports 1..18 bytes"); + const r = await this.att(KeyboardOp.write, [...le16(handle), withoutResponse ? 1 : 0, value.length, ...value]); + if (r.code >>> 8) throw new KeyboardClientError(`ATT write ${handle}: ${r.code >>> 8}`, undefined, r.code >>> 8); + } + + private async attributes(): Promise { + const attrs: Attribute[] = []; + let start = 1; + while (start <= 65535) { + const r = await this.att(KeyboardOp.find, [...le16(start), 255, 255]); + const status = r.code >>> 8; + if (status === ATT_NOT_FOUND) break; // the normal end of the table + if (status) throw new KeyboardClientError(`ATT Find Information: ${status}`); + const width = r.data[0] === 1 ? 4 : r.data[0] === 2 ? 18 : 0; + if (!width || r.data.length <= 1 || (r.data.length - 1) % width) { + throw new KeyboardClientError("Malformed Find Information response"); + } + for (let i = 1; i < r.data.length; i += width) { + const handle = u16(r.data, i); + if (handle < start || attrs.length >= MAX_ATTRIBUTES) throw new KeyboardClientError("Invalid or excessive GATT handles"); + attrs.push({ handle, uuid: attributeUuid(r.data.subarray(i + 2, i + width)) }); + start = handle + 1; + } + } + return attrs; + } + + /** + * The properties byte of a characteristic, from its declaration, or + * undefined when the keyboard won't say. A GATT client normally learns + * declarations through Read By Type, which the bridge doesn't relay, so + * this reads the declaration attribute itself. Most stacks answer that + * with the full declaration. Some keep only the properties byte there and + * build the rest for Read By Type alone (older Telink SDKs, common in + * small keyboards), and some refuse the read. None of that is a reason to + * turn a keyboard away: the report's handle and UUID are already known. + */ + private async declaredProperties(attrs: readonly Attribute[], a: Attribute): Promise { + const decl = attrs.filter((d) => d.handle < a.handle && d.uuid === UUID_CHARACTERISTIC).pop(); + if (!decl) return undefined; + let declaration: Uint8Array; + try { + declaration = await this.shortRead(decl.handle); + } catch (e) { + const status = attRefusal(e); + this.events.log?.(`declaration ${decl.handle} of ${a.handle}: read refused (ATT ${status})`); + return undefined; + } + if (declaration.length === 5 || declaration.length === 19) { + if (u16(declaration, 1) === a.handle && attributeUuid(declaration.subarray(3)) === a.uuid) return declaration[0]!; + this.events.log?.(`declaration ${decl.handle} of ${a.handle}: describes something else (${hex(declaration)})`); + return undefined; + } + if (declaration.length === 1) return declaration[0]!; + this.events.log?.(`declaration ${decl.handle} of ${a.handle}: unexpected value (${hex(declaration)})`); + return undefined; + } + + /** + * Discover every HID service, its Report Map and each report's Report + * Reference; select Report Protocol and subscribe the input reports that + * can carry keys. Needs an encrypted link. No handle is assumed. + * + * Only what typing needs is required of the keyboard: a Report Map that + * parses, and at least one key-bearing input report with a Report + * Reference and a CCC. A report that can't be placed is skipped and + * logged, as is anything wrong with an external report (the battery + * level, usually). + */ + async configure(): Promise { + const epoch = this.epoch; + const log = (line: string): void => this.events.log?.(line); + // A new discovery replaces any earlier mapping, whether or not it succeeds. + this.release(); + this.inputs.clear(); + this.configuration = undefined; + const attrs = await this.attributes(); + log(`gatt ${attrs.map((a) => `${a.handle}=${typeof a.uuid === "number" ? a.uuid.toString(16) : a.uuid}`).join(" ")}`); + const reports: KeyboardReport[] = []; + const watched: KeyboardReport[] = []; + const skipped: string[] = []; + const descriptorsFor = (handle: number): Attribute[] => { + const end = attrs.find((a) => a.handle > handle && + (a.uuid === UUID_PRIMARY_SERVICE || a.uuid === UUID_SECONDARY_SERVICE || a.uuid === UUID_CHARACTERISTIC))?.handle ?? 65536; + return attrs.filter((a) => a.handle > handle && a.handle < end); + }; + /** Why a report was left out; the link going away is not a reason to carry on. */ + const skip = (a: Attribute, reason: string): void => { + skipped.push(`${a.handle}: ${reason}`); + log(`report ${a.handle} skipped: ${reason}`); + }; + const addReport = async (service: number, a: Attribute, map: Uint8Array, parsed: Map) => { + if (reports.some((r) => r.handle === a.handle)) return skip(a, "already listed by another HID service"); + const descriptors = descriptorsFor(a.handle); + const ref = descriptors.find((d) => d.uuid === UUID_REPORT_REFERENCE); + if (!ref) return skip(a, "no Report Reference descriptor"); + let reference: Uint8Array; + try { + reference = await this.shortRead(ref.handle); + } catch (e) { + return skip(a, `Report Reference ${ref.handle} unreadable (ATT ${attRefusal(e)})`); + } + if (reference.length !== 2) return skip(a, `Report Reference ${ref.handle} is ${hex(reference) || "empty"}`); + const id = reference[0]!; + const type = reference[1]!; + if (type < 1 || type > 3) return skip(a, `Report Reference type ${type}`); + const ccc = descriptors.find((d) => d.uuid === UUID_CCC)?.handle; + const properties = await this.declaredProperties(attrs, a); + const report: KeyboardReport = { service, handle: a.handle, id, type, ccc, properties, map }; + if (type === 1) { + const layout = parsed.get(id); + if (!layout) return skip(a, `input report id ${id} is not in the Report Map`); + if (ccc === undefined || (properties !== undefined && !(properties & 0x10))) return skip(a, "input report can't notify"); + if (reportHasKeys(layout)) watched.push(report); + else log(`report ${a.handle} (id ${id}) carries no keys; not subscribed`); + } + reports.push(report); + log(`report ${a.handle}: id ${id} type ${type} ccc ${ccc ?? "-"} properties ${properties ?? "?"}`); + }; + for (let i = 0; i < attrs.length; i++) { + const service = attrs[i]!; + if (service.uuid !== UUID_PRIMARY_SERVICE) continue; + if (attributeUuid(await this.shortRead(service.handle)) !== UUID_HID_SERVICE) continue; + const end = attrs.slice(i + 1).find((a) => a.uuid === UUID_PRIMARY_SERVICE || a.uuid === UUID_SECONDARY_SERVICE)?.handle ?? 65536; + const members = attrs.filter((a) => a.handle > service.handle && a.handle < end); + const mapAttr = members.find((a) => a.uuid === UUID_REPORT_MAP); + if (!mapAttr) throw new KeyboardClientError(`HID service ${service.handle} has no Report Map`); + const map = await this.read(mapAttr.handle); + log(`report map ${mapAttr.handle}: ${hex(map)}`); + const parsed = parseReportMap(map); + for (const mode of members.filter((a) => a.uuid === UUID_PROTOCOL_MODE)) { + try { + await this.write(mode.handle, Uint8Array.of(1), true); + } catch (e) { + // Report Protocol is the default after a connection; a keyboard + // that won't take the write is almost certainly in it already. + log(`protocol mode ${mode.handle}: write refused (ATT ${attRefusal(e)})`); + } + } + for (const a of members.filter((m) => m.uuid === UUID_REPORT)) await addReport(service.handle, a, map, parsed); + // HOGP lets a Report Map refer to reports in other services (commonly Battery). + for (const ext of descriptorsFor(mapAttr.handle).filter((a) => a.uuid === UUID_EXTERNAL_REPORT_REFERENCE)) { + let value: Uint8Array; + try { + value = await this.shortRead(ext.handle); + } catch (e) { + log(`external report reference ${ext.handle} skipped: unreadable (ATT ${attRefusal(e)})`); + continue; + } + if (value.length !== 2 && value.length !== 16) { + log(`external report reference ${ext.handle} skipped: value ${hex(value) || "empty"}`); + continue; + } + const uuid = attributeUuid(value); + for (const a of attrs.filter((m) => m.uuid === uuid && (m.handle < service.handle || m.handle >= end))) { + await addReport(service.handle, a, map, parsed); + } + } + } + if (this.closed || this.epoch !== epoch) throw new KeyboardClientError("The keyboard link changed during setup"); + if (!watched.length) { + throw new KeyboardClientError(reports.length || skipped.length + ? `No usable keyboard input report (${skipped.join("; ") || "none carries keys"})` + : "This device has no HID service"); + } + if (watched.length > MAX_WATCHES) throw new KeyboardClientError("Keyboard has more than 16 input reports"); + const changed = attrs.find((a) => a.uuid === UUID_SERVICE_CHANGED); + const changedCcc = changed && descriptorsFor(changed.handle).find((a) => a.uuid === UUID_CCC); + const watches = watched.map((r) => r.handle); + if (changed && changedCcc && watches.length < MAX_WATCHES) watches.push(changed.handle); + const serviceChanged = changed && changedCcc && watches.includes(changed.handle) ? changed.handle : undefined; + const config: KeyboardConfiguration = { epoch: this.epoch, reports, watched: watched.map((r) => r.handle), serviceChanged }; + this.restore(config); + try { + await this.command(KeyboardOp.watch, [watches.length, ...watches.flatMap(le16)]); + if (serviceChanged !== undefined) { + try { + await this.write(changedCcc!.handle, Uint8Array.of(2, 0)); + } catch (e) { + log(`service changed ${changedCcc!.handle}: subscription refused (ATT ${attRefusal(e)})`); + } + } + for (const r of watched) await this.write(r.ccc!, Uint8Array.of(1, 0)); + } catch (e) { + this.inputs.clear(); + this.configuration = undefined; + this.release(); + throw e; + } + return config; + } + + /** + * Install a mapping found by configure(). It is only good while the glasses + * keep the same connection (the same epoch): after a keyboard reconnect or + * a firmware boot, discover again. + */ + restore(config: KeyboardConfiguration): void { + if (!config.reports.length || config.reports.length > 64) throw new KeyboardClientError("Invalid keyboard configuration"); + const inputs = new Map(); + for (const r of config.reports) { + if (r.type !== 1 || !config.watched.includes(r.handle)) continue; + if (!Number.isInteger(r.handle) || r.handle < 1 || r.handle > 65535 || inputs.has(r.handle)) { + throw new KeyboardClientError("Invalid restored Report handle"); + } + if (!r.map.length || r.map.length > MAX_VALUE) throw new KeyboardClientError("Invalid restored Report Map"); + const report = parseReportMap(r.map).get(r.id); + if (!report) throw new KeyboardClientError("Restored Report ID missing"); + inputs.set(r.handle, { report, id: r.id, service: r.service }); + } + if (!inputs.size || inputs.size > MAX_WATCHES) throw new KeyboardClientError("Invalid restored input count"); + this.release(); + this.inputs = inputs; + this.configuration = config; + } + + /** Output reports of the configured keyboard (the LED report is the usual one). */ + outputReports(): KeyboardReport[] { + return this.configuration?.reports.filter((r) => r.type === 2) ?? []; + } +} + +/** + * The ATT error code when `error` is the keyboard refusing a read or write. + * Anything else (the link dropping, a timeout, a stream gap) is rethrown: + * those end the setup, where a refusal only costs the one attribute. + */ +function attRefusal(error: unknown): number { + if (error instanceof KeyboardClientError && error.attStatus !== undefined) return error.attStatus; + throw error; +} + +function hex(bytes: Uint8Array): string { + return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(""); +} + +function opName(op: number): string { + for (const [name, value] of Object.entries(KeyboardOp)) if (value === op) return name; + return String(op); +} + +function messageOf(error: unknown): string { + return error instanceof Error ? error.message : String(error); +} diff --git a/app/g2/keyboard/hid.ts b/app/g2/keyboard/hid.ts new file mode 100644 index 00000000..566d1491 --- /dev/null +++ b/app/g2/keyboard/hid.ts @@ -0,0 +1,188 @@ +/** + * Bounded HID report-descriptor decoder for the keyboard bridge: turns a + * keyboard's Report Map into the layout of each input report, and input + * reports into the set of keys held. From the reference client in g2flash + * demos/ (keyboard-hid.ts). + * + * HID over GATT carries the Report ID out of band (in each characteristic's + * Report Reference descriptor), so byte zero of a report value is data: it is + * never stripped as USB HID would. Only the keyboard/keypad page (7) and the + * consumer page (12) produce keys; pointer axes and padding are ignored. + * No platform imports: this runs under node in the tests. + */ + +export type HidUsage = { page: number; usage: number }; +export type HidKeyEvent = HidUsage & { down: boolean }; + +type Global = { page: number; min: number; max: number; size: number; count: number; id: number }; +type Field = { + bit: number; + size: number; + count: number; + variable: boolean; + min: number; + max: number; + usages: HidUsage[]; + range?: [HidUsage, HidUsage]; +}; +export type HidReport = { id: number; bits: number; fields: Field[] }; + +const HID_PAGE_KEYBOARD = 7; +const HID_PAGE_CONSUMER = 12; +const REPORT_MAP_MAX = 512; + +function fail(reason: string): never { + throw new Error(`Unsupported or malformed HID descriptor: ${reason}`); +} + +const usageKey = (u: HidUsage): string => `${u.page}:${u.usage}`; + +/** Input reports by Report ID (0 when the descriptor uses none). Throws on anything out of bounds. */ +export function parseReportMap(bytes: Uint8Array): Map { + if (!bytes.length || bytes.length > REPORT_MAP_MAX) fail("report map must contain 1..512 bytes"); + const reports = new Map(); + let g: Global = { page: 0, min: 0, max: 0, size: 0, count: 0, id: 0 }; + const stack: Global[] = []; + let usages: HidUsage[] = []; + let lo: HidUsage | undefined; + let hi: HidUsage | undefined; + let depth = 0; + const usage = (v: number, n: number): HidUsage => + n === 4 ? { page: v >>> 16, usage: v & 65535 } : { page: g.page, usage: v }; + for (let p = 0; p < bytes.length;) { + const prefix = bytes[p++]!; + if (prefix === 0xfe) fail("long items"); + const n = [0, 1, 2, 4][prefix & 3]!; + if (p + n > bytes.length) fail("truncated item"); + let v = 0; + for (let j = 0; j < n; j++) v += bytes[p++]! * 2 ** (8 * j); + const signed = n && v >= 2 ** (n * 8 - 1) ? v - 2 ** (n * 8) : v; + const type = (prefix >> 2) & 3; + const tag = prefix >> 4; + if (type === 1) { + switch (tag) { + case 0: g.page = v; break; + case 1: g.min = signed; break; + case 2: g.max = g.min < 0 ? signed : v; break; + case 7: g.size = v; break; + case 8: if (!v || v > 255) fail("Report ID"); g.id = v; break; + case 9: g.count = v; break; + case 10: if (stack.length >= 8) fail("global stack overflow"); stack.push({ ...g }); break; + case 11: if (!stack.length) fail("global stack underflow"); g = stack.pop()!; break; + case 3: case 4: case 5: case 6: break; // physical range, unit and exponent + default: fail("unknown global item"); + } + } else if (type === 2) { + if (tag === 0) { if (usages.length >= 512) fail("too many usages"); usages.push(usage(v, n)); } + else if (tag === 1) lo = usage(v, n); + else if (tag === 2) hi = usage(v, n); + else if (tag === 10) fail("usage delimiters"); + else if (tag > 9) fail("unknown local item"); + } else if (type === 0) { + if (tag === 10) { if (++depth > 32) fail("collection depth"); } + else if (tag === 12) { if (--depth < 0) fail("collection underflow"); } + else if (tag === 8) { + if (!g.size || g.size > 32 || !g.count || g.count > 512) fail("field dimensions"); + let r = reports.get(g.id); + if (!r) { + if (reports.size >= 16) fail("too many input reports"); + r = { id: g.id, bits: 0, fields: [] }; + reports.set(g.id, r); + } + const field: Field = { + bit: r.bits, size: g.size, count: g.count, variable: !!(v & 2), min: g.min, max: g.max, usages: [...usages], + }; + if (lo || hi) { + if (!lo || !hi || lo.page !== hi.page || hi.usage < lo.usage) fail("usage range"); + field.range = [lo!, hi!]; + } + r.bits += g.size * g.count; + if (r.bits > 4096) fail("report exceeds 512 bytes"); + // Constant padding and relative pointer axes are not keys. + if (!(v & 1) && !(v & 4)) r.fields.push(field); + } else if (tag !== 9 && tag !== 11) fail("unknown main item"); + usages = []; + lo = hi = undefined; + } else fail("reserved item type"); + } + if (depth || stack.length) fail("unbalanced collection/global stack"); + if (reports.has(0) && reports.size > 1) fail("mixed numbered and unnumbered input reports"); + if (!reports.size) fail("no input reports"); + return reports; +} + +function usageAt(f: Field, index: number): HidUsage | undefined { + if (index < 0) return undefined; + if (index < f.usages.length) return f.usages[index]; + const rangeIndex = index - f.usages.length; + if (f.range && rangeIndex <= f.range[1].usage - f.range[0].usage) { + return { page: f.range[0].page, usage: f.range[0].usage + rangeIndex }; + } + // Variable items reuse their last usage when Report Count exceeds the usages. + if (f.variable) return f.range?.[1] ?? f.usages[f.usages.length - 1]; + return undefined; +} + +/** + * Whether an input report can ever say a key is held. False for a pointer's + * report (a trackpad or mouse on a combined device), whose movement would + * otherwise be relayed, and thrown away, a hundred times a second. + */ +export function reportHasKeys(report: HidReport): boolean { + const isKeyPage = (u: HidUsage): boolean => u.page === HID_PAGE_KEYBOARD || u.page === HID_PAGE_CONSUMER; + return report.fields.some((f) => f.usages.some(isKeyPage) || (f.range !== undefined && isKeyPage(f.range[0]))); +} + +/** The keys one input report says are held. Throws on a length mismatch or a rollover report. */ +export function reportKeys(report: HidReport, data: Uint8Array): HidUsage[] { + if (data.length !== Math.ceil(report.bits / 8)) throw new Error("HID input length does not match Report Map"); + const keys = new Map(); + for (const f of report.fields) { + for (let i = 0; i < f.count; i++) { + let value = 0; + for (let j = 0; j < f.size; j++) { + const bit = f.bit + i * f.size + j; + if (data[bit >>> 3]! & (1 << (bit & 7))) value += 2 ** j; + } + if (f.min < 0 && value >= 2 ** (f.size - 1)) value -= 2 ** f.size; + if (value < f.min || value > f.max) continue; // null state + const u = usageAt(f, f.variable ? i : value - f.min); + if (!u || (f.variable && value === 0) || !u.usage) continue; + if (u.page === HID_PAGE_KEYBOARD && u.usage <= 3) throw new Error("HID keyboard rollover/error report"); + if (u.page === HID_PAGE_KEYBOARD || u.page === HID_PAGE_CONSUMER) keys.set(usageKey(u), u); + } + } + return [...keys.values()]; +} + +/** + * Held keys across a keyboard's input reports. Ownership is per report + * characteristic, then unioned: releasing a key in one report cannot release + * a modifier another report still holds. + */ +export class HidKeys { + private reports = new Map(); + private held = new Map(); + + /** Apply one report from characteristic `handle`; returns the transitions it caused. */ + update(handle: number, report: HidReport, data: Uint8Array): HidKeyEvent[] { + this.reports.set(handle, reportKeys(report, data)); + return this.diff(); + } + + /** Release everything (a stream gap, a dropped link). */ + reset(): HidKeyEvent[] { + this.reports.clear(); + return this.diff(); + } + + private diff(): HidKeyEvent[] { + const next = new Map(); + for (const values of this.reports.values()) for (const u of values) next.set(usageKey(u), u); + const events: HidKeyEvent[] = []; + for (const [k, u] of this.held) if (!next.has(k)) events.push({ ...u, down: false }); + for (const [k, u] of next) if (!this.held.has(k)) events.push({ ...u, down: true }); + this.held = next; + return events; + } +} diff --git a/app/g2/keyboard/key-router.ts b/app/g2/keyboard/key-router.ts new file mode 100644 index 00000000..cbda2ac2 --- /dev/null +++ b/app/g2/keyboard/key-router.ts @@ -0,0 +1,144 @@ +/** + * Where a key from the hardware keyboard goes: to a keybinding being set up, + * to a gesture it is bound to, to the window with input focus, or to the + * built-in navigation. The meanings are in bindings.ts; this is the order of + * asking, and the bookkeeping around it. Shared by the Android and iOS + * controllers through KeyRouterHost. + * No platform imports: this runs under node in the tests. + */ +import { + GestureScheme, + chordOf, + isModifierCode, + resolveKey, + type GestureOrigin, + type KeyAction, + type KeyChord, + type KeyGesture, +} from "./bindings"; +import type { KeyEvent } from "./keys"; + +export type KeyRouterHost = { + /** Connected to glasses that are in use. */ + ready(): boolean; + locked(): boolean; + screenOn(): boolean; + /** Turn a dark display on, and nothing else. */ + wake(): void; + /** Offer a key to the window with input focus; true when that window takes keys. */ + offerToWindow(event: KeyEvent): boolean; + /** Perform a gesture as if it came from the ring or the watch. */ + gesture(gesture: KeyGesture, origin: GestureOrigin): Promise; + /** The custom keybindings, by chord id. */ + bindings(): ReadonlyMap; + /** A key was used for something other than a gesture or typing (count it against the screen timeout). */ + noteActivity(): void; + log(line: string): void; + now?(): number; +}; + +/** + * A held key repeats twenty times a second, faster than a list can repaint + * over the glasses' link. Repeats are dropped while a gesture is still being + * handled, and closer together than this. + */ +const REPEAT_MIN_INTERVAL_MS = 100; + +export class KeyRouter { + private capture: ((chord: KeyChord) => void) | null = null; + /** Keys whose press was spoken for, so their release is too. */ + private readonly consumed = new Set(); + private readonly scheme = new GestureScheme(); + private gesturesInFlight = 0; + private lastGestureAtMs = 0; + + constructor(private readonly host: KeyRouterHost) {} + + /** One key transition from the keyboard. */ + handleKey(event: KeyEvent): void { + const host = this.host; + if (!host.ready()) return; + if (host.locked() || !host.screenOn()) { + // A dark display takes no typing: the first press only wakes it, as + // the ring's double tap would, and a locked one stays locked. + if (event.phase === "down" && !event.repeat && !host.screenOn()) host.wake(); + return; + } + if (this.capture) { + this.captureKey(event); + return; + } + if (event.phase === "up") { + if (!this.consumed.delete(event.code)) host.offerToWindow(event); + return; + } + const resolution = resolveKey(event, host.bindings()); + if (resolution.consume) { + this.consumed.add(event.code); + if (resolution.gesture) this.perform(resolution.gesture, event.repeat); + return; + } + if (host.offerToWindow(event)) return; + if (resolution.gesture) this.perform(resolution.gesture, event.repeat); + } + + /** + * A key the focused window was offered and had no use for (a terminal + * showing its session list rather than a session): it gets the built-in + * navigation meaning after all. + */ + handleUnhandledKey(event: KeyEvent): void { + const host = this.host; + if (event.phase !== "down" || this.capture || !host.ready() || host.locked() || !host.screenOn()) return; + const resolution = resolveKey(event, host.bindings()); + if (!resolution.consume && resolution.gesture) this.perform(resolution.gesture, event.repeat); + } + + /** + * Take the next key press instead of acting on it (setting up a + * keybinding). Modifiers held with it are part of the chord; pressed alone + * they are waited through. Returns a function that calls the capture off. + */ + captureNextKey(onChord: (chord: KeyChord) => void): () => void { + this.capture = onChord; + return () => { + if (this.capture === onChord) this.capture = null; + }; + } + + /** The keyboard went away: nothing is held any more. */ + reset(): void { + this.consumed.clear(); + } + + private captureKey(event: KeyEvent): void { + this.host.noteActivity(); + if (event.phase === "up") { + this.consumed.delete(event.code); + return; + } + if (event.repeat || isModifierCode(event.code)) return; + const capture = this.capture!; + this.capture = null; + this.consumed.add(event.code); + capture(chordOf(event)); + } + + private perform(gesture: KeyGesture, repeat: boolean): void { + const now = this.host.now ? this.host.now() : Date.now(); + if (repeat && (this.gesturesInFlight > 0 || now - this.lastGestureAtMs < REPEAT_MIN_INTERVAL_MS)) return; + this.lastGestureAtMs = now; + void this.run(gesture, this.scheme.originFor(gesture)); + } + + private async run(gesture: KeyGesture, origin: GestureOrigin): Promise { + this.gesturesInFlight++; + try { + await this.host.gesture(gesture, origin); + } catch (error) { + this.host.log(`keyboard gesture ${gesture} failed: ${error instanceof Error ? error.message : String(error)}`); + } finally { + this.gesturesInFlight--; + } + } +} diff --git a/app/g2/keyboard/keys.ts b/app/g2/keyboard/keys.ts new file mode 100644 index 00000000..1a4c35e8 --- /dev/null +++ b/app/g2/keyboard/keys.ts @@ -0,0 +1,285 @@ +/** + * Key events as the rest of Faceclaw sees them, and the translation from the + * keyboard bridge's raw HID transitions: layout (US only for now), modifier + * and Caps Lock state, and typematic repeat, which a BLE keyboard never sends + * (its report just stays asserted). The translation tables follow the Glassly + * app's (GlassesKeyboardInput.ts, MIT). + * No platform imports: this runs under node in the tests, and in app workers. + */ +import type { HidKeyEvent } from "./hid"; + +export type KeyModifiers = { shift: boolean; ctrl: boolean; alt: boolean; meta: boolean }; + +/** + * One key transition, shaped like a DOM KeyboardEvent: `key` is the logical + * key with the layout applied ("a", "A", "Enter", "ArrowUp"), `code` the + * physical key ("KeyA"), `text` what a press types (absent for releases, for + * keys that type nothing, and for Ctrl/Alt/Meta chords, which are commands). + */ +export type KeyEvent = { + phase: "down" | "up"; + key: string; + code: string; + text?: string; + modifiers: KeyModifiers; + /** A synthesized auto-repeat of a held key. */ + repeat: boolean; + /** Date.now() when the phone saw the transition. */ + timestampMs: number; +}; + +const HID_PAGE_KEYBOARD = 7; +const HID_PAGE_CONSUMER = 12; +const USAGE_CAPS_LOCK = 57; + +/** [unshifted, shifted, code] for US-layout punctuation on the keyboard page. */ +const PUNCTUATION: Record = { + 45: ["-", "_", "Minus"], + 46: ["=", "+", "Equal"], + 47: ["[", "{", "BracketLeft"], + 48: ["]", "}", "BracketRight"], + 49: ["\\", "|", "Backslash"], + 50: ["#", "~", "IntlHash"], + 51: [";", ":", "Semicolon"], + 52: ["'", '"', "Quote"], + 53: ["`", "~", "Backquote"], + 54: [",", "<", "Comma"], + 55: [".", ">", "Period"], + 56: ["/", "?", "Slash"], + 100: ["\\", "|", "IntlBackslash"], +}; + +const DIGITS = "1234567890"; +const SHIFTED_DIGITS = "!@#$%^&*()"; + +/** [key, code] for keys that type nothing. */ +const NAMED: Record = { + 40: ["Enter", "Enter"], + 41: ["Escape", "Escape"], + 42: ["Backspace", "Backspace"], + 43: ["Tab", "Tab"], + 57: ["CapsLock", "CapsLock"], + 70: ["PrintScreen", "PrintScreen"], + 71: ["ScrollLock", "ScrollLock"], + 72: ["Pause", "Pause"], + 73: ["Insert", "Insert"], + 74: ["Home", "Home"], + 75: ["PageUp", "PageUp"], + 76: ["Delete", "Delete"], + 77: ["End", "End"], + 78: ["PageDown", "PageDown"], + 79: ["ArrowRight", "ArrowRight"], + 80: ["ArrowLeft", "ArrowLeft"], + 81: ["ArrowDown", "ArrowDown"], + 82: ["ArrowUp", "ArrowUp"], + 83: ["NumLock", "NumLock"], + 88: ["Enter", "NumpadEnter"], + 101: ["ContextMenu", "ContextMenu"], + 102: ["Power", "Power"], + 224: ["Control", "ControlLeft"], + 225: ["Shift", "ShiftLeft"], + 226: ["Alt", "AltLeft"], + 227: ["Meta", "MetaLeft"], + 228: ["Control", "ControlRight"], + 229: ["Shift", "ShiftRight"], + 230: ["Alt", "AltRight"], + 231: ["Meta", "MetaRight"], +}; + +/** [key and text, code] for the numeric keypad's operators. */ +const NUMPAD: Record = { + 84: ["/", "NumpadDivide"], + 85: ["*", "NumpadMultiply"], + 86: ["-", "NumpadSubtract"], + 87: ["+", "NumpadAdd"], + 99: [".", "NumpadDecimal"], + 103: ["=", "NumpadEqual"], +}; + +const CONSUMER: Record = { + 0xe9: "AudioVolumeUp", + 0xea: "AudioVolumeDown", + 0xe2: "AudioVolumeMute", + 0xcd: "MediaPlayPause", + 0xb0: "MediaPlay", + 0xb1: "MediaPause", + 0xb5: "MediaTrackNext", + 0xb6: "MediaTrackPrevious", + 0xb7: "MediaStop", + 0x6f: "BrightnessUp", + 0x70: "BrightnessDown", + 0x221: "BrowserSearch", + 0x223: "BrowserHome", + 0x224: "BrowserBack", + 0x225: "BrowserForward", + 0x18a: "LaunchMail", + 0x192: "LaunchApplication2", + 0x194: "LaunchApplication1", +}; + +const MODIFIER_USAGES: Record = { + 224: "ctrl", 228: "ctrl", 225: "shift", 229: "shift", 226: "alt", 230: "alt", 227: "meta", 231: "meta", +}; + +type Translated = { key: string; code: string; text?: string }; + +/** One HID usage under the US layout. Caps Lock only affects letters. */ +export function translateUsage(page: number, usage: number, shift: boolean, capsLock: boolean): Translated { + if (page === HID_PAGE_KEYBOARD) { + if (usage >= 4 && usage <= 29) { + const lower = String.fromCharCode(97 + usage - 4); + const key = shift !== capsLock ? lower.toUpperCase() : lower; + return { key, code: `Key${lower.toUpperCase()}`, text: key }; + } + if (usage >= 30 && usage <= 39) { + const index = usage - 30; + const key = shift ? SHIFTED_DIGITS[index]! : DIGITS[index]!; + return { key, code: `Digit${DIGITS[index]}`, text: key }; + } + if (usage === 44) return { key: " ", code: "Space", text: " " }; + const punctuation = PUNCTUATION[usage]; + if (punctuation) { + const key = shift ? punctuation[1] : punctuation[0]; + return { key, code: punctuation[2], text: key }; + } + if (usage >= 58 && usage <= 69) return { key: `F${usage - 57}`, code: `F${usage - 57}` }; + if (usage >= 104 && usage <= 115) return { key: `F${usage - 91}`, code: `F${usage - 91}` }; + if (usage >= 89 && usage <= 97) { + const digit = String(usage - 88); + return { key: digit, code: `Numpad${digit}`, text: digit }; + } + if (usage === 98) return { key: "0", code: "Numpad0", text: "0" }; + const numpad = NUMPAD[usage]; + if (numpad) return { key: numpad[0], code: numpad[1], text: numpad[0] }; + const named = NAMED[usage]; + if (named) return { key: named[0], code: named[1] }; + return { key: "Unidentified", code: `Usage${usage.toString(16).padStart(2, "0")}` }; + } + if (page === HID_PAGE_CONSUMER) { + const name = CONSUMER[usage]; + return name ? { key: name, code: name } : { key: "Unidentified", code: `Consumer${usage.toString(16)}` }; + } + return { key: "Unidentified", code: `Page${page.toString(16)}Usage${usage.toString(16)}` }; +} + +export type KeyTranslatorOptions = { + emit: (event: KeyEvent) => void; + now?: () => number; + setTimer?: (callback: () => void, delayMs: number) => unknown; + clearTimer?: (handle: unknown) => void; + /** Hold time before the first repeat, and the gap between repeats. */ + repeatDelayMs?: number; + repeatIntervalMs?: number; +}; + +const REPEAT_DELAY_MS = 400; +const REPEAT_INTERVAL_MS = 50; + +/** + * Raw HID transitions in, KeyEvents out. Modifier state comes from the same + * stream, and the bridge reports a release for every key when the stream may + * have lost something, so a missed key-up cannot leave a modifier stuck or a + * key repeating forever. + */ +export class KeyTranslator { + private readonly emitEvent: (event: KeyEvent) => void; + private readonly now: () => number; + private readonly setTimer: (callback: () => void, delayMs: number) => unknown; + private readonly clearTimer: (handle: unknown) => void; + private readonly repeatDelayMs: number; + private readonly repeatIntervalMs: number; + private readonly held = new Set(); + private modifiers: KeyModifiers = { shift: false, ctrl: false, alt: false, meta: false }; + private capsLock = false; + private repeatTimer: unknown = null; + private repeating: { page: number; usage: number } | null = null; + + constructor(options: KeyTranslatorOptions) { + this.emitEvent = options.emit; + this.now = options.now ?? (() => Date.now()); + this.setTimer = options.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs)); + this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle as ReturnType)); + this.repeatDelayMs = options.repeatDelayMs ?? REPEAT_DELAY_MS; + this.repeatIntervalMs = options.repeatIntervalMs ?? REPEAT_INTERVAL_MS; + } + + /** Apply the transitions one input report produced, in order. */ + handle(events: readonly HidKeyEvent[]): void { + for (const event of events) this.handleOne(event); + } + + private handleOne(event: HidKeyEvent): void { + const id = `${event.page}:${event.usage}`; + const modifier = event.page === HID_PAGE_KEYBOARD ? MODIFIER_USAGES[event.usage] : undefined; + if (event.down) { + if (this.held.has(id)) return; + this.held.add(id); + if (modifier) this.modifiers[modifier] = true; + if (event.page === HID_PAGE_KEYBOARD && event.usage === USAGE_CAPS_LOCK) this.capsLock = !this.capsLock; + this.emit("down", event.page, event.usage, false); + // The newest non-modifier key is the one that repeats, as on a PC. + if (!modifier) this.startRepeat(event.page, event.usage); + } else { + if (!this.held.delete(id)) return; + if (modifier) this.modifiers[modifier] = this.otherHeld(event.usage, modifier); + if (this.repeating?.page === event.page && this.repeating.usage === event.usage) this.stopRepeat(); + this.emit("up", event.page, event.usage, false); + } + } + + /** The keyboard went away: forget everything without emitting releases. */ + reset(): void { + this.stopRepeat(); + this.held.clear(); + this.modifiers = { shift: false, ctrl: false, alt: false, meta: false }; + this.capsLock = false; + } + + /** Whether the same modifier's key on the other side is still down. */ + private otherHeld(released: number, modifier: keyof KeyModifiers): boolean { + for (const [usage, name] of Object.entries(MODIFIER_USAGES)) { + if (name === modifier && Number(usage) !== released && this.held.has(`${HID_PAGE_KEYBOARD}:${usage}`)) return true; + } + return false; + } + + private emit(phase: "down" | "up", page: number, usage: number, repeat: boolean): void { + const translated = translateUsage(page, usage, this.modifiers.shift, this.capsLock); + const event: KeyEvent = { + phase, + key: translated.key, + code: translated.code, + modifiers: { ...this.modifiers }, + repeat, + timestampMs: this.now(), + }; + if (phase === "down" && translated.text !== undefined && + !this.modifiers.ctrl && !this.modifiers.alt && !this.modifiers.meta) { + event.text = translated.text; + } + this.emitEvent(event); + } + + private startRepeat(page: number, usage: number): void { + this.stopRepeat(); + this.repeating = { page, usage }; + this.repeatTimer = this.setTimer(() => this.repeatTick(), this.repeatDelayMs); + } + + private repeatTick(): void { + const key = this.repeating; + this.repeatTimer = null; + if (!key || !this.held.has(`${key.page}:${key.usage}`)) { + this.repeating = null; + return; + } + this.emit("down", key.page, key.usage, true); + this.repeatTimer = this.setTimer(() => this.repeatTick(), this.repeatIntervalMs); + } + + private stopRepeat(): void { + if (this.repeatTimer !== null) this.clearTimer(this.repeatTimer); + this.repeatTimer = null; + this.repeating = null; + } +} diff --git a/app/g2/keyboard/protocol.ts b/app/g2/keyboard/protocol.ts new file mode 100644 index 00000000..d70e661a --- /dev/null +++ b/app/g2/keyboard/protocol.ts @@ -0,0 +1,297 @@ +/** + * Wire format of the CFW keyboard bridge (Faceclaw/39). The master temple acts + * as a BLE central for one HID-over-GATT keyboard; the phone drives that link + * over private settings fields and gets the keyboard's raw input reports back. + * The firmware side is g2flash patches/keyboard_core.h, documented in its + * docs/keyboard.md. This follows the reference client in g2flash demos/ + * (keyboard-protocol.ts), which came with the firmware from tetramo-labs. + * + * Phone -> glasses, settings field 130 (wrapped by the native session): + * ['K','B',1,op, request LE16, epoch LE16, body...] at most 80 bytes + * Glasses -> phone, settings field 131: + * ['K','B',1,kind, sequence LE32, epoch LE16, request LE16, code LE16, + * handle LE16, total LE16, offset LE16, timestamp LE32, fragment...] + * + * All integers are little endian. No platform imports: this runs under node + * in the tests. + */ + +export const KEYBOARD_PROTOCOL_VERSION = 1; + +/** Fixed part of a field-131 record, before its fragment. */ +export const KEYBOARD_RECORD_HEADER = 24; +/** Most body bytes one record carries; longer bodies are fragmented. */ +export const KEYBOARD_RECORD_CHUNK = 96; +/** Largest reassembled body (an ATT value or a HID report). */ +export const KEYBOARD_BODY_MAX = 512; +/** Largest control body after the 8-byte prefix. */ +export const KEYBOARD_CONTROL_BODY_MAX = 72; + +export const KeyboardOp = { + query: 0, + enable: 1, + disable: 2, + scan: 3, + connect: 4, + disconnect: 5, + pair: 6, + auth: 7, + compare: 8, + find: 9, + read: 10, + write: 11, + watch: 12, +} as const; +export type KeyboardOpCode = (typeof KeyboardOp)[keyof typeof KeyboardOp]; + +export const KeyboardKind = { + status: 1, + att: 2, + input: 3, + dm: 4, + advert: 5, +} as const; + +/** Control error codes, carried in a STATUS record's `code`. */ +export const KeyboardError = { + ok: 0, + badRequest: 1, + disabled: 2, + busy: 3, + staleEpoch: 4, + noSpace: 5, + notConnected: 6, + notEncrypted: 7, + timeout: 8, + noMemory: 9, +} as const; + +export function keyboardErrorName(code: number): string { + switch (code) { + case KeyboardError.ok: return "ok"; + case KeyboardError.badRequest: return "bad request"; + case KeyboardError.disabled: return "keyboard bridge disabled"; + case KeyboardError.busy: return "busy"; + case KeyboardError.staleEpoch: return "stale epoch"; + case KeyboardError.noSpace: return "no connection or bond space"; + case KeyboardError.notConnected: return "not connected"; + case KeyboardError.notEncrypted: return "not encrypted"; + case KeyboardError.timeout: return "timeout"; + case KeyboardError.noMemory: return "allocation failure"; + default: return `error ${code}`; + } +} + +/** Cordio device-manager events the bridge relays (a DM record's `code & 0xff`). */ +export const KeyboardDm = { + connOpen: 0x27, + connClose: 0x28, + pairComplete: 0x2a, + pairFailed: 0x2b, + encrypted: 0x2c, + encryptFailed: 0x2d, + authRequest: 0x2e, + compare: 0x35, +} as const; + +/** ATT client events (an ATT record's `code & 0xff`; the status is `code >> 8`). */ +export const KeyboardAtt = { + notification: 13, + indication: 14, +} as const; + +export type KeyboardRecord = { + kind: number; + sequence: number; + epoch: number; + request: number; + code: number; + handle: number; + /** Glasses uptime in ms when the record was queued. */ + timestamp: number; + data: Uint8Array; +}; + +export const u16 = (p: Uint8Array, off = 0): number => p[off]! | (p[off + 1]! << 8); +export const u32 = (p: Uint8Array, off = 0): number => + (p[off]! | (p[off + 1]! << 8) | (p[off + 2]! << 16) | (p[off + 3]! << 24)) >>> 0; +export const le16 = (v: number): number[] => [v & 255, (v >>> 8) & 255]; + +/** A field-130 control record. The session wraps it in the settings package. */ +export function keyboardControl(op: number, request: number, epoch: number, body: readonly number[] = []): Uint8Array { + if (!Number.isInteger(op) || op < 0 || op > KeyboardOp.watch || body.length > KEYBOARD_CONTROL_BODY_MAX) { + throw new Error("Keyboard control bounds"); + } + return Uint8Array.from([75, 66, KEYBOARD_PROTOCOL_VERSION, op, ...le16(request), ...le16(epoch), ...body]); +} + +/** + * Bounded, ordered reassembly of field-131 records. `onGap` fires whenever + * the stream may have lost something (a skipped sequence, an epoch change, a + * malformed or orphaned fragment): the caller then releases every held key + * and fails any setup transaction in flight. The firmware's once-a-second + * status record makes a lost final release visible even when no further keys + * arrive. + */ +export class KeyboardRecords { + private epoch: number | undefined; + private last: number | undefined; + private fragment: { record: KeyboardRecord; total: number; used: number } | undefined; + + constructor(private readonly onGap: () => void) {} + + /** Forget the stream position (the phone link dropped); counts as a gap. */ + reset(): void { + this.epoch = undefined; + this.last = undefined; + this.fragment = undefined; + this.onGap(); + } + + /** Feed one field-131 payload; returns a complete record, or undefined. */ + push(p: Uint8Array): KeyboardRecord | undefined { + const invalid = (): undefined => { + this.fragment = undefined; + this.onGap(); + return undefined; + }; + if ( + p.length < KEYBOARD_RECORD_HEADER || p.length > KEYBOARD_RECORD_HEADER + KEYBOARD_RECORD_CHUNK || + p[0] !== 75 || p[1] !== 66 || p[2] !== KEYBOARD_PROTOCOL_VERSION + ) { + return invalid(); + } + const r: KeyboardRecord = { + kind: p[3]!, + sequence: u32(p, 4), + epoch: u16(p, 8), + request: u16(p, 10), + code: u16(p, 12), + handle: u16(p, 14), + timestamp: u32(p, 20), + data: new Uint8Array(0), + }; + const total = u16(p, 16); + const offset = u16(p, 18); + const n = p.length - KEYBOARD_RECORD_HEADER; + if (r.kind < KeyboardKind.status || r.kind > KeyboardKind.advert || total > KEYBOARD_BODY_MAX || + offset + n > total || (total > 0 && n === 0)) { + return invalid(); + } + if (this.epoch !== r.epoch) { + this.onGap(); + this.fragment = undefined; + this.last = undefined; + this.epoch = r.epoch; + } + if (offset === 0) { + if (this.last !== undefined) { + const distance = (r.sequence - this.last) >>> 0; + if (distance === 0 || distance >= 0x80000000) return undefined; // duplicate or old delivery + } + if (this.fragment || (this.last !== undefined && r.sequence !== ((this.last + 1) >>> 0))) this.onGap(); + this.last = r.sequence; + this.fragment = { record: { ...r, data: new Uint8Array(total) }, total, used: 0 }; + } + const f = this.fragment; + if (!f || f.used !== offset || f.total !== total || f.record.sequence !== r.sequence || + f.record.kind !== r.kind || f.record.request !== r.request || f.record.code !== r.code || + f.record.handle !== r.handle || f.record.timestamp !== r.timestamp) { + return invalid(); + } + f.record.data.set(p.subarray(KEYBOARD_RECORD_HEADER), offset); + f.used += n; + if (f.used !== total) return undefined; + this.fragment = undefined; + return f.record; + } +} + +/** BLE address types as the controller reports them. */ +export const KEYBOARD_ADDRESS_TYPES = ["public", "random", "public-identity", "random-identity"] as const; + +/** One advertiser seen during a scan (an ADVERT record's body, parsed). */ +export type KeyboardAdvert = { + addressType: number; + /** "aa:bb:cc:dd:ee:ff", most significant byte first. */ + address: string; + rssi: number; + name: string; + /** Advertises the HID service, or a HID appearance. */ + hid: boolean; +}; + +/** ADVERT body: addrType, addr[6] (LSB first), RSSI, event type, AD length, AD structures. */ +export function parseKeyboardAdvert(body: Uint8Array): KeyboardAdvert | null { + if (body.length < 10 || body[0]! > 3) return null; + let name = ""; + let hid = false; + for (let i = 10; i < body.length;) { + const n = body[i++]!; + if (n === 0 || i + n > body.length) break; + const type = body[i]!; + if (type === 8 || type === 9) name = decodeUtf8(body.subarray(i + 1, i + n)); + // 16-bit service lists (incomplete / complete): 0x1812 is HID. + if (type === 2 || type === 3) { + for (let j = i + 1; j + 1 < i + n; j += 2) if (body[j] === 0x12 && body[j + 1] === 0x18) hid = true; + } + // Appearance 0x03C0..0x03FF is the HID category (0x03C1 keyboard); some + // keyboards advertise that without the service list. + if (type === 0x19 && n >= 3 && body[i + 2] === 0x03 && body[i + 1]! >= 0xc0) hid = true; + i += n; + } + return { + addressType: body[0]!, + address: formatKeyboardAddress(body.subarray(1, 7)), + rssi: (body[7]! << 24) >> 24, + name, + hid, + }; +} + +/** + * Fold a later record for the same advertiser into an earlier one. An active + * scan reports the advertisement and its scan response separately and the + * name usually only rides in the latter: keep a name once seen, HID once + * seen, and the best signal. + */ +export function mergeKeyboardAdverts(a: KeyboardAdvert, b: KeyboardAdvert): KeyboardAdvert { + return { ...a, rssi: Math.max(a.rssi, b.rssi), name: a.name || b.name, hid: a.hid || b.hid }; +} + +/** Controller byte order (LSB first) to the usual "aa:bb:cc:dd:ee:ff". */ +export function formatKeyboardAddress(lsbFirst: Uint8Array): string { + return Array.from(lsbFirst).reverse().map((b) => b.toString(16).padStart(2, "0")).join(":"); +} + +/** "aa:bb:cc:dd:ee:ff" to the controller's LSB-first bytes, or null if malformed. */ +export function parseKeyboardAddress(text: string): Uint8Array | null { + if (!/^(?:[0-9a-f]{2}:){5}[0-9a-f]{2}$/i.test(text)) return null; + return Uint8Array.from(text.split(":").reverse().map((part) => parseInt(part, 16))); +} + +/** Lenient UTF-8 decode (advertised names); no TextDecoder in every runtime this loads in. */ +function decodeUtf8(bytes: Uint8Array): string { + let out = ""; + for (let i = 0; i < bytes.length;) { + const b = bytes[i++]!; + let code = b; + let extra = 0; + if (b >= 0xf0 && b < 0xf8) { code = b & 0x07; extra = 3; } + else if (b >= 0xe0) { code = b & 0x0f; extra = 2; } + else if (b >= 0xc0) { code = b & 0x1f; extra = 1; } + else if (b >= 0x80) { out += "�"; continue; } + if (i + extra > bytes.length) { out += "�"; break; } + let valid = true; + for (let k = 0; k < extra; k++) { + const c = bytes[i + k]!; + if ((c & 0xc0) !== 0x80) { valid = false; break; } + code = (code << 6) | (c & 0x3f); + } + if (!valid || code > 0x10ffff) { out += "�"; continue; } + i += extra; + if (code === 0) continue; + out += String.fromCodePoint(code); + } + return out; +} diff --git a/app/g2/keyboard/service.ts b/app/g2/keyboard/service.ts new file mode 100644 index 00000000..333704ff --- /dev/null +++ b/app/g2/keyboard/service.ts @@ -0,0 +1,216 @@ +/** + * The keyboard bridge as the app uses it: one KeyboardBridge for the life of + * the app, fed by whichever glasses session is live, its remembered keyboard + * and the custom keybindings kept in the settings store, and its key + * transitions turned into KeyEvents and routed. The platform's controller + * reports the link coming and going and performs the gestures keys stand + * for; the Settings app drives pairing through `bridge` and edits the + * keybindings. + */ +import { addKeyboardEventListener, keyboardLinkSession, sendKeyboardControlRecord } from "../../native/keyboard-link"; +import { getStringSetting, setStringSetting } from "../../native/settings-store"; +import { shell } from "../../ui/shell/shell"; +import { + MAX_KEY_BINDINGS, + chordId, + keyBindingMap, + parseKeyBindings, + serializeKeyBindings, + type GestureOrigin, + type KeyAction, + type KeyBinding, + type KeyChord, + type KeyGesture, +} from "./bindings"; +import { KeyboardBridge, type KeyboardBridgeSnapshot, type SavedKeyboard } from "./bridge"; +import { KeyRouter } from "./key-router"; +import { KeyTranslator, type KeyEvent } from "./keys"; + +declare const java: any; +declare const arc4random_uniform: ((bound: number) => number) | undefined; + +/** JSON of the remembered keyboard ({ address, addressType, name }), or "" for none. */ +const SAVED_KEYBOARD_KEY = "keyboard.saved"; +/** JSON list of the custom keybindings ({ key, action }); see bindings.ts. */ +const KEY_BINDINGS_KEY = "keyboard.bindings"; + +/** What the platform's controller does for the keyboard. */ +export type KeyboardServiceHost = { + /** Connected to glasses that are in use (not charging in their case). */ + ready(): boolean; + locked(): boolean; + /** Turn a dark display on, and nothing else (a locked display stays locked). */ + wake(): void; + /** Perform a gesture as if it came from the ring or the watch. */ + gesture(gesture: KeyGesture, origin: GestureOrigin): Promise; + /** Routine lines only (failed background reconnects); the rest go to the device log directly. */ + log(line: string): void; + /** Whether an absent keyboard is worth looking for now (see KeyboardBridgeHost). */ + shouldReconnect(): boolean; +}; + +function loadSavedKeyboard(): SavedKeyboard | null { + try { + const raw = getStringSetting(SAVED_KEYBOARD_KEY, ""); + if (!raw) return null; + const value = JSON.parse(raw); + if (typeof value?.address !== "string" || typeof value?.addressType !== "number") return null; + return { address: value.address, addressType: value.addressType, name: typeof value.name === "string" ? value.name : "" }; + } catch { + return null; + } +} + +/** Passkey entry only protects the pairing if the passkey can't be guessed. */ +function randomPasskey(): number { + try { + if (global.isAndroid) return new java.security.SecureRandom().nextInt(1_000_000); + if (typeof arc4random_uniform === "function") return arc4random_uniform(1_000_000); + } catch { + // Fall through to the weaker source rather than failing the pairing. + } + return Math.floor(Math.random() * 1_000_000); +} + +class KeyboardService { + private host: KeyboardServiceHost | null = null; + private session: unknown = null; + private offEvents: (() => void) | null = null; + private readonly listeners = new Set<() => void>(); + private bindings: KeyBinding[] = parseKeyBindings(getStringSetting(KEY_BINDINGS_KEY, "")); + private bindingMap = keyBindingMap(this.bindings); + + private readonly router = new KeyRouter({ + ready: () => this.host?.ready() ?? false, + locked: () => this.host?.locked() ?? false, + screenOn: () => shell.isScreenOn(), + wake: () => this.host?.wake(), + offerToWindow: (event) => shell.receiveKeyEvent(event), + gesture: (gesture, origin) => this.host?.gesture(gesture, origin) ?? Promise.resolve(), + bindings: () => this.bindingMap, + noteActivity: () => shell.noteUserActivity(), + log: (line) => console.log(`[keyboard] ${line}`), + }); + private readonly translator = new KeyTranslator({ emit: (event) => this.router.handleKey(event) }); + + readonly bridge = new KeyboardBridge({ + send: (record) => { + const session = this.session; + if (!session) return false; + try { + return sendKeyboardControlRecord(session, record, `op=${record[3]}`); + } catch { + return false; + } + }, + loadSaved: loadSavedKeyboard, + storeSaved: (saved) => setStringSetting(SAVED_KEYBOARD_KEY, saved ? JSON.stringify(saved) : ""), + onKeys: (events) => this.translator.handle(events), + onKeyboardGone: () => { + this.translator.reset(); + this.router.reset(); + }, + onChanged: () => { + for (const listener of [...this.listeners]) listener(); + }, + // Pairing and setup are rare and are what a failure report needs, so + // they always reach the device log. Nothing here ever includes a key. + log: (line, routine) => { + if (routine) this.host?.log(line); + else console.log(`[keyboard] ${line}`); + }, + randomPasskey, + shouldReconnect: () => this.host?.shouldReconnect() ?? true, + }); + + setHost(host: KeyboardServiceHost): void { + this.host = host; + } + + snapshot(): KeyboardBridgeSnapshot { + return this.bridge.snapshot(); + } + + /** Called on every bridge state change. Returns an unsubscribe function. */ + subscribe(listener: () => void): () => void { + this.listeners.add(listener); + return () => this.listeners.delete(listener); + } + + /** The glasses came into use (the display woke): look for an absent keyboard now. */ + retryNow(): void { + this.bridge.retryNow(); + } + + /** A G2 session on firmware with the bridge is up. Idempotent. */ + linkReady(): void { + const session = keyboardLinkSession(); + if (!session) return; + if (session !== this.session) { + // The native session object is rebuilt across reconnects. + this.offEvents?.(); + this.session = session; + this.offEvents = addKeyboardEventListener(session, (body) => this.bridge.accept(body)); + } + this.bridge.linkReady(); + } + + /** + * The session can't host the keyboard any more. `release` asks the firmware + * to let the keyboard go first, for when the link itself stays up (the + * glasses went into their case, or the app is disconnecting on purpose). + * Idempotent. + */ + linkLost(release = false): void { + if (release) this.bridge.linkClosing(); + this.bridge.linkLost(); + this.offEvents?.(); + this.offEvents = null; + this.session = null; + } + + /** A key a worker's window was sent and had no use for (the "key-unhandled" reply). */ + handleUnhandledKey(event: KeyEvent): void { + this.router.handleUnhandledKey(event); + } + + // ---------- Custom keybindings ---------- + + /** The custom keybindings, in the order they were added. */ + keyBindings(): readonly KeyBinding[] { + return this.bindings; + } + + /** Bind a chord, replacing what it was bound to. False when the list is full. */ + setKeyBinding(chord: KeyChord, action: KeyAction): boolean { + const id = chordId(chord); + const index = this.bindings.findIndex((binding) => chordId(binding.chord) === id); + if (index < 0 && this.bindings.length >= MAX_KEY_BINDINGS) return false; + const next = [...this.bindings]; + if (index < 0) next.push({ chord, action }); + else next[index] = { chord, action }; + this.storeBindings(next); + return true; + } + + removeKeyBinding(chord: KeyChord): void { + const id = chordId(chord); + this.storeBindings(this.bindings.filter((binding) => chordId(binding.chord) !== id)); + } + + /** + * Take the next key pressed on the keyboard instead of acting on it. Returns + * a function that calls the capture off. + */ + captureNextKey(onChord: (chord: KeyChord) => void): () => void { + return this.router.captureNextKey(onChord); + } + + private storeBindings(bindings: KeyBinding[]): void { + this.bindings = bindings; + this.bindingMap = keyBindingMap(bindings); + setStringSetting(KEY_BINDINGS_KEY, serializeKeyBindings(bindings)); + } +} + +export const keyboardService = new KeyboardService(); diff --git a/app/g2/lock-screen.ts b/app/g2/lock-screen.ts index 485504bd..7f140eeb 100644 --- a/app/g2/lock-screen.ts +++ b/app/g2/lock-screen.ts @@ -1,23 +1,26 @@ -import { GrayImage, G2_LENS_WIDTH, G2_LENS_HEIGHT } from "../graphics/image"; +import { GrayImage } from "../graphics/image"; +import { screenHeight, screenWidth } from "../graphics/screen-size"; import { getDefaultMediumFont } from "../graphics/ui-fonts"; import { wrapText } from "../graphics/textwrap"; export const LOCK_SCREEN_SURFACE_ID = "lock-screen"; const LOCK_SCREEN_MESSAGE = "Glasses locked; unlock the phone to unlock the glasses."; +/** The paired glasses' whole screen, black, with the message in a box at its centre. */ export function createLockScreenImage(): GrayImage { - const image = new GrayImage(G2_LENS_WIDTH, G2_LENS_HEIGHT, 0); + const width = screenWidth(), height = screenHeight(); + const image = new GrayImage(width, height, 0); const font = getDefaultMediumFont(); const boxWidth = 480; const boxHeight = 150; - const boxX = Math.round((G2_LENS_WIDTH - boxWidth) / 2); - const boxY = Math.round((G2_LENS_HEIGHT - boxHeight) / 2); + const boxX = Math.round((width - boxWidth) / 2); + const boxY = Math.round((height - boxHeight) / 2); image.drawRoundedRect(boxX, boxY, boxWidth, boxHeight, 150, 12); const lines = wrapText(font, LOCK_SCREEN_MESSAGE, boxWidth - 64); const textHeight = lines.length * font.lineHeight; const firstY = boxY + Math.round((boxHeight - textHeight) / 2); lines.forEach((line, index) => { - const x = Math.round((G2_LENS_WIDTH - font.measureText(line)) / 2); + const x = Math.round((width - font.measureText(line)) / 2); image.drawText(font, x, firstY + index * font.lineHeight, line, 230); }); return image; diff --git a/app/g2/pairing-candidates.ts b/app/g2/pairing-candidates.ts index b891581a..f6c8a059 100644 --- a/app/g2/pairing-candidates.ts +++ b/app/g2/pairing-candidates.ts @@ -16,12 +16,11 @@ import { RING_CALIBRATION, sortedByProximity, zoneGlyph, - zoneLabel, type ProximityEstimate, type ProximityZone, } from "./ble-proximity"; -import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type RawAdvertisement } from "./even-advertisement"; -import { glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; +import { classifyAdvertisement, normalizeMacAddress, type EvenAdvertisement, type G1Firmware, type RawAdvertisement } from "./even-advertisement"; +import { GENERIC_G2_IMAGE_PATH, glassesImagePath, R1_IMAGE_PATH } from "./glasses-artwork"; import { colorwayDisplayName, colorwaySwatchHex, @@ -48,6 +47,8 @@ export type GlassesPairCandidate = { rssi: number | null; proximity: ProximityEstimate | null; lastSeenMs: number; + /** An Even G1 pair: the arms' firmware, the "lower" of the two (stock, then safe mode). Absent on a G2. */ + g1Firmware?: G1Firmware; /** * Set when this lone arm and a lone arm of the other side carry different * serials — the mixed-pair situation the serial check exists to name. @@ -56,6 +57,15 @@ export type GlassesPairCandidate = { mismatchWarning: string | null; }; +/** A RayNeo iO: one device, one address (no arms to join). */ +export type RayNeoCandidate = { + id: string; + advertisement: EvenAdvertisement; + rssi: number | null; + proximity: ProximityEstimate | null; + lastSeenMs: number; +}; + export type RingCandidate = { id: string; advertisement: EvenAdvertisement; @@ -176,9 +186,10 @@ export class DiscoveryAggregator { pairs(): GlassesPairCandidate[] { const groups = new Map(); for (const record of this.byAddress.values()) { - if (record.role === "ring") continue; + if (record.role === "ring" || record.role === "rayneo-io") continue; const canonical = serialKey(record.serial); - const key = canonical ? `serial:${canonical}` : `arm:${record.address}`; + const family = record.g1Firmware ? "g1:" : ""; + const key = canonical ? `${family}serial:${canonical}` : `arm:${record.address}`; const group = groups.get(key) ?? { left: null, right: null }; const slot = record.role === "left" ? "left" : "right"; const incumbent = group[slot]; @@ -199,7 +210,9 @@ export class DiscoveryAggregator { pairs.push({ id: serialKey(serial) ?? `arm:${any.address}`, serial, - identity: GlassesHardwareIdentity.decode(serial), + // Even's G2 serial scheme; a G1's says nothing to it. + identity: any.g1Firmware ? null : GlassesHardwareIdentity.decode(serial), + ...(any.g1Firmware ? { g1Firmware: g1PairFirmware(left, right) } : {}), left: left ? stripSmoothing(left) : null, right: right ? stripSmoothing(right) : null, completeness: left && right ? "complete" : left ? "left-only" : "right-only", @@ -225,6 +238,22 @@ export class DiscoveryAggregator { } /** Every R1 ring seen, closest first. */ + rayneos(): RayNeoCandidate[] { + const found: RayNeoCandidate[] = []; + for (const record of this.byAddress.values()) { + if (record.role !== "rayneo-io") continue; + const rssi = record.smoothedRssi != null ? Math.round(record.smoothedRssi) : null; + found.push({ + id: `rayneo:${record.address}`, + advertisement: stripSmoothing(record), + rssi, + proximity: estimateProximity(rssi, GLASSES_CALIBRATION), + lastSeenMs: record.seenAtMs, + }); + } + return sortedByProximity(found, (candidate) => candidate.proximity, (candidate) => candidate.id); + } + rings(): RingCandidate[] { const rings: RingCandidate[] = []; for (const record of this.byAddress.values()) { @@ -281,7 +310,7 @@ export function isPreviouslyPaired(name: string | null | undefined, pairedSerial export type PairingRowPresentation = { id: string; - kind: "glasses" | "ring"; + kind: "glasses" | "ring" | "rayneo-io"; /** "Even G2 B" / "Even R1" / fallback product name. */ modelTitle: string; /** The serial (glasses) or local name (ring). */ @@ -299,7 +328,6 @@ export type PairingRowPresentation = { isPreviouslyPaired: boolean; /** "Yours" / "Closest" / "". */ badge: string; - proximitySummary: string; proximityGlyph: string; zone: ProximityZone | null; /** "Left + right arms found", "Only the left arm has been seen", …; "" when there is nothing worth a line (an unbonded ring). */ @@ -325,12 +353,11 @@ function presentationBase( isNearest: boolean, isPaired: boolean, warnings: readonly string[], -): Pick { +): Pick { return { isNearest, isPreviouslyPaired: isPaired, badge: isPaired ? "Yours" : isNearest ? "Closest" : "", - proximitySummary: proximity ? zoneLabel(proximity.zone) : "Signal unknown", proximityGlyph: proximity ? zoneGlyph(proximity.zone) : "○○○○", zone: proximity?.zone ?? null, warning: warnings.join(" "), @@ -342,7 +369,52 @@ function embeddedMacMismatchWarning(subject: string, ad: EvenAdvertisement | nul return `${subject} advertised address ${ad.embeddedMac} differs from its radio address ${ad.address}.`; } +/** The pair can only do what its less capable arm can. */ +function g1PairFirmware(left: EvenAdvertisement | null, right: EvenAdvertisement | null): G1Firmware { + const firmwares = [left?.g1Firmware, right?.g1Firmware]; + if (firmwares.includes("stock")) return "stock"; + return firmwares.includes("g1v0-safe") ? "g1v0-safe" : "g1v0"; +} + +export function g1Row(pair: GlassesPairCandidate, context: RowContext = {}): PairingRowPresentation { + const isPreviouslyPairedRow = isPreviouslyPaired(pair.serial, context.pairedSerial); + const isNearest = !!context.nearestId && context.nearestId === pair.id; + const warnings: string[] = []; + if (pair.mismatchWarning) warnings.push(pair.mismatchWarning); + let armsSummary: string; + let canSelect = false; + if (pair.completeness !== "complete") { + armsSummary = pair.completeness === "left-only" + ? "Only the left arm has been seen — waiting for the right" + : "Only the right arm has been seen — waiting for the left"; + } else if (pair.g1Firmware === "stock") { + armsSummary = "Runs Even's firmware. Faceclaw will install its own, with the glasses in the case"; + canSelect = true; + } else if (pair.g1Firmware === "g1v0-safe") { + armsSummary = "In safe mode: the firmware restarted repeatedly. Faceclaw can install it again, with the glasses in the case"; + canSelect = true; + } else { + armsSummary = "Left + right arms found. To pair, keep them in the case with the lid open"; + canSelect = true; + } + return { + id: pair.id, + kind: "glasses", + modelTitle: "Even Realities G1", + deviceName: pair.serial ?? (pair.left ?? pair.right)!.name, + variantSummary: null, + colorway: null, + swatchHex: null, + imagePath: GENERIC_G2_IMAGE_PATH, + hasVariantImage: false, + ...presentationBase(pair.proximity, isNearest, isPreviouslyPairedRow, warnings), + armsSummary, + canSelect, + }; +} + export function glassesRow(pair: GlassesPairCandidate, context: RowContext = {}): PairingRowPresentation { + if (pair.g1Firmware) return g1Row(pair, context); const identity = pair.identity; const imagePath = glassesImagePath(identity); const isPreviouslyPairedRow = isPreviouslyPaired(pair.serial, context.pairedSerial); @@ -416,6 +488,28 @@ export function ringRow(ring: RingCandidate, context: RowContext = {}): PairingR }; } +export function rayneoRow(candidate: RayNeoCandidate, context: { pairedAddress?: string; nearestId?: string | null } = {}): PairingRowPresentation { + const ad = candidate.advertisement; + const isPaired = !!context.pairedAddress && normalizeMacAddress(context.pairedAddress) === ad.address; + const isNearest = !!context.nearestId && context.nearestId === candidate.id; + const warnings: string[] = []; + if (ad.embeddedMacMismatch) warnings.push(`It advertises ${ad.embeddedMac} but was heard as ${ad.address}.`); + return { + id: candidate.id, + kind: "rayneo-io", + modelTitle: "RayNeo iO", + deviceName: ad.name || ad.address, + variantSummary: null, + colorway: null, + swatchHex: null, + imagePath: GENERIC_G2_IMAGE_PATH, + hasVariantImage: false, + ...presentationBase(candidate.proximity, isNearest, isPaired, warnings), + armsSummary: "Needs the Faceclaw custom firmware. First time: put it in pairing mode (on the charger, hold the button ~5 s until the light blinks blue).", + canSelect: true, + }; +} + /** Convenience: a colourway's display text, for rows that show the swatch alone. */ export function colorwayLabel(colorway: GlassesColorway | null): string { return colorway ? colorwayDisplayName(colorway) : ""; diff --git a/app/g2/phone-preview-crop.ts b/app/g2/phone-preview-crop.ts index 2eafaa51..b0138414 100644 --- a/app/g2/phone-preview-crop.ts +++ b/app/g2/phone-preview-crop.ts @@ -1,6 +1,5 @@ -import { G2_LENS_HEIGHT, G2_LENS_WIDTH } from "../graphics/image"; import { previewScalingSetting } from "../ui/dashboard-settings"; -import { phonePreviewRect, usedScreenRect, type ScreenRect } from "../ui/shell/geometry"; +import { phonePreviewRect, screenHeight, screenWidth, usedScreenRect, type ScreenRect } from "../ui/shell/geometry"; import { shell } from "../ui/shell/shell"; /** @@ -14,7 +13,7 @@ export function phonePreviewCrop(locked: boolean, glanceRect: ScreenRect | null) if (locked || previewScalingSetting.get() === "raw") return null; const window = shell.foregroundWindow(); const crop = phonePreviewRect(glanceRect ?? usedScreenRect(window?.heightMode ?? "min", window?.appId)); - const wholePanel = crop.x === 0 && crop.y === 0 && crop.width === G2_LENS_WIDTH && crop.height === G2_LENS_HEIGHT; + const wholePanel = crop.x === 0 && crop.y === 0 && crop.width === screenWidth() && crop.height === screenHeight(); return wholePanel ? null : crop; } @@ -27,7 +26,7 @@ export function phonePreviewCrop(locked: boolean, glanceRect: ScreenRect | null) export function mirrorToPanelFraction(crop: ScreenRect | null, nx: number, ny: number): { nx: number; ny: number } { if (!crop) return { nx, ny }; return { - nx: (crop.x + nx * crop.width) / G2_LENS_WIDTH, - ny: (crop.y + ny * crop.height) / G2_LENS_HEIGHT, + nx: (crop.x + nx * crop.width) / screenWidth(), + ny: (crop.y + ny * crop.height) / screenHeight(), }; } diff --git a/app/g2/wear-remote.ts b/app/g2/wear-remote.ts index 92a62902..07571947 100644 --- a/app/g2/wear-remote.ts +++ b/app/g2/wear-remote.ts @@ -1,5 +1,6 @@ /** - * The Wear OS watch as an input device and status mirror for the glasses. + * The watch (Wear OS or Apple 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 @@ -17,22 +18,28 @@ * 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. The level lives in shell.getBatteryLevels() - * beside the G2 and R1 ones and is cleared when no watch is reachable. + * 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. * - * Transport is app/native/wear-bridge.ts (Java FaceclawWearBridge); the - * message shapes are documented in wear/PROTOCOL.md. + * Transport is app/native/wear-bridge.ts (Java FaceclawWearBridge) or + * wear-bridge.ios.ts (FaceclawWatchBridge); the message shapes are documented + * in wear/PROTOCOL.md. */ import { flagAnalyticsEvent } from "../analytics/analytics"; import { type AppDefinition } from "../apps/app-definition"; import { getInstalledEvenHubApps, installedEvenHubAppId } from "../apps/evenhub/installed-apps"; import { WEAR_PATHS, wearBridge, type WearMessage } from "../native/wear-bridge"; import { + glassesModelName, onAnySettingChanged, watchCanUnlockSetting, watchCrownClockwiseNextSetting, watchMirrorAssistantSetting, watchRemoteEnabledSetting, + watchSoundEffectsSetting, + watchVibrateOnInputSetting, } from "../ui/dashboard-settings"; import { shell, type AssistantActivityEvent } from "../ui/shell/shell"; import { voiceActivity } from "../ui/shell/voice-activity"; @@ -102,17 +109,26 @@ 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 = { - /** The launcher-grid apps; installed EvenHub packages are added dynamically. */ - apps: readonly AppDefinition[]; + /** The launcher-grid apps for the paired glasses; installed EvenHub packages are added dynamically. */ + apps: () => readonly AppDefinition[]; injectInput: (kind: WearRemoteInputKind) => Promise; launchApp: (appId: string) => Promise; connect: () => Promise; disconnect: () => Promise; 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; @@ -136,6 +152,7 @@ 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; @@ -143,7 +160,7 @@ export class WearRemote { constructor(private readonly host: WearRemoteHost) { this.active = wearBridge.isAvailable(); if (!this.active) { - host.appendLog("watch: Google Play services unavailable; watch remote disabled"); + host.appendLog(`watch: ${global.isIOS ? "WatchConnectivity" : "Google Play services"} unavailable; watch remote disabled`); return; } wearBridge.onMessage((message) => { @@ -183,10 +200,25 @@ 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.pollWatchBattery(false), WATCH_BATTERY_POLL_INTERVAL_MS); + setInterval(() => { + this.expireWatchBattery(); + 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 @@ -257,11 +289,13 @@ 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, listening: voiceActivity.isActive(), battery: state.lastHeadsetBattery, + glassesModel: glassesModelName(), charging: state.phase === "charging" || battery.headsetCharging === true, caseBattery: battery.case, caseCharging: battery.caseCharging, @@ -278,6 +312,8 @@ 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(), @@ -286,7 +322,7 @@ export class WearRemote { /** Launchable apps, matching the launcher grid and the apps.launch tool. */ private listApps(): Array<{ appId: string; title: string }> { - const apps = this.host.apps.map((app) => ({ appId: app.appId, title: app.title })); + const apps = this.host.apps().map((app) => ({ appId: app.appId, title: app.title })); for (const installed of getInstalledEvenHubApps()) { apps.push({ appId: installedEvenHubAppId(installed.packageId), title: installed.name }); } @@ -307,7 +343,11 @@ export class WearRemote { // acked (the watch sends it fire-and-forget, without a seq). this.watchBatteryPollsUnanswered = 0; const battery = readNumber(message.payload.battery, -1); - const valid = Number.isInteger(battery) && battery >= 0 && battery <= 100; + // 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; this.setWatchBattery(valid ? battery : null, valid ? message.payload.charging === true : null); return; } @@ -315,8 +355,7 @@ 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. - const phase = this.host.getState().phase; - if (watchRemoteEnabledSetting.get() && (phase === "connected" || phase === "charging")) { + if (watchRemoteEnabledSetting.get() && this.takesInput()) { await this.host.injectInput("ring-press"); } return; @@ -378,8 +417,7 @@ export class WearRemote { return; } const kind = gesture as WearRemoteInputKind; - const state = this.host.getState(); - if (state.phase !== "connected" && state.phase !== "charging") { + if (!this.takesInput()) { ack(false, "The glasses are not connected."); return; } @@ -422,7 +460,7 @@ export class WearRemote { default: break; } - if (!connected) { + if (!this.takesInput()) { ack(false, "The glasses are not connected."); return; } @@ -561,6 +599,8 @@ 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; } diff --git a/app/graphics/evenhub-font.ts b/app/graphics/evenhub-font.ts index d80ca2bd..bd612844 100644 --- a/app/graphics/evenhub-font.ts +++ b/app/graphics/evenhub-font.ts @@ -12,7 +12,8 @@ * - Text SIZING / KERNING / WRAPPING: @evenrealities/pretext, whose advance * tables the bitmaps were validated against. Using pretext for measurement * means our line breaks match exactly where EvenHub apps (which measure - * with the same library) expect them. + * with the same library) expect them. The one exception is leading spaces + * after a '\n', which stock keeps and pretext drops (see lvgl-wrap.ts). * * Bitmaps are 4bpp, high-nibble-first, row stride floor(boxW/2)+1. The UI * fonts are effectively 1-bit (nibbles 0 or 0xF); we keep the nibble value so @@ -23,6 +24,7 @@ import { File, knownFolders } from "@nativescript/core"; import { getTextWidth } from "@evenrealities/pretext"; import { EVENHUB_RUNTIME_FONT_FILENAME, isEvenHubFontAsset } from "../g2/firmware-fonts"; import { lvglMetrics, lvglGlyph } from "../native/lvgl-font"; +import { wrapLvglText } from "./lvgl-wrap"; import { GrayImage, grayToNibble, type FwTextFont, type PlacedFwText, type PlacedFwTextGlyph } from "./image"; import { TtfFont } from "./ttf-font"; import { decodeBase64 } from "../util/base64"; @@ -200,63 +202,11 @@ export class EvenHubFont implements FwTextFont { } /** - * Wrap text to a pixel width, returning the actual line strings. Ports - * pretext's measureTextWrap (LVGL lv_text_get_next_line semantics) so the - * breaks land exactly where the measurement library reports them. + * Wrap text to a pixel width, returning the actual line strings: pretext's + * breaks, but keeping leading spaces after a '\n' (see lvgl-wrap.ts). */ wrap(text: string, maxWidth: number): string[] { - if (!text) return [""]; - const cps = Array.from(text).map((c) => c.codePointAt(0)!); - const lines: string[] = []; - let line: number[] = []; - let lineWidth = 0; - let lastBreak = -1; // index within `line` after which we may wrap - - for (let i = 0; i < cps.length; i++) { - const cp = cps[i]!; - if (cp === 10) { - lines.push(String.fromCodePoint(...line)); - line = []; - lineWidth = 0; - lastBreak = -1; - continue; - } - // LVGL drops leading spaces at the start of a wrapped line. - if (line.length === 0 && cp === 32) continue; - const adv = this.advanceOf(cp, cps[i + 1] ?? 0); - if (lineWidth + adv > maxWidth) { - if (cp === 32) { - // The overflowing char is a space: break here, discard it. - lines.push(String.fromCodePoint(...line)); - line = []; - lineWidth = 0; - lastBreak = -1; - } else if (lastBreak !== -1) { - // Wrap at the last break opportunity; carry the remainder forward. - const carry = line.slice(lastBreak + 1); - line = line.slice(0, lastBreak + 1); - const trimmed = line[line.length - 1] === 32 ? line.slice(0, -1) : line; - lines.push(String.fromCodePoint(...trimmed)); - line = carry; - lineWidth = carry.reduce((sum, c, j) => sum + this.advanceOf(c, carry[j + 1] ?? 0), 0); - lastBreak = -1; - line.push(cp); - lineWidth += adv; - } else { - // No break opportunity: hard break before the overflowing char. - lines.push(String.fromCodePoint(...line)); - line = [cp]; - lineWidth = adv; - lastBreak = -1; - } - } else { - line.push(cp); - lineWidth += adv; - if (isBreakable(cp)) lastBreak = line.length - 1; - } - } - lines.push(String.fromCodePoint(...line)); - return lines; + return wrapLvglText(text, maxWidth, kernedAdvance); } /** @@ -446,8 +396,3 @@ export class EvenHubFont implements FwTextFont { } } -function isBreakable(cp: number): boolean { - if (cp === 32 || cp === 45) return true; // space, hyphen - // CJK ranges (pretext parity) — breakable between any two ideographs. - return (cp >= 0x2e80 && cp <= 0x9fff) || (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xac00 && cp <= 0xd7af); -} diff --git a/app/graphics/image.ts b/app/graphics/image.ts index f36a0dd7..ea4c69a2 100644 --- a/app/graphics/image.ts +++ b/app/graphics/image.ts @@ -4,8 +4,14 @@ import type { MenuHighlightAnimation } from "../ui/menu-highlight-motion"; import { Glyph } from "./bdffont"; import { wrapText } from "./textwrap"; +// This file is also built by tests/tsconfig.json, which has no DOM or Node types. +declare const console: { warn(message: string): void }; + export const G2_LENS_WIDTH = 640; export const G2_LENS_HEIGHT = 480; +/** RayNeo iO screen (per eye) with the Faceclaw firmware: 540x220. */ +export const RAYNEO_IO_WIDTH = 540; +export const RAYNEO_IO_HEIGHT = 220; const DEFAULT_CORNER_RADIUS = 8; /** @@ -156,9 +162,15 @@ export class GrayImage { private memoizedSourceHash: number | null = null; constructor(width: number, height: number, fill = 0) { - this.width = width; - this.height = height; - this.pixels = new Uint8Array(width * height); + // A fractional width would put most rows' `y * width + x` between pixels, + // silently losing them. TTF text measures fractionally, so this is easy to + // hit; the stack is there because the size alone doesn't identify the caller. + if (!Number.isInteger(width) || !Number.isInteger(height)) { + console.warn(`GrayImage: rounding up non-integer size ${width}x${height}\n${new Error().stack}`); + } + this.width = Math.ceil(width); + this.height = Math.ceil(height); + this.pixels = new Uint8Array(this.width * this.height); if (fill !== 0) { this.clear(fill); } @@ -584,6 +596,25 @@ export class GrayImage { } } + /** + * bakeDeferredDrawsInPlace, but only for the draws whose ink may fall inside + * `rect`; the rest stay deferred. For covering part of the image with later + * raster (the EvenHub compositor painting an image container over text) + * without giving up the deferred wire path for everything else. + */ + bakeDeferredDrawsWithin(rect: { x: number; y: number; width: number; height: number }): void { + if (!this.drawList.length) return; + const covered = (b: { x: number; y: number; width: number; height: number } | null) => + !b || (b.x < rect.x + rect.width && rect.x < b.x + b.width && b.y < rect.y + rect.height && rect.y < b.y + b.height); + const bake: DeferredDraw[] = []; + const keep: DeferredDraw[] = []; + for (const placed of this.drawList) (covered(placedDrawBounds(placed)) ? bake : keep).push(placed); + if (!bake.length) return; + this.drawList.splice(0, this.drawList.length, ...bake); + this.bakeDeferredDrawsInPlace(); + this.drawList.push(...keep); + } + /** * A copy of this image with its brightness scaled by `factor` (0..1): * raster and glyph / firmware-text draws alike, keeping the draws deferred @@ -693,6 +724,35 @@ export function grayToNibble(value: number): number { /** Where rasterizeGlyph writes: an image, or a clipped buffer (paintReplayDraws). */ type PixelSink = { setPixel(x: number, y: number, value: number): void }; +/** A deferred draw's ink rectangle, or null when it can't be bounded (treat as anywhere). */ +function placedDrawBounds(placed: DeferredDraw): { x: number; y: number; width: number; height: number } | null { + if (placed.kind === "glyph") { + const { glyph } = placed; + return { + x: placed.x + glyph.bbxX, + y: placed.y + placed.font.ascent - (glyph.bbxHeight + glyph.bbxY), + width: glyph.bbxWidth, + height: glyph.bbxHeight, + }; + } + if (placed.kind === "image") { + return placed.presentation ? null : { x: placed.x, y: placed.y, width: placed.source.width, height: placed.source.height }; + } + let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity; + for (const member of placed.glyphs) { + if (!member.ink) continue; + const wire = placed.font.fwGlyphWireData(member.cp); + if (!wire) return null; + const x = placed.x + member.dx + wire.ofsX; + const y = placed.y + wire.inkTop; + left = Math.min(left, x); + top = Math.min(top, y); + right = Math.max(right, x + wire.boxW); + bottom = Math.max(bottom, y + wire.boxH); + } + return right < left ? { x: placed.x, y: placed.y, width: 0, height: 0 } : { x: left, y: top, width: right - left, height: bottom - top }; +} + /** Bake one glyph into an image's pixel buffer (y is the top of the line). */ function rasterizeGlyph( target: PixelSink, diff --git a/app/graphics/lvgl-wrap.ts b/app/graphics/lvgl-wrap.ts new file mode 100644 index 00000000..b4626dde --- /dev/null +++ b/app/graphics/lvgl-wrap.ts @@ -0,0 +1,76 @@ +/** + * Word wrap for EvenHub text containers, matching the stock firmware's LVGL + * labels as measured by running firmware 2.2.9.22 in the g2-firmware-emulator: + * + * - Spaces are kept wherever they fall: at the start of the text, after a + * '\n', and on soft-wrapped lines. A space that doesn't fit at the end of a + * line starts the next one, so "HHHHHHHH EEEE" in 100px (8 H = 96px, + * 5px spaces) wraps with all four spaces indenting the second line. + * - A line otherwise breaks after its last space, hyphen or CJK ideograph, + * or, with none, before the character that overflows. + * + * @evenrealities/pretext's measureTextWrap, which apps measure with, differs + * in one way: it drops spaces at the start of every line. Apps rely on stock's + * behavior, though: Iris Pro indents a line 11 spaces past a 40px glyph placed + * beside it, and stripping the indent slid the text under the icon. + */ + +/** Wrap opportunities: space, hyphen, and between CJK ideographs. */ +export function isLvglBreakable(cp: number): boolean { + if (cp === 32 || cp === 45) return true; + return (cp >= 0x2e80 && cp <= 0x9fff) || (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xac00 && cp <= 0xd7af); +} + +/** + * Split text into display lines no wider than maxWidth. + * `advanceOf(cp, next)` is the kerned pixel advance of cp before next (0 at the end). + */ +export function wrapLvglText(text: string, maxWidth: number, advanceOf: (cp: number, next: number) => number): string[] { + if (!text) return [""]; + const cps = Array.from(text).map((c) => c.codePointAt(0)!); + const lines: string[] = []; + let line: number[] = []; + let lineWidth = 0; + // The last break opportunity on this line, as an index into cps, and how + // many of `line`'s codepoints end at it. + let lastBreak = -1; + let lastBreakKeep = 0; + + const endLine = (keep: number[]) => { + lines.push(String.fromCodePoint(...keep)); + line = []; + lineWidth = 0; + lastBreak = -1; + }; + + let i = 0; + while (i < cps.length) { + const cp = cps[i]!; + if (cp === 10) { + endLine(line); + i++; + continue; + } + const adv = advanceOf(cp, cps[i + 1] ?? 0); + if (lineWidth + adv <= maxWidth || line.length === 0) { + // A character wider than the whole line still takes one to itself. + line.push(cp); + lineWidth += adv; + if (isLvglBreakable(cp)) { + lastBreak = i; + lastBreakKeep = line.length; + } + i++; + } else if (cp !== 32 && lastBreak !== -1) { + // Wrap after the last break opportunity and rescan from there. + const restart = lastBreak + 1; + endLine(line.slice(0, lastBreakKeep)); + i = restart; + } else { + // An overflowing space, or no break opportunity: this character starts the next line. + endLine(line); + } + } + lines.push(String.fromCodePoint(...line)); + return lines; +} diff --git a/app/graphics/screen-size.ts b/app/graphics/screen-size.ts new file mode 100644 index 00000000..c5d7621f --- /dev/null +++ b/app/graphics/screen-size.ts @@ -0,0 +1,27 @@ +/** + * The paired glasses' screen (per eye), which the shell and UI lay out in: + * the G2's 640x480, or the RayNeo iO's 540x220 with the Faceclaw firmware. + * + * Read straight from the settings store (the key dashboard-settings.ts's + * glassesTypeSetting writes), so this stays a leaf that UI primitives can + * import without pulling in the settings module, and every isolate (the + * main one, app workers, the phone preview) agrees with the session. + */ +import { getStringSetting } from "../native/settings-store"; +import { G2_LENS_HEIGHT, G2_LENS_WIDTH, RAYNEO_IO_HEIGHT, RAYNEO_IO_WIDTH } from "./image"; + +/** Settings key of the paired glasses' type: "g2" (default) or "rayneo-io". */ +export const GLASSES_TYPE_KEY = "deviceType"; + +/** Whether the paired glasses are a RayNeo iO. */ +export function isRayNeoIoConfigured(): boolean { + return getStringSetting(GLASSES_TYPE_KEY, "g2") === "rayneo-io"; +} + +export function screenWidth(): number { + return isRayNeoIoConfigured() ? RAYNEO_IO_WIDTH : G2_LENS_WIDTH; +} + +export function screenHeight(): number { + return isRayNeoIoConfigured() ? RAYNEO_IO_HEIGHT : G2_LENS_HEIGHT; +} diff --git a/app/graphics/ui-fonts.ts b/app/graphics/ui-fonts.ts index bcf5e786..62f4b3e3 100644 --- a/app/graphics/ui-fonts.ts +++ b/app/graphics/ui-fonts.ts @@ -13,6 +13,7 @@ import type { UiFont } from "./image"; import { TtfFont } from "./ttf-font"; import { ensurePreinstalledFonts, getInstalledFont, installedFontPath } from "./installed-fonts"; import { getStringSetting, onSettingsStoreChanged, setStringSetting } from "../native/settings-store"; +import { GLASSES_TYPE_KEY, isRayNeoIoConfigured } from "./screen-size"; export type BitmapFace = "terminus" | "terminusv"; @@ -72,8 +73,18 @@ export function parseFontSelection(raw: string): UiFontSelection | null { return null; } -/** Default UI font when the user has never picked one. */ -const DEFAULT_UI_FONT: UiFontSelection = { kind: "ttf", file: "Roboto-Light.ttf", size: 16 }; +/** + * The default UI font's size, which onboarding recommends: 16, or 14 on the + * RayNeo iO, whose 540x220 screen fits fewer rows. + */ +export function defaultUiFontSize(): number { + return isRayNeoIoConfigured() ? 14 : 16; +} + +/** Default UI font when the user has never picked one: Roboto Light at the default size. */ +function defaultUiFont(): UiFontSelection { + return { kind: "ttf", file: "Roboto-Light.ttf", size: defaultUiFontSize() }; +} export function getUiFontSelection(): UiFontSelection { const parsed = parseFontSelection(getStringSetting(UI_FONT_SELECTION_KEY, "")); @@ -84,7 +95,7 @@ export function getUiFontSelection(): UiFontSelection { if (legacy === "terminus" || legacy === "terminusv") { return { kind: "bitmap", face: legacy }; } - return DEFAULT_UI_FONT; + return defaultUiFont(); } export function setUiFontSelection(selection: UiFontSelection): void { @@ -113,7 +124,8 @@ export function fontSelectionLabel(selection: UiFontSelection): string { type UiFontRole = "small" | "medium" | "large"; -const UI_FONT_KEYS: readonly string[] = [UI_FONT_SELECTION_KEY, LEGACY_UI_FONT_KEY]; +/** Keys whose change re-resolves the UI fonts (the glasses type picks the default size). */ +const UI_FONT_KEYS: readonly string[] = [UI_FONT_SELECTION_KEY, LEGACY_UI_FONT_KEY, GLASSES_TYPE_KEY]; /** * The three role fonts for one selection source, resolved lazily and cached diff --git a/app/health/health-glance.ts b/app/health/health-glance.ts index 7b690331..337b7888 100644 --- a/app/health/health-glance.ts +++ b/app/health/health-glance.ts @@ -23,6 +23,7 @@ import { GrayImage, type UiFont } from "../graphics/image"; import { lineStep } from "../ui/metrics"; import { GESTURE_SCROLL } from "../ui/gestures"; +import type { Edges } from "../ui/viewport"; import { drawSleepLanes, drawMetricChart, @@ -47,10 +48,11 @@ import { } from "./health-types"; import { stageLabel, type SleepStageName } from "./sleep-stages"; -const MARGIN = 10; const GUTTER = 14; -/** Below this the two columns stack instead. */ -const TWO_COLUMN_MIN_WIDTH = 380; +/** Below this content width the two columns stack instead. */ +const TWO_COLUMN_MIN_WIDTH = 360; +/** Clear space between a page's content and its footer hint. */ +const FOOTER_GAP = 16; export type GlanceFonts = { small: UiFont; large: UiFont }; @@ -108,7 +110,30 @@ export type GlanceData = { fixture: boolean; }; -export type GlanceSize = { width: number; height: number }; +/** + * The window a page is painted for: its size, and the padding suggested for + * each of its edges (`ui/viewport.ts`), which is how far in the page's + * outermost content sits. A size with no padding is a window nothing borders. + */ +export type GlanceSize = { width: number; height: number; padding?: Edges }; + +/** The rect a page lays out in: the window inside its edge padding. */ +type Frame = { left: number; top: number; right: number; bottom: number }; + +function frameOf(size: GlanceSize): Frame { + const { padding } = size; + return { + left: padding?.left ?? 0, + top: padding?.top ?? 0, + right: size.width - (padding?.right ?? 0), + bottom: size.height - (padding?.bottom ?? 0), + }; +} + +/** Height the footer hint takes off the bottom of a page's content: its line and the gap above it. */ +function footerHeight(fonts: GlanceFonts): number { + return fonts.small.lineHeight + FOOTER_GAP; +} /** Paint whichever page the cursor is on. */ export function drawGlancePage( @@ -165,10 +190,11 @@ function drawHeader( right: string, ): number { const { small } = fonts; - image.drawText(small, MARGIN, MARGIN, title, INK.title); - drawTextRight(image, small, size.width - MARGIN, MARGIN, right, INK.label); - const bottom = MARGIN + small.lineHeight + 3; - image.drawLine(MARGIN, bottom, size.width - MARGIN, bottom, INK.axis); + const frame = frameOf(size); + image.drawText(small, frame.left, frame.top, title, INK.title); + drawTextRight(image, small, frame.right, frame.top, right, INK.label); + const bottom = frame.top + small.lineHeight + 3; + image.drawLine(frame.left, bottom, frame.right - 1, bottom, INK.axis); return bottom; } @@ -186,8 +212,8 @@ function drawFooter( hint: string, ): void { const { small } = fonts; - const y = size.height - small.lineHeight - 2; - image.drawText(small, MARGIN, y, hint, INK.faint); + const frame = frameOf(size); + image.drawText(small, frame.left, frame.bottom - small.lineHeight, hint, INK.faint); } // =========================================================================== @@ -220,24 +246,24 @@ function drawOverview( ): void { const { small, large } = fonts; const step = lineStep(small); + const frame = frameOf(size); const headerBottom = drawHeader(image, size, fonts, "HEALTH", shortDate(data.nowMs)); const summary = data.summary; if (!summary) { - image.drawText(small, MARGIN, headerBottom + step, "Waiting for ring data...", INK.dim); + image.drawText(small, frame.left, headerBottom + step, "Waiting for ring data...", INK.dim); drawFooter(image, size, fonts, ""); return; } - const twoColumn = size.width >= TWO_COLUMN_MIN_WIDTH; - const columnWidth = twoColumn - ? Math.floor((size.width - MARGIN * 2 - GUTTER) / 2) - : size.width - MARGIN * 2; - const rightX = twoColumn ? MARGIN + columnWidth + GUTTER : MARGIN; + const contentWidth = frame.right - frame.left; + const twoColumn = contentWidth >= TWO_COLUMN_MIN_WIDTH; + const columnWidth = twoColumn ? Math.floor((contentWidth - GUTTER) / 2) : contentWidth; + const rightX = twoColumn ? frame.left + columnWidth + GUTTER : frame.left; const top = headerBottom + 6; const todayBottom = drawTodayColumn(image, summary, { - x: MARGIN, + x: frame.left, y: top, width: columnWidth, fonts, @@ -259,7 +285,7 @@ function drawOverview( // artefact instead of as structure. It also matters more than it looks: on // the glasses an unlit pixel is TRANSPARENT, so every line drawn past the // content is one more thing between the wearer and the world. - const divider = MARGIN + columnWidth + Math.floor(GUTTER / 2); + const divider = frame.left + columnWidth + Math.floor(GUTTER / 2); image.drawLine(divider, top, divider, Math.max(todayBottom, nightBottom), INK.faint); } @@ -371,6 +397,7 @@ function drawMetricDetail( ): void { const { small, large } = fonts; const step = lineStep(small); + const frame = frameOf(size); const headerBottom = drawHeader( image, size, @@ -388,12 +415,12 @@ function drawMetricDetail( // headline is the day's total rather than a range. const total = metric === "steps" ? data.summary?.steps ?? 0 : data.summary?.calories ?? 0; const text = total > 0 ? total.toLocaleString() : "--"; - image.drawText(large, MARGIN, y, text, INK.title); + image.drawText(large, frame.left, y, text, INK.title); const width = large.measureText(text); if (unit) { image.drawText( small, - MARGIN + width + 6, + frame.left + width + 6, y + large.lineHeight - small.lineHeight - 1, unit, INK.label, @@ -401,17 +428,16 @@ function drawMetricDetail( } y += large.lineHeight + 6; } else { - image.drawText(small, MARGIN, y, rangeAverageText(summary, unit), INK.line); + image.drawText(small, frame.left, y, rangeAverageText(summary, unit), INK.line); y += step + 4; } const points = data.hourly[metric] ?? []; - const footerHeight = small.lineHeight + 8; - const chartHeight = size.height - y - MARGIN - footerHeight; + const chartHeight = frame.bottom - footerHeight(fonts) - y; if (chartHeight >= 40) { drawMetricChart( image, - { x: MARGIN, y, width: size.width - MARGIN * 2, height: chartHeight }, + { x: frame.left, y, width: frame.right - frame.left, height: chartHeight }, { metric, points, @@ -482,35 +508,35 @@ function drawSleepDetail( const { small, large } = fonts; const step = lineStep(small); const sleep = data.summary?.sleep ?? null; + const frame = frameOf(size); const headerBottom = drawHeader(image, size, fonts, "SLEEP", "last night"); let y = headerBottom + 6; if (!sleep) { - image.drawText(small, MARGIN, y, "No sleep record", INK.dim); + image.drawText(small, frame.left, y, "No sleep record", INK.dim); drawFooter(image, size, fonts, `${GESTURE_SCROLL} Calories · Summary`); return; } // Total and efficiency on one line, so the lanes get the height. const totalText = formatDuration(sleep.totalSec); - image.drawText(large, MARGIN, y, totalText, INK.title); + image.drawText(large, frame.left, y, totalText, INK.title); drawTextRight( image, small, - size.width - MARGIN, + frame.right, y + large.lineHeight - small.lineHeight - 1, `${Math.round(sleep.efficiencyPercent)}% efficiency`, INK.label, ); y += large.lineHeight + 6; - const footerHeight = small.lineHeight + 8; const captionHeight = step; - const laneHeight = size.height - y - MARGIN - footerHeight - captionHeight; + const laneHeight = frame.bottom - footerHeight(fonts) - captionHeight - y; if (laneHeight >= 40) { drawSleepLanes( image, - { x: MARGIN, y, width: size.width - MARGIN * 2, height: laneHeight }, + { x: frame.left, y, width: frame.right - frame.left, height: laneHeight }, { bands: data.stageBands, font: small, @@ -523,6 +549,6 @@ function drawSleepDetail( y += laneHeight; } - image.drawText(small, MARGIN, y, hypnogramCaptionShort(), INK.faint); + image.drawText(small, frame.left, y, hypnogramCaptionShort(), INK.faint); drawFooter(image, size, fonts, `${GESTURE_SCROLL} Calories · Summary`); } diff --git a/app/native/faceclaw-communicator.ios.ts b/app/native/faceclaw-communicator.ios.ts index ea6fd304..6baba51a 100644 --- a/app/native/faceclaw-communicator.ios.ts +++ b/app/native/faceclaw-communicator.ios.ts @@ -1,3 +1,4 @@ +import type { GlassesType } from "../ui/dashboard-settings"; import type { RingInput } from "../g2/ring-input"; import { File, knownFolders, path, type ImageSource } from "@nativescript/core"; import { REQUIRED_FACECLAW_FIRMWARE_VERSION, type FirmwareInfo } from "../g2/firmware-compat"; @@ -18,6 +19,7 @@ declare const FaceclawKitFaceclawCompassListener: any; declare const FaceclawKitFaceclawImuListener: any; declare const FaceclawKitIosAmbientLightListener: any; declare const FaceclawKitIosMicStatusListener: any; +declare const FaceclawKitIosKeyboardEventListener: any; export type CommunicatorPhase = @@ -197,6 +199,13 @@ class MicStatusListener extends NSObject { onNsDataMicStatusBodyArm(body: NSData, arm: string): void { this.handler(fromData(body), String(arm ?? "")); } } +@NativeClass() +class KeyboardEventListener extends NSObject { + static ObjCProtocols = [FaceclawKitIosKeyboardEventListener]; + handler!: (body: Uint8Array) => void; + onNsDataKeyboardEventBody(body: NSData): void { this.handler(fromData(body)); } +} + /** * The iOS twin of the Android communicator bridge: the same public API over * the shared Kotlin session (FaceclawKitIosGlassesSession, CoreBluetooth @@ -248,7 +257,10 @@ export class FaceclawCommunicatorBridge { return FaceclawCommunicatorBridge.active; } - constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string; glassesType?: GlassesType }) { + if (addresses.glassesType === "rayneo-io") { + throw new Error("RayNeo iO glasses are not supported on iOS yet."); + } this.communicator = FaceclawKitIosGlassesSession.alloc().initWithRightAddressLeftAddressRingAddress( String(addresses.right ?? "").toUpperCase(), String(addresses.left ?? "").toUpperCase(), @@ -256,6 +268,7 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevisionRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + if (addresses.glassesType === "g1") this.communicator.useG1(); // Guarded: an older framework build may not export it yet. if (addresses.ringRole && typeof this.communicator.setDirectRingRoleRole === "function") { this.communicator.setDirectRingRoleRole(addresses.ringRole); @@ -696,6 +709,9 @@ export class FaceclawCommunicatorBridge { return this.enqueueNativeCall(() => Boolean(this.communicator.setFaceclawWakeLeaseEnabledEnabled(Boolean(enabled)))); } + /** The RayNeo iO's wake word; iOS doesn't drive an iO, so nothing to do. */ + async setVoiceWakeEnabled(_enabled: boolean): Promise {} + async awaitEvenHubSessionReady(timeoutMs: number): Promise { return this.enqueueNativeCall(() => Boolean(this.communicator.awaitEvenHubSessionReadyTimeoutMs(Math.round(nonNegativeNumber(timeoutMs))))); } @@ -795,6 +811,19 @@ export class FaceclawCommunicatorBridge { toData(new Uint8Array(record)), label, Boolean(rightTemple), Boolean(leftTemple))); } + /** Raw field-131 keyboard-bridge records, in arrival order, on the main queue. */ + addKeyboardEventListener(listener: (body: Uint8Array) => void): () => void { + const proxy = KeyboardEventListener.new() as KeyboardEventListener; + proxy.handler = listener; + const handle = this.communicator.addKeyboardEventListenerNsDataListener(proxy); + return () => { this.communicator.removeKeyboardEventListenerListener(handle); }; + } + + /** Queue a CFW keyboard-bridge control for the right temple; false when nothing was queued. */ + sendFaceclawKeyboardControl(record: Uint8Array, label: string): boolean { + return Boolean(this.communicator.sendFaceclawKeyboardControlRecordLabel(toData(new Uint8Array(record)), label)); + } + /** * Every audio-characteristic packet, whatever enabled the mics, on the * main queue. Passive: sends nothing and doesn't affect capture. @@ -849,6 +878,11 @@ export class FaceclawCommunicatorBridge { return Boolean(this.communicator.isAncsAuthorized()); } + /** False on a G1 whose firmware has no relay; a G2's depends on its firmware revision. */ + ancsRelayAvailable(): boolean { + return Boolean(this.communicator.ancsRelayAvailable()); + } + onAncsAuthorization(listener: (authorized: boolean) => void): () => void { this.ancsAuthorizationListeners.add(listener); return () => this.ancsAuthorizationListeners.delete(listener); diff --git a/app/native/faceclaw-communicator.ts b/app/native/faceclaw-communicator.ts index a459d348..51dd92ee 100644 --- a/app/native/faceclaw-communicator.ts +++ b/app/native/faceclaw-communicator.ts @@ -1,3 +1,4 @@ +import type { GlassesType } from "../ui/dashboard-settings"; import type { RingInput } from "../g2/ring-input"; import { ImageSource, Utils } from "@nativescript/core"; import * as frameTimings from "./frame-timings"; @@ -169,7 +170,7 @@ export class FaceclawCommunicatorBridge { private readonly firmwareInfoListeners = new Set<(info: FirmwareInfo) => void>(); private readonly previewAnimationListeners = new Set<() => void>(); - constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string }) { + constructor(addresses: { right: string; left: string; ring?: string; ringRole?: string; glassesType?: GlassesType }) { const context = Utils.android.getApplicationContext(); if (!context) throw new Error("Android application context unavailable"); @@ -181,6 +182,10 @@ export class FaceclawCommunicatorBridge { ); // The shared session halts on any other firmware ("incompatible-firmware"). this.communicator.setRequiredFirmwareRevision(REQUIRED_FACECLAW_FIRMWARE_VERSION); + // RayNeo iO: one link (its address in both arm slots), its own handshake and page lease. + if (addresses.glassesType === "rayneo-io") this.communicator.useRayNeoIo(); + // Even G1 on g1v0: two links, like a G2's arms, but frames composed here and sent to each arm. + if (addresses.glassesType === "g1") this.communicator.useG1(); // Which R1 role the direct ring link claims; only matters with a ring address. if (addresses.ringRole) this.communicator.setDirectRingRole(addresses.ringRole); this.listenerProxy = new com.faceclaw.app.FaceclawBleCommunicatorListener({ @@ -756,6 +761,14 @@ export class FaceclawCommunicatorBridge { ); } + /** + * Whether the glasses' own wake word reaches Faceclaw: on a RayNeo iO, its + * "Hey RayNeo" switch (G2 glasses use the wake lease above instead). + */ + async setVoiceWakeEnabled(enabled: boolean): Promise { + await this.enqueueJavaCall(() => this.communicator.setVoiceWakeEnabled(enabled)); + } + /** * Resolve only once the recreated layout and retained frame * are visible. CFW's deferred-dashboard READY is emitted from this barrier. diff --git a/app/native/g1-flasher.ios.ts b/app/native/g1-flasher.ios.ts new file mode 100644 index 00000000..f2fd9579 --- /dev/null +++ b/app/native/g1-flasher.ios.ts @@ -0,0 +1,80 @@ +import { Application } from '@nativescript/core' +import { parseG1FlashResult, type G1FlashResult } from '../g1/flash-plan' +import { iosBluetooth } from './ios-bluetooth' +import { kotlinListener } from './kotlin-listener.ios' +import type { G1FlasherOptions } from './g1-flasher' +export type { G1FlashMode, G1FlasherOptions } from './g1-flasher' + +declare const FaceclawKitIosG1Flasher: any, FaceclawKitFaceclawFirmwareFlasherListener: any + +/** CoreBluetooth has no way to remove a pairing; iOS Settings does it. */ +export function forgetG1Pairing(_address: string): boolean { + return false +} + +/** + * iOS twin of the Android G1Flasher: the shared Kotlin G1ArmFlashFlow over a CoreBluetooth central. As with the G2's + * flasher, the phone must stay in the foreground with the screen awake, and addresses are mapped to peripheral + * identifiers first. + */ +export class G1Flasher { + private flasher: any = null + private listenerProxy: object | null = null + private logListener: ((line: string) => void) | null = null + private progressListener: ((bytesSent: number, bytesTotal: number) => void) | null = null + private stateListener: ((state: string) => void) | null = null + private previousIdle = false + private cancelled = false + private foregroundError = '' + + constructor(private readonly options: G1FlasherOptions) {} + + onLog(listener: (line: string) => void): void { this.logListener = listener } + onProgress(listener: (bytesSent: number, bytesTotal: number) => void): void { this.progressListener = listener } + onState(listener: (state: string) => void): void { this.stateListener = listener } + + private readonly backgrounded = () => { + this.foregroundError = 'The install stopped because Faceclaw left the foreground. Return to Faceclaw and try again.' + this.cancel() + } + + run(): Promise { + this.previousIdle = UIApplication.sharedApplication.idleTimerDisabled + UIApplication.sharedApplication.idleTimerDisabled = true + Application.on(Application.suspendEvent, this.backgrounded) + const restore = () => { + Application.off(Application.suspendEvent, this.backgrounded) + UIApplication.sharedApplication.idleTimerDisabled = this.previousIdle + } + return new Promise((resolve, reject) => { + const identifier = iosBluetooth().peripheralIdentifier(this.options.address, this.options.side) + if (!identifier) throw new Error(`Could not find the ${this.options.side} arm. Keep the glasses in the case with the lid open.`) + this.flasher = FaceclawKitIosG1Flasher.alloc().initWithAddressSideFirmwarePathNetCorePathModeConnectWindowMs( + identifier, this.options.side, this.options.firmwarePath, this.options.netCorePath ?? '', this.options.mode, this.options.connectWindowMs) + this.listenerProxy = kotlinListener(FaceclawKitFaceclawFirmwareFlasherListener, { + onLogLine: (line: string) => this.logListener?.(String(line ?? '')), + onProgressLensComponentIndexComponentCountBlockIndexBlockCountBytesSentBytesTotal: ( + _lens: string, _componentIndex: number, _componentCount: number, _blockIndex: number, _blockCount: number, sent: number, total: number, + ) => this.progressListener?.(Number(sent), Number(total)), + onStateStateDetail: (state: string) => this.stateListener?.(String(state)), + onCompleteSuccessDetail: (success: boolean, detail: string) => { + if (success) resolve(parseG1FlashResult(String(detail ?? ''))) + else reject(new Error(this.foregroundError || String(detail ?? '') || 'The install failed.')) + }, + }) + this.flasher.setListenerListener(this.listenerProxy) + if (this.cancelled) this.flasher.cancel() + this.flasher.start() + }).finally(restore) + } + + cancel(): void { + this.cancelled = true + try { this.flasher?.cancel() } catch { /* ignore */ } + } + + close(): void { + this.cancel() + try { this.flasher?.close() } catch { /* ignore */ } + } +} diff --git a/app/native/g1-flasher.ts b/app/native/g1-flasher.ts new file mode 100644 index 00000000..e27f6a0f --- /dev/null +++ b/app/native/g1-flasher.ts @@ -0,0 +1,85 @@ +import { Utils } from "@nativescript/core"; + +import { parseG1FlashResult, type G1FlashResult, type G1Side } from "../g1/flash-plan"; + +declare const com: any; + +/** "restore": Even's firmware back on an arm running g1v0, both of its images. */ +export type G1FlashMode = "stock" | "update" | "probe" | "restore"; + +export type G1FlasherOptions = { + address: string; + side: G1Side; + /** The application core's image. */ + firmwarePath: string; + /** A restore's network-core image. */ + netCorePath?: string; + mode: G1FlashMode; + /** How long to keep trying to reach the arm and pair with it. */ + connectWindowMs: number; +}; + +/** Removes the phone's pairing with an address, which the glasses no longer use or no longer share. False: this phone can't. */ +export function forgetG1Pairing(address: string): boolean { + const context = Utils.android.getApplicationContext(); + if (!context) return false; + com.faceclaw.app.FaceclawG1Flasher.forgetPairing(context, address); + return true; +} + +/** TS wrapper around FaceclawG1Flasher: one arm's install, its restore to Even's firmware, or a question about what it runs. */ +export class G1Flasher { + private readonly flasher: any; + private readonly listenerProxy: any; + private logListener: ((line: string) => void) | null = null; + private progressListener: ((bytesSent: number, bytesTotal: number) => void) | null = null; + private stateListener: ((state: string) => void) | null = null; + private completion: ((success: boolean, detail: string) => void) | null = null; + + constructor(options: G1FlasherOptions) { + const context = Utils.android.getApplicationContext(); + if (!context) throw new Error("Android application context unavailable"); + this.flasher = new com.faceclaw.app.FaceclawG1Flasher( + context, options.address, options.side, options.firmwarePath, options.netCorePath ?? "", options.mode, options.connectWindowMs, + ); + this.listenerProxy = new com.faceclaw.app.FaceclawFirmwareFlasherListener({ + onLog: (line: string) => this.logListener?.(String(line)), + onProgress: (_lens: string, _component: number, _components: number, _block: number, _blocks: number, sent: number, total: number) => + this.progressListener?.(Number(sent), Number(total)), + onState: (state: string) => this.stateListener?.(String(state)), + onComplete: (success: boolean, detail: string) => this.completion?.(Boolean(success), String(detail ?? "")), + }); + this.flasher.setListener(this.listenerProxy); + } + + onLog(listener: (line: string) => void): void { + this.logListener = listener; + } + + onProgress(listener: (bytesSent: number, bytesTotal: number) => void): void { + this.progressListener = listener; + } + + onState(listener: (state: string) => void): void { + this.stateListener = listener; + } + + run(): Promise { + return new Promise((resolve, reject) => { + this.completion = (success, detail) => { + this.completion = null; + if (success) resolve(parseG1FlashResult(detail)); + else reject(new Error(detail || "The install failed.")); + }; + this.flasher.start(); + }); + } + + cancel(): void { + this.flasher.cancel(); + } + + close(): void { + this.flasher.close(); + } +} diff --git a/app/native/gray-image-preview.ios.ts b/app/native/gray-image-preview.ios.ts index da6c89d6..4d2e83c6 100644 --- a/app/native/gray-image-preview.ios.ts +++ b/app/native/gray-image-preview.ios.ts @@ -11,7 +11,7 @@ export function grayImageToPreviewSource(image: GrayImage): ImageSource | null { /** * A glasses icon as a white-on-transparent phone image (gray becomes alpha), - * for the dark header. + * which the phone UI tints to suit its background. */ export function grayImageToWhiteIconSource(image: GrayImage): ImageSource | null { const baked = image.withDrawsBaked() diff --git a/app/native/gray-image-preview.ts b/app/native/gray-image-preview.ts index e59c2655..58ee723f 100644 --- a/app/native/gray-image-preview.ts +++ b/app/native/gray-image-preview.ts @@ -30,7 +30,7 @@ export function grayImageToPreviewSource(image: GrayImage): ImageSource | null { /** * A glasses icon as a white-on-transparent phone image (gray becomes alpha), - * for the dark action bar. + * which the phone UI tints to suit its background. */ export function grayImageToWhiteIconSource(image: GrayImage): ImageSource | null { if (!global.isAndroid) { diff --git a/app/native/image-rgba.ios.ts b/app/native/image-rgba.ios.ts new file mode 100644 index 00000000..7ef09dba --- /dev/null +++ b/app/native/image-rgba.ios.ts @@ -0,0 +1,9 @@ +import { toData, fromData } from './kotlin-data' +import { rgbaFromPacket } from './image-rgba' +declare const FaceclawGraphics: any + +/** Decoded RGBA of encoded image bytes, or null when undecodable (transparent pixels come out black). */ +export function decodeImageRgba(bytes: Uint8Array): { width: number; height: number; rgba: Uint8Array } | null { + const data = FaceclawGraphics.rgbaPacketFromImageData(toData(bytes)) + return data ? rgbaFromPacket(fromData(data)) : null +} diff --git a/app/native/image-rgba.ts b/app/native/image-rgba.ts new file mode 100644 index 00000000..28c8d7b1 --- /dev/null +++ b/app/native/image-rgba.ts @@ -0,0 +1,22 @@ +import { toUint8Array } from '../util/array-util' +import { copyToJavaByteBuffer } from './java-direct-buffer' +declare const com: any + +/** Decoded RGBA (not premultiplied) of encoded image bytes, or null when undecodable. */ +export function decodeImageRgba(bytes: Uint8Array): { width: number; height: number; rgba: Uint8Array } | null { + try { + return rgbaFromPacket(toUint8Array(com.faceclaw.app.ImageFileLoader.decodeRgbaFromBytes(copyToJavaByteBuffer(bytes)))) + } catch (error) { + console.warn(`decodeImageRgba failed: ${error}`) + return null + } +} + +/** [widthLo, widthHi, heightLo, heightHi, RGBA...] as an image, or null when short. */ +export function rgbaFromPacket(packet: Uint8Array): { width: number; height: number; rgba: Uint8Array } | null { + if (packet.length < 4) return null + const width = packet[0]! | (packet[1]! << 8) + const height = packet[2]! | (packet[3]! << 8) + if (width <= 0 || height <= 0 || packet.length < 4 + width * height * 4) return null + return { width, height, rgba: packet.slice(4, 4 + width * height * 4) } +} diff --git a/app/native/ios-bluetooth.ts b/app/native/ios-bluetooth.ts index 5c523858..aac0b385 100644 --- a/app/native/ios-bluetooth.ts +++ b/app/native/ios-bluetooth.ts @@ -7,6 +7,8 @@ declare const FaceclawKitIosBleCentral: any, FaceclawKitIosProtocolPlatform: any /** CBManagerState raw values reported by the Kotlin central. */ export const BLE_STATE_UNSUPPORTED = 2, BLE_STATE_UNAUTHORIZED = 3, BLE_STATE_POWERED_OFF = 4, BLE_STATE_POWERED_ON = 5 +/** CBManagerAuthorization.allowedAlways. */ +const BLE_AUTHORIZATION_ALLOWED = 3 export type BluetoothEvent = | { kind: 'state'; state: number; authorization: number } @@ -50,17 +52,21 @@ export class IosBluetooth { } }, }) - this.native.setScanListenerListener(this.scanListener) } onEvent(listener: (event: BluetoothEvent) => void): () => void { this.listeners.add(listener); return () => { this.listeners.delete(listener) } } private emit(event: BluetoothEvent): void { for (const listener of [...this.listeners]) listener(event) } + /** + * Whether the user has allowed Bluetooth. Unlike `state` this is accurate before the + * central exists, and reading it never shows the permission prompt. + */ + isAuthorized(): boolean { return Number(this.native.authorization()) === BLE_AUTHORIZATION_ALLOWED } /** Creates the central (first use shows the Bluetooth permission prompt) without blocking the JS thread. */ private ensureCentral(): void { - // A zero timeout returns immediately after creating the central; the state arrives - // through the scan listener on the main queue. - this.native.waitForPoweredOnTimeoutMs(0) + // Registering the listener creates the central, or has an existing one re-report its + // state; the state arrives through the listener on the main queue. + this.native.setScanListenerListener(this.scanListener) } ensureReady(): Promise { if (this.state === BLE_STATE_POWERED_ON) return Promise.resolve() @@ -129,6 +135,15 @@ export class IosBluetooth { }) return result } + /** The peripheral last heard at this address, if it was on this side. */ + peripheralIdentifier(address: string, role: string): string | null { + try { + const saved = JSON.parse(ApplicationSettings.getString(`ios.ble.peripheral.${address}`, '{}')) + return saved.role === role && typeof saved.identifier === 'string' ? saved.identifier : null + } catch { + return null + } + } forget(address: string): void { ApplicationSettings.remove(`ios.ble.peripheral.${address}`); this.devices.delete(address) } } let instance: IosBluetooth | null = null diff --git a/app/native/keyboard-link.ios.ts b/app/native/keyboard-link.ios.ts new file mode 100644 index 00000000..7dcc52b2 --- /dev/null +++ b/app/native/keyboard-link.ios.ts @@ -0,0 +1,24 @@ +import { FaceclawCommunicatorBridge } from "./faceclaw-communicator.ios"; + +/** The iOS twin of keyboard-link.ts, over the running shared-Kotlin session. */ + +export function keyboardLinkSession(): unknown { + return FaceclawCommunicatorBridge.getActive(); +} + +/** Queue a control record for the right temple; false when the session wasn't ready and nothing was queued. */ +export function sendKeyboardControlRecord(session: unknown, record: Uint8Array, label: string): boolean { + return (session as FaceclawCommunicatorBridge).sendFaceclawKeyboardControl(record, label); +} + +/** Raw keyboard-bridge records (undecoded, possibly fragments), in arrival order. Returns an unsubscribe function. */ +export function addKeyboardEventListener(session: unknown, listener: (body: Uint8Array) => void): () => void { + const unsubscribe = (session as FaceclawCommunicatorBridge).addKeyboardEventListener(listener); + return () => { + try { + unsubscribe(); + } catch { + // The session may have been closed during a reconnect. + } + }; +} diff --git a/app/native/keyboard-link.ts b/app/native/keyboard-link.ts new file mode 100644 index 00000000..954cd24f --- /dev/null +++ b/app/native/keyboard-link.ts @@ -0,0 +1,40 @@ +import { toJavaBytes } from "./cloud-stt"; +import { toUint8Array } from "../util/array-util"; + +declare const com: any; + +/** + * Platform plumbing for the CFW keyboard bridge (app/g2/keyboard/): the running + * session to send field-130 controls on and to hear field-131 records from. + * The session is opaque and is a different object after a reconnect. + */ + +export function keyboardLinkSession(): unknown { + if (!global.isAndroid) return null; + try { + return com.faceclaw.app.FaceclawBleCommunicator.getActive(); + } catch { + return null; + } +} + +/** Queue a control record for the right temple; false when the session wasn't ready and nothing was queued. */ +export function sendKeyboardControlRecord(session: unknown, record: Uint8Array, label: string): boolean { + return (session as any).sendFaceclawKeyboardControl(toJavaBytes(record), label) !== false; +} + +/** Raw keyboard-bridge records (undecoded, possibly fragments), in arrival order. Returns an unsubscribe function. */ +export function addKeyboardEventListener(session: unknown, listener: (body: Uint8Array) => void): () => void { + const communicator = session as any; + const proxy = new com.faceclaw.app.FaceclawKeyboardEventListener({ + onKeyboardEvent: (body: any) => listener(toUint8Array(body)), + }); + communicator.addKeyboardEventListener(proxy); + return () => { + try { + communicator.removeKeyboardEventListener(proxy); + } catch { + // The old communicator instance may be gone after a reconnect. + } + }; +} diff --git a/app/native/mic-recorder.ios.ts b/app/native/mic-recorder.ios.ts new file mode 100644 index 00000000..e5f76a3b --- /dev/null +++ b/app/native/mic-recorder.ios.ts @@ -0,0 +1,50 @@ +import { knownFolders, path as paths } from '@nativescript/core' + +// Kotlin/Native facade exported by FaceclawKit (native/kotlin/shared/src/iosMain/.../IosMicRecorder.kt). +declare const FaceclawKitIosMicRecordings: any + +/** + * Records 16 kHz mono PCM16 to a Matroska audio file (.mka) in + * Documents/Downloads while it is captured, through the shared Kotlin writer + * that Android's captures are recorded with. The file is written about a + * second at a time, so a crash leaves everything up to the last second. + */ +export class MicRecorder { + private constructor(private recorder: any, readonly path: string) {} + + /** + * A recorder for Downloads/.mka (a -2, -3... suffix if taken), or null. + * `info` describes the capture and is stored in the file. + */ + static open(name: string, info: Record = {}): MicRecorder | null { + const fm = NSFileManager.defaultManager + const dir = paths.join(knownFolders.documents().path, 'Downloads') + try { + fm.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(dir, true, null) + let path = paths.join(dir, `${name}.mka`) + for (let n = 2; fm.fileExistsAtPath(path); n++) path = paths.join(dir, `${name}-${n}.mka`) + const recorder = FaceclawKitIosMicRecordings.shared.openPathConfigJson(path, JSON.stringify(info)) + return recorder ? new MicRecorder(recorder, path) : null + } catch { + return null + } + } + + append(pcm: Uint8Array): void { + if (!this.recorder || !pcm.length) return + // The handle is the buffer's start: a view into a larger buffer is copied out first. + const bytes = pcm.byteOffset === 0 && pcm.byteLength === pcm.buffer.byteLength ? pcm : pcm.slice() + try { + // Copied by the recorder before this returns. + this.recorder.appendPcm16le(NSData.dataWithBytesLength(interop.handleof(bytes.buffer), bytes.byteLength)) + } catch { + // Stop recording rather than retry. + this.close() + } + } + + close(): void { + try { this.recorder?.finish() } catch { /* already closed */ } + this.recorder = null + } +} diff --git a/app/native/mic-recording.ts b/app/native/mic-recording.ts new file mode 100644 index 00000000..0c8663f1 --- /dev/null +++ b/app/native/mic-recording.ts @@ -0,0 +1,29 @@ +declare const android: any; +declare const java: any; + +/** Extension of the recordings Save Recording writes, and Transcribe replays (Matroska audio). */ +export const RECORDING_EXTENSION = ".mka"; + +export function isMicRecordingFile(name: string): boolean { + return name.toLowerCase().endsWith(RECORDING_EXTENSION); +} + +/** + * The path for a new recording in the public Downloads directory: + * Downloads/.mka, with a -2, -3... suffix if that is taken. Null when + * Downloads isn't available. The file itself is created by whoever records. + */ +export function newRecordingPath(name: string): string | null { + try { + const downloads = android.os.Environment.getExternalStoragePublicDirectory( + android.os.Environment.DIRECTORY_DOWNLOADS, + ); + downloads.mkdirs(); + let file = new java.io.File(downloads, `${name}${RECORDING_EXTENSION}`); + for (let n = 2; file.exists(); n++) file = new java.io.File(downloads, `${name}-${n}${RECORDING_EXTENSION}`); + return String(file.getAbsolutePath()); + } catch (error) { + console.warn(`Voice: no Downloads directory for ${name}${RECORDING_EXTENSION}: ${error}`); + return null; + } +} diff --git a/app/native/voice-control.ios.ts b/app/native/voice-control.ios.ts index 407ab3cd..aa0740a2 100644 --- a/app/native/voice-control.ios.ts +++ b/app/native/voice-control.ios.ts @@ -3,7 +3,7 @@ import type { CloudSttTranscriptEvent } from './cloud-stt' import type { ReconnectingSttClient } from './reconnecting-stt' import { createCloudSttClient, usesCloudStt, type VoiceProviderSelection } from './cloud-stt-provider' import { createSpeechAnalyzerClient, speechAnalyzerSupported } from './speech-analyzer-stt.ios' -import { WavRecorder } from './wav-recorder.ios' +import { MicRecorder } from './mic-recorder.ios' import { pcmLevel } from '../util/audio-level' declare const FaceclawSpeech: any @@ -57,11 +57,14 @@ export class IosVoiceControlBridge { private continuous = false // Shown instead of the native "ended" status once a drain the bridge started completes. private drainStatus: string | null = null - // Continuous captures' audio goes to Downloads/.wav while it is + // Continuous captures' audio goes to Downloads/.mka while it is // set. The file outlives a capture, so a restarted one keeps appending to it, // and it is created by the first audio, so a failed start leaves no file. private recordingName = '' - private recorder: WavRecorder | null = null + private recorder: MicRecorder | null = null + // The file could not be created: one attempt per recording, not one per packet. + private recordingFailure = false + private readonly recordingListeners = new Set<() => void>() // Raw-PCM tap (EvenHub mic apps): decode-only glasses audio, broadcast to // rawListeners while any owner wants it, from the session setRawSession // bound. It shares the one glasses mic with speech capture, which preempts @@ -206,22 +209,37 @@ export class IosVoiceControlBridge { /** Where a listening continuous capture gets its audio; null when none is listening. */ get continuousSource(): 'glasses' | 'phone' | null { return this.continuous && this.capturing ? this.source : null } /** - * Record continuous captures' audio to Downloads/.wav, across restarts, + * Record continuous captures' audio to Downloads/.mka, across restarts, * until called with another name or ''. Only cloud captures supply PCM. */ recordTo(name: string): void { if (name === this.recordingName) return this.recorder?.close(); this.recorder = null - this.recordingName = name + this.setRecording(name, false) + } + /** Whether continuous captures' audio is being saved (see recordTo). */ + get recording(): boolean { return this.recordingName !== '' && !this.recordingFailure } + /** Whether the recording asked for could not be saved (its file could not be created). */ + get recordingFailed(): boolean { return this.recordingFailure } + /** `recording` or `recordingFailed` changed. */ + onRecordingChange(listener: () => void): () => void { this.recordingListeners.add(listener); return () => { this.recordingListeners.delete(listener) } } + private setRecording(name: string, failed: boolean): void { + const wasRecording = this.recording, hadFailed = this.recordingFailure + this.recordingName = name; this.recordingFailure = failed + if (wasRecording === this.recording && hadFailed === failed) return + for (const fn of [...this.recordingListeners]) fn() } private record(pcm: Uint8Array): void { - if (!this.recorder && this.recordingName) { - this.recorder = WavRecorder.open(this.recordingName) + if (!this.recording) return + if (!this.recorder) { + this.recorder = MicRecorder.open(this.recordingName, { + recording: this.recordingName, startedAt: new Date().toISOString(), platform: 'ios', + source: this.source === 'phone' ? 'phone' : 'glasses', mics: 1, + }) this.log(this.recorder ? `Voice: recording audio to ${this.recorder.path}` : 'Voice: could not create the audio recording') - // One attempt per recording, not one per packet. - if (!this.recorder) this.recordingName = '' + if (!this.recorder) { this.setRecording(this.recordingName, true); return } } - this.recorder?.append(pcm) + this.recorder.append(pcm) } /** End continuous capture, transcribing the audio since the last pause. */ stopContinuousCapture(): Promise { diff --git a/app/native/voice-control.ts b/app/native/voice-control.ts index d6a7e37b..96243f7d 100644 --- a/app/native/voice-control.ts +++ b/app/native/voice-control.ts @@ -1,7 +1,8 @@ import { Utils } from "@nativescript/core"; -import { type CloudSttTranscriptEvent, CloudSttClient } from "./cloud-stt"; +import { type CloudSttTranscriptEvent, CloudSttClient, toJavaBytes } from "./cloud-stt"; import { createCloudSttClient, transcriptionKey } from "./cloud-stt-provider"; +import { newRecordingPath } from "./mic-recording"; import { SpeechPauseDetector } from "./speech-pause"; import { toUint8Array } from "../util/array-util"; import { pcmLevel } from "../util/audio-level"; @@ -60,7 +61,6 @@ export type PushToTalkOptions = { whisperServerApiKey?: string; /** Spoken language for cloud providers (see VoiceProviderSelection.language). */ language?: string; - saveRecording: boolean; /** * Watch the mic and fire onSpeechEnd when the speaker stops. For hands-free * ("Hey Even") capture, which has no button release to end the utterance. @@ -84,6 +84,49 @@ export type PushToTalkOptions = { * frame). Null/absent leaves the mic omnidirectional. */ beamFilter?: { centerDeg: number; halfWidthDeg: number } | null; + /** + * Capture from the temples' own microphones (the custom firmware's + * mic_control stream) instead of the glasses' mixed stream. Each temple + * streams its microphones on its own link and clock; the phone mixes them + * into the mono feed that is transcribed. Null/absent keeps the mixed + * stream; ignored with usePhoneMic. + */ + micArray?: MicArrayCapture | null; + /** + * Play this recording (a .mka file from Save Recording) in real time in + * place of any microphone. The capture needs no glasses, and ends by + * itself when the recording does. + */ + replay?: { path: string; startMs: number } | null; + /** What the caller knows of the capture, for the description stored in a recording of it. */ + captureInfo?: Record; +}; + +export type MicArrayCapture = { + /** The mic_control CONFIGURE record both temples are armed with (see mic-protocol.ts). */ + configure: Uint8Array; +}; + +/** Progress of a capture that replays a recording; positions are ms into it. */ +export type VoiceReplayEvent = { + /** + * `start` once the file is open, `position` about once per second played, + * `seek` when a jump took effect, `end` when the recording ran out, and + * `error` when it could not be opened (the status says why). + */ + kind: "start" | "position" | "seek" | "end" | "error"; + positionMs: number; + durationMs: number; +}; + +/** What a listening view (Transcribe, Translate) takes from a capture: the microphone's, or a replay's. */ +export type VoiceEventSource = { + onStatus(listener: (state: VoiceControlState) => void): () => void; + onTranscript(listener: (event: VoiceTranscriptEvent) => void): () => void; + onSpeechPause(listener: () => void): () => void; + onMicLevel(listener: (level: number) => void): () => void; + readonly recording: boolean; + readonly recordingFailed: boolean; }; /** Who currently wants the mic running. */ @@ -130,9 +173,13 @@ export class FaceclawVoiceControlBridge { private captureEndpointing = false; // Non-null while a cloud provider owns the transcript; Java only decodes PCM. private cloudClient: CloudSttClient | null = null; - // What the running STT stream transcribes with (transcriptionKey); a holder - // asking for something else restarts the stream rather than sharing it. + // What the running STT stream captures from and transcribes with + // (streamKey); a holder asking for something else restarts the stream + // rather than sharing it. private streamProvider: string | null = null; + // The options of the running stream, for the description of a recording of it. + private streamOptions: PushToTalkOptions | null = null; + private readonly replayListeners = new Set<(event: VoiceReplayEvent) => void>(); // Raw-PCM tap (EvenHub mic apps, the Microphones app): when active, the // controller runs in the decode-only "cloud" mode and every decoded PCM // frame is broadcast to these listeners. STT capture preempts it — a live @@ -150,6 +197,17 @@ export class FaceclawVoiceControlBridge { // the bridge swallow it. private verificationActive = false; private verificationRejected = false; + // Continuous captures' audio goes to Downloads/.mka while it is + // set: every source's chunks as they arrive, before any processing, written + // by the controller. The file outlives a capture, so a restarted one keeps + // adding to it, and it is created by the first audio, so a failed start + // leaves no file. + private recordingName = ""; + // The file is open in the controller. + private recordingOpen = false; + // The file could not be created: one attempt per recording, not one per packet. + private recordingFailure = false; + private readonly recordingListeners = new Set<() => void>(); onStatus(listener: (state: VoiceControlState) => void): () => void { this.statusListeners.add(listener); @@ -242,6 +300,125 @@ export class FaceclawVoiceControlBridge { this.acquireCapture("continuous", options); } + /** + * End the continuous capture as an utterance: stop it and have the + * transcript of its last audio come as a final. For a capture whose audio + * ran out by itself (a replay). + */ + finishContinuousCapture(): void { + this.releaseCapture("continuous", true); + } + + /** Progress of a capture that replays a recording (PushToTalkOptions.replay). */ + onReplay(listener: (event: VoiceReplayEvent) => void): () => void { + this.replayListeners.add(listener); + return () => this.replayListeners.delete(listener); + } + + /** Continue the running replay from `positionMs` into its recording. */ + seekReplay(positionMs: number): void { + this.controller?.seekReplay(Math.max(0, Math.round(positionMs))); + } + + /** Hold the running replay where it is, or let it go on. */ + setReplayPaused(paused: boolean): void { + this.controller?.setReplayPaused(paused); + } + + /** Whether a capture is running and still has audio coming (a replay stops being so at its end). */ + isCaptureLive(): boolean { + return this.micIsLive(); + } + + /** + * Record continuous captures' audio to Downloads/.mka, across restarts, + * until called with another name or "". + */ + recordTo(name: string): void { + if (name === this.recordingName) return; + this.closeRecording(); + this.setRecording(name, false); + } + + private closeRecording(): void { + if (!this.recordingOpen) return; + this.recordingOpen = false; + try { + this.controller?.stopRecording(); + } catch (error) { + console.warn(`Voice: closing the recording failed: ${error}`); + } + } + + /** Whether continuous captures' audio is being saved (see recordTo). */ + get recording(): boolean { + return this.recordingName !== "" && !this.recordingFailure; + } + + /** Whether the recording asked for could not be saved (its file could not be created). */ + get recordingFailed(): boolean { + return this.recordingFailure; + } + + /** `recording` or `recordingFailed` changed. */ + onRecordingChange(listener: () => void): () => void { + this.recordingListeners.add(listener); + return () => this.recordingListeners.delete(listener); + } + + private setRecording(name: string, failed: boolean): void { + const wasRecording = this.recording; + const hadFailed = this.recordingFailure; + this.recordingName = name; + this.recordingFailure = failed; + if (wasRecording === this.recording && hadFailed === failed) return; + for (const listener of Array.from(this.recordingListeners)) listener(); + } + + /** + * Audio arrived for a continuous capture: open the recording asked for, if + * it isn't open yet. The controller writes it from then on, as the audio + * arrives on its own thread. + */ + private ensureRecording(): void { + if (!this.recording || this.recordingOpen) return; + const path = newRecordingPath(this.recordingName); + let opened = false; + try { + opened = path !== null && Boolean(this.controller?.startRecording(path, JSON.stringify(this.describeCapture()))); + } catch (error) { + console.warn(`Voice: could not create the recording: ${error}`); + } + if (!opened) { + this.setRecording(this.recordingName, true); + return; + } + this.recordingOpen = true; + console.log(`Voice: recording audio to ${path}`); + } + + /** Only captures a continuous holder has a part in are recorded: push-to-talk on its own is not. */ + private syncRecordingEnabled(): void { + this.controller?.setRecordingEnabled(this.captureHolders.has("continuous")); + } + + /** The running capture, as the JSON stored in a recording of it. */ + private describeCapture(): Record { + const options = this.streamOptions; + return { + recording: this.recordingName, + startedAt: new Date().toISOString(), + source: options?.usePhoneMic ? "phone" : "glasses", + micArray: Boolean(options?.micArray) && !options?.usePhoneMic, + transcription: { provider: options?.provider ?? "", language: options?.language ?? "" }, + processing: { + noiseSuppression: Boolean(options?.noiseSuppression), + beamFilter: options?.beamFilter ?? null, + }, + ...options?.captureInfo, + }; + } + /** Subscribe to decoded raw mic PCM (16 kHz mono S16LE). */ onRawPcm(listener: RawPcmListener): () => void { this.rawPcmListeners.add(listener); @@ -305,8 +482,9 @@ export class FaceclawVoiceControlBridge { // The raw tap is strictly the G2 stream; clear any phone-mic flag a // preview-mode capture may have left on the shared controller. this.controller?.setUsePhoneMic(false); - this.controller?.setSaveRecordings(false); this.controller?.setEndpointing(false); + this.controller?.setMicArray(null); + this.controller?.setReplay(null, 0); // Raw means raw: the Microphones session (and EvenHub apps) get the // unprocessed stream and run their own beam/suppression processing. this.controller?.setNoiseSuppression(false); @@ -342,19 +520,33 @@ export class FaceclawVoiceControlBridge { const micLive = this.micIsLive(); this.suspendedHolders.delete(holder); this.captureHolders.add(holder); - if (micLive && this.streamProvider === transcriptionKey(options)) { + if (micLive && this.streamProvider === streamKey(options)) { // Mic already running; the new holder just shares the existing stream // (transcripts are already broadcast to its listeners). + this.syncRecordingEnabled(); return; } - // Any leftover capture is dead, or transcribes with another provider than + // Any leftover capture is dead, or captures or transcribes otherwise than // this holder needs; drop it before starting the new one. if (this.started) this.teardownCapture(); - this.streamProvider = transcriptionKey(options); + this.streamProvider = streamKey(options); + this.streamOptions = options; this.ensureController(); + this.syncRecordingEnabled(); + // A recording under way carries on into this capture: note what changed. + if (this.recordingOpen) { + try { + this.controller?.noteRecordingEvent(JSON.stringify({ event: "capture", ...this.describeCapture() })); + } catch (error) { + console.warn(`Voice: recording event failed: ${error}`); + } + } this.controller?.setCommunicator(options.communicator); this.controller?.setUsePhoneMic(Boolean(options.usePhoneMic)); - this.controller?.setSaveRecordings(options.saveRecording); + this.controller?.setMicArray( + options.micArray && !options.usePhoneMic && !options.replay ? toJavaBytes(options.micArray.configure) : null, + ); + this.controller?.setReplay(options.replay?.path ?? null, Math.max(0, Math.round(options.replay?.startMs ?? 0))); this.controller?.setEndpointing(Boolean(options.endpointing)); this.captureEndpointing = Boolean(options.endpointing); this.controller?.setNoiseSuppression(Boolean(options.noiseSuppression)); @@ -379,7 +571,7 @@ export class FaceclawVoiceControlBridge { this.speechPause.reset(); // Replaces whatever the last capture left behind ("Listening...", an // error, the permission prompt) until the controller reports progress. - this.setStatus("Starting microphone..."); + this.setStatus(options.replay ? "Opening the recording..." : "Starting microphone..."); // A previous push-to-talk commit may still be awaiting its final result. this.cloudClient?.stop(); const cloudClient = this.createCloudClient(options); @@ -424,6 +616,7 @@ export class FaceclawVoiceControlBridge { if (commit) this.cloudClient?.finish(); return; } + this.syncRecordingEnabled(); if (this.captureHolders.size > 0) { // Another holder still wants the mic; keep it running. return; @@ -448,6 +641,7 @@ export class FaceclawVoiceControlBridge { this.captureHolders.clear(); this.suspendedHolders.clear(); this.suspendedRaw = false; + this.syncRecordingEnabled(); this.teardownCapture(); this.setStatus("Voice control stopped."); } @@ -465,6 +659,7 @@ export class FaceclawVoiceControlBridge { this.suspendedHolders.add(holder); } this.captureHolders.clear(); + this.syncRecordingEnabled(); this.suspendedRaw = this.rawActive; this.teardownCapture(); if (this.suspendedHolders.size > 0) { @@ -522,6 +717,7 @@ export class FaceclawVoiceControlBridge { private teardownCapture(): void { this.rawActive = false; this.streamProvider = null; + this.streamOptions = null; if (global.isAndroid) { this.controller?.stop(); } @@ -554,6 +750,8 @@ export class FaceclawVoiceControlBridge { onPcm: (pcm: any) => { const bytes = toUint8Array(pcm); this.cloudClient?.acceptPcm(bytes); + // Push-to-talk on a capture of its own is not recorded. + if (this.captureHolders.has("continuous")) this.ensureRecording(); if (!this.cloudClient && this.captureHolders.has("continuous") && this.speechPause.accept(bytes)) { for (const listener of this.speechPauseListeners) listener(); } @@ -584,6 +782,10 @@ export class FaceclawVoiceControlBridge { ); } }, + onReplay: (kind: string, positionMs: number, durationMs: number) => { + const event = { kind: String(kind) as VoiceReplayEvent["kind"], positionMs: Number(positionMs), durationMs: Number(durationMs) }; + for (const listener of Array.from(this.replayListeners)) listener(event); + }, }); this.controller.setListener(this.listenerProxy); } @@ -620,6 +822,21 @@ export class FaceclawVoiceControlBridge { } } +/** + * What a capture reads and transcribes with. A running capture is shared only + * by holders asking for the same: the provider and language, the microphones + * (the mixed stream, or the temples' own under a given configuration), or the + * recording it replays. + */ +function streamKey(options: PushToTalkOptions): string { + const source = options.replay + ? `replay:${options.replay.path}` + : options.micArray && !options.usePhoneMic + ? `array:${Array.from(options.micArray.configure).join(",")}` + : "mixed"; + return `${transcriptionKey(options)}|${source}`; +} + function toJavaFloats(values: Float32Array): any { const javaFloats = Array.create("float", values.length); for (let i = 0; i < values.length; i++) { @@ -629,3 +846,136 @@ function toJavaFloats(values: Float32Array): any { } export const voiceControlBridge = new FaceclawVoiceControlBridge(); + +export type VoiceReplayState = "opening" | "playing" | "paused" | "ended" | "failed"; + +/** + * A recording played back as a capture of its own: transcribed by the same + * pipeline as the microphone, with the same settings, on a bridge and native + * controller separate from the microphone's. Nothing here touches the mic, + * so voice input and a live Transcribe window carry on beside a replay. + */ +export class VoiceReplay { + private readonly bridge = new FaceclawVoiceControlBridge(); + private readonly listeners = new Set<(jumpedToMs?: number) => void>(); + private readonly offReplay: () => void; + private position = 0; + private duration = 0; + private current: VoiceReplayState = "opening"; + private closed = false; + + /** + * `options` gives the capture options (provider, keys, processing) each + * time the replay starts, so a restart picks up changed settings. + */ + constructor(readonly path: string, private readonly options: () => PushToTalkOptions) { + this.offReplay = this.bridge.onReplay((event) => this.handle(event)); + } + + /** The replay's status, transcript and level events. */ + get events(): VoiceEventSource { + return this.bridge; + } + + /** Milliseconds into the recording. */ + get positionMs(): number { + return this.position; + } + + /** The recording's length in ms; 0 until it has been opened. */ + get durationMs(): number { + return this.duration; + } + + get state(): VoiceReplayState { + return this.current; + } + + /** + * The position, duration or state changed. `jumpedToMs` is given when + * playback moved there other than by playing on: a jump, or a start + * part-way in. It comes after the transcript of what played before. + */ + onChange(listener: (jumpedToMs?: number) => void): () => void { + this.listeners.add(listener); + return () => this.listeners.delete(listener); + } + + /** Play from `positionMs` into the recording. */ + start(positionMs = 0): void { + if (this.closed) return; + this.position = Math.max(0, positionMs); + this.set("opening"); + this.bridge.startContinuousCapture({ + ...this.options(), + communicator: null, + usePhoneMic: false, + micArray: null, + replay: { path: this.path, startMs: this.position }, + }); + } + + /** Continue from `positionMs`: a jump while playing, a fresh start once the replay has ended. */ + jumpTo(positionMs: number): void { + if (this.closed) return; + const target = Math.max(0, this.duration > 0 ? Math.min(positionMs, this.duration) : positionMs); + if ((this.current === "playing" || this.current === "paused") && this.bridge.isCaptureLive()) { + this.bridge.seekReplay(target); + this.position = target; + this.notify(); + return; + } + this.start(target); + } + + setPaused(paused: boolean): void { + if (this.closed || (this.current !== "playing" && this.current !== "paused")) return; + this.bridge.setReplayPaused(paused); + this.set(paused ? "paused" : "playing"); + } + + /** Stop for good and release the capture. */ + close(): void { + if (this.closed) return; + this.closed = true; + this.offReplay(); + this.listeners.clear(); + this.bridge.stop(); + } + + private handle(event: VoiceReplayEvent): void { + this.duration = event.durationMs; + switch (event.kind) { + case "start": + this.position = event.positionMs; + this.current = "playing"; + this.notify(event.positionMs > 0 ? event.positionMs : undefined); + return; + case "seek": + this.position = event.positionMs; + this.notify(event.positionMs); + return; + case "end": + this.position = event.durationMs; + // Its last audio is still to be transcribed (a cloud provider's final). + this.bridge.finishContinuousCapture(); + this.set("ended"); + return; + case "error": + this.set("failed"); + return; + default: + this.position = event.positionMs; + this.notify(); + } + } + + private set(state: VoiceReplayState): void { + this.current = state; + this.notify(); + } + + private notify(jumpedToMs?: number): void { + for (const listener of Array.from(this.listeners)) listener(jumpedToMs); + } +} diff --git a/app/native/wav-header.ts b/app/native/wav-header.ts deleted file mode 100644 index a85ba2e0..00000000 --- a/app/native/wav-header.ts +++ /dev/null @@ -1,22 +0,0 @@ -/** The 44-byte header of a 16 kHz mono PCM16 WAV file holding `dataBytes` of samples. */ -export function wavHeader(dataBytes: number): Uint8Array { - const header = new Uint8Array(44); - const view = new DataView(header.buffer); - const ascii = (offset: number, text: string) => { - for (let i = 0; i < text.length; i++) header[offset + i] = text.charCodeAt(i); - }; - ascii(0, "RIFF"); - view.setUint32(4, 36 + dataBytes, true); - ascii(8, "WAVE"); - ascii(12, "fmt "); - view.setUint32(16, 16, true); - view.setUint16(20, 1, true); // PCM - view.setUint16(22, 1, true); // mono - view.setUint32(24, 16000, true); - view.setUint32(28, 32000, true); // byte rate - view.setUint16(32, 2, true); // block align - view.setUint16(34, 16, true); // bits per sample - ascii(36, "data"); - view.setUint32(40, dataBytes, true); - return header; -} diff --git a/app/native/wav-recorder.ios.ts b/app/native/wav-recorder.ios.ts deleted file mode 100644 index ff5e815a..00000000 --- a/app/native/wav-recorder.ios.ts +++ /dev/null @@ -1,75 +0,0 @@ -import { knownFolders, path as paths } from '@nativescript/core' -import { wavHeader } from './wav-header' - -// About a second of 16 kHz mono PCM16: written in batches, not per 50 ms packet. -const FLUSH_BYTES = 32000 - -/** - * Appends 16 kHz mono PCM16 to a WAV file in Documents/Downloads while it is - * captured. The header's sizes are rewritten on every flush, so a crash leaves a - * playable file of everything up to the last second. - */ -export class WavRecorder { - private pending: Uint8Array[] = [] - private pendingBytes = 0 - private dataBytes = 0 - - private constructor(private handle: NSFileHandle | null, readonly path: string) {} - - /** A recorder for Downloads/.wav (a -2, -3... suffix if taken), or null. */ - static open(name: string): WavRecorder | null { - const fm = NSFileManager.defaultManager - const dir = paths.join(knownFolders.documents().path, 'Downloads') - try { - fm.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(dir, true, null) - let path = paths.join(dir, `${name}.wav`) - for (let n = 2; fm.fileExistsAtPath(path); n++) path = paths.join(dir, `${name}-${n}.wav`) - if (!fm.createFileAtPathContentsAttributes(path, toData(wavHeader(0)), null)) return null - const handle = NSFileHandle.fileHandleForWritingAtPath(path) - if (!handle || !handle.seekToEndReturningOffsetError(null)) return null - return new WavRecorder(handle, path) - } catch { - return null - } - } - - append(pcm: Uint8Array): void { - if (!this.handle || !pcm.length) return - this.pending.push(pcm.slice()) - this.pendingBytes += pcm.length - if (this.pendingBytes >= FLUSH_BYTES) this.flush() - } - - close(): void { - this.flush() - try { this.handle?.closeAndReturnError() } catch { /* already closed */ } - this.handle = null - } - - private flush(): void { - const handle = this.handle - if (!handle || !this.pendingBytes) return - const chunk = new Uint8Array(this.pendingBytes) - let offset = 0 - for (const part of this.pending) { chunk.set(part, offset); offset += part.length } - this.pending = [] - this.pendingBytes = 0 - try { - // NativeScript throws a failed call's NSError (storage full, file removed). - handle.writeDataError(toData(chunk)) - handle.seekToOffsetError(0) - handle.writeDataError(toData(wavHeader(this.dataBytes + chunk.length))) - handle.seekToEndReturningOffsetError(null) - this.dataBytes += chunk.length - return - } catch { - // Stop recording rather than retry. - } - try { handle.closeAndReturnError() } catch { /* ignore */ } - this.handle = null - } -} - -function toData(bytes: Uint8Array): NSData { - return NSData.dataWithBytesLength(interop.handleof(bytes.buffer), bytes.byteLength) -} diff --git a/app/native/wear-bridge-types.ts b/app/native/wear-bridge-types.ts new file mode 100644 index 00000000..39241d62 --- /dev/null +++ b/app/native/wear-bridge-types.ts @@ -0,0 +1,52 @@ +/** + * 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; + nodeId: string; +}; + +export type WearWatchConnection = { + reachable: boolean; + watchName: string; +}; + +export function parseWearPayload(json: string): Record { + try { + const parsed = JSON.parse(json); + return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}; + } catch { + return {}; + } +} diff --git a/app/native/wear-bridge.ios.ts b/app/native/wear-bridge.ios.ts new file mode 100644 index 00000000..d498e136 --- /dev/null +++ b/app/native/wear-bridge.ios.ts @@ -0,0 +1,123 @@ +/** + * 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() + private readonly connectionListeners = new Set() + + 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, 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): 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): 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() diff --git a/app/native/wear-bridge.ts b/app/native/wear-bridge.ts index a2871218..ede435ef 100644 --- a/app/native/wear-bridge.ts +++ b/app/native/wear-bridge.ts @@ -9,47 +9,12 @@ * 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; - nodeId: string; -}; - -export type WearWatchConnection = { - reachable: boolean; - watchName: string; -}; - type MessageListener = (message: WearMessage) => void; type ConnectionListener = (connection: WearWatchConnection) => void; @@ -91,7 +56,7 @@ class WearBridge { onMessage: (path: string, json: string, nodeId: string) => { const message: WearMessage = { path: String(path), - payload: parsePayload(String(json)), + payload: parseWearPayload(String(json)), nodeId: String(nodeId), }; for (const listener of Array.from(this.messageListeners)) { @@ -177,13 +142,4 @@ class WearBridge { } } -function parsePayload(json: string): Record { - try { - const parsed = JSON.parse(json); - return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}; - } catch { - return {}; - } -} - export const wearBridge = new WearBridge(); diff --git a/app/phone-ui/README.md b/app/phone-ui/README.md index c8d13a6c..efcf0d54 100644 --- a/app/phone-ui/README.md +++ b/app/phone-ui/README.md @@ -1,10 +1,17 @@ # Main-screen UI Android and iOS share `remote-controls.xml`, `remote-controls.css`, and -`RemoteControlsViewModel`: tab order and selection, screen-size choices, -brightness/Auto settings, watch labels, ring markings, and microphone/keyboard -buttons. Import the stylesheet at the top of each platform's application CSS -(before any rules), so the NativeScript CSS pipeline includes it. +`RemoteControlsViewModel`: the bar of icon buttons under the mirror (the +foreground EvenHub app's phone UI, microphone, keyboard, settings) and the +touchpad below it, which is the simulated watch face or the ring pad according +to the Phone input style setting. The settings button opens `settings-page.xml` +(`SettingsViewModel`, `settings-page.css`), also shared: display mode, +brightness/Auto, Phone input style and battery levels. That page needs no host: +it reads the settings store, the shell's battery levels and +`g2/glasses-presence`, which both platforms' controllers feed. Import the +stylesheets at the top of each platform's application CSS (before any rules), +so the NativeScript CSS pipeline includes them; iOS also has to register each +shared page in `onboarding-register.ios.ts`. Android's `MainViewModel` extends that shared model and connects it to `dashboardController`. iOS loads the same XML with `Builder.load` and connects @@ -28,6 +35,8 @@ audio input in preview mode. The phone path requires both Speech Recognition and Microphone permissions and stops when Faceclaw leaves the foreground; connected-glasses capture retains its existing background behavior. -The iOS microphone and keyboard image assets are 3x rasterizations of the -Android vector drawables with the same names; regenerate them from those -vectors if the icon designs change. +The iOS microphone, keyboard and settings image assets (`ic_control_*`) are 3x +rasterizations of the Android vector drawables with the same names; regenerate +them from those vectors if the icon designs change. The EvenHub button's icon +is the app's own, rendered white on transparent; `.control-icon` tints all four +alike. diff --git a/app/phone-ui/g1-flash-view-model.ts b/app/phone-ui/g1-flash-view-model.ts new file mode 100644 index 00000000..b83d61e6 --- /dev/null +++ b/app/phone-ui/g1-flash-view-model.ts @@ -0,0 +1,489 @@ +import { Frame, Observable } from "@nativescript/core"; + +import { G1ArmScanner } from "../g1/arm-scanner"; +import { EVEN_G1_RESTORE } from "../g1/even-firmware"; +import { G1V0_IMAGE } from "../g1/firmware/g1v0-image"; +import { + buildEvenG1Firmware, + buildG1Firmware, + type BuiltEvenG1Firmware, + type BuiltG1Firmware, + type G1BuildProgress, +} from "../g1/firmware-builder"; +import { saveG1Arm, saveG1Pair } from "../g1/addresses"; +import { + G1_CASE_DELAY_HINT, + G1_CASE_INSTRUCTIONS, + G1_INSTALL_NOTICE, + G1_SIDES, + G1_UNINSTALL_NOTICE, + G1_UNINSTALL_SIDES, + g1FlashPercent, + type G1FlashResult, + type G1Side, +} from "../g1/flash-plan"; +import { loadDeviceAddresses, loadPairedGlassesIdentity } from "../g2/device-addresses"; +import { downloadAndExtractEvenHubFonts, hasExtractedEvenHubFonts } from "../g2/firmware-builder"; +import { type GlassesPairCandidate } from "../g2/pairing-candidates"; +import { resumeAutoReconnect, suppressAutoReconnect } from "../g2/reconnect-policy"; +import { ensureBlePermissions } from "../native/ble-permissions"; +import { forgetG1Pairing, G1Flasher, type G1FlasherOptions } from "../native/g1-flasher"; +import { formatErrorMessage } from "../util/format-error"; +import { finishOnboardingNavigation } from "./onboarding-navigation"; +import { setOnboardingCompleted, setPreviewOnlyMode } from "./onboarding-state"; + +type Phase = "intro" | "preparing" | "flashing" | "flashed" | "error"; + +const LOCATE_MS = 45_000; +/** An arm takes about 20 s to copy the image, and a hung boot resets itself within two minutes. */ +const RETURN_MS = 240_000; +/** Even's image is larger than g1v0, and MCUboot first installs the network core's. */ +const RESTORE_RETURN_MS = 300_000; +/** + * Just after its reset an arm may still be heard on g1v0. Later than this, one heard on g1v0 has booted it again: + * MCUboot didn't take Even's firmware. + */ +const OLD_FIRMWARE_GRACE_MS = 15_000; +const CONNECT_MS = 60_000; +/** A new arm pairs only once it knows it's in the case, which a full case can take a while to tell it. */ +const FIRST_PAIRING_MS = 120_000; + +/** + * The install and uninstall page on a G1, in place of OnboardingFlashViewModel. The two arms are separate devices that + * each take the image over MCUmgr (G1ArmFlashFlow), left first; an uninstall goes right first and puts back both of + * Even's images, the network core's too. There is nothing on the lens to confirm with while an arm runs Even's + * firmware, so the confirmation is on the phone: the page before, or this one's intro. + * + * Every run starts by listening for what each arm runs now, so a retry picks up wherever the last one stopped. An arm's + * new address is saved as soon as it's known. + */ +export class G1FlashViewModel extends Observable { + private phase: Phase = "intro"; + private readonly fromOnboarding: boolean; + private readonly uninstalling: boolean; + private readonly scanner = new G1ArmScanner(); + private image: BuiltG1Firmware | null = null; + private evenImage: BuiltEvenG1Firmware | null = null; + private flasher: G1Flasher | null = null; + private generation = 0; + private disposed = false; + private unpairedArm = false; + /** An uninstall's outcome, for the last page: an arm's store erased, a pairing this phone couldn't remove, an arm done. */ + private wiped = false; + private pairingLeft = false; + private restoredArm = false; + + headline = "Install Faceclaw's Firmware"; + status = ""; + log = ""; + busy = false; + progress = 0; + + constructor(options?: { mode?: "install" | "uninstall"; fromOnboarding?: boolean; autoStart?: boolean }) { + super(); + this.fromOnboarding = options?.fromOnboarding ?? true; + this.uninstalling = options?.mode === "uninstall"; + suppressAutoReconnect(); + if (this.uninstalling) { + this.headline = "Back to Even's Firmware"; + this.status = `${G1_CASE_INSTRUCTIONS}\n\n${G1_UNINSTALL_NOTICE}`; + } else { + this.status = `${G1_CASE_INSTRUCTIONS}\n\n${G1_INSTALL_NOTICE}`; + } + if (options?.autoStart) void this.run(); + } + + // --- what the page binds -------------------------------------------------- + + get logVisibility(): "visible" | "collapse" { + return this.log ? "visible" : "collapse"; + } + + get busyVisibility(): "visible" | "collapse" { + return this.busy ? "visible" : "collapse"; + } + + get progressVisibility(): "visible" | "collapse" { + return this.phase === "flashing" ? "visible" : "collapse"; + } + + get primaryLabel(): string { + switch (this.phase) { + case "intro": + return this.uninstalling ? "Uninstall" : "Install"; + case "flashed": + return "Finish"; + case "error": + return "Retry"; + default: + return ""; + } + } + + get primaryVisibility(): "visible" | "collapse" { + return this.primaryLabel ? "visible" : "collapse"; + } + + get secondaryLabel(): string { + return "Back"; + } + + get secondaryVisibility(): "visible" | "collapse" { + // No way out mid-install, or after one. + return this.phase === "preparing" || this.phase === "flashing" || this.phase === "flashed" ? "collapse" : "visible"; + } + + onPrimaryTap(): void { + if (this.phase === "intro" || this.phase === "error") void this.run(); + else if (this.phase === "flashed") this.finish(); + } + + onSecondaryTap(): void { + if (this.phase === "intro" || this.phase === "error") this.leave(); + } + + // --- the install ---------------------------------------------------------- + + private async run(): Promise { + const generation = ++this.generation; + const live = () => !this.disposed && generation === this.generation; + this.setPhase("preparing"); + this.setBusy(true); + this.setText("Preparing Firmware", this.uninstalling ? "Getting Even's firmware ready..." : "Getting the firmware ready..."); + try { + await ensureBlePermissions(); + if (!live()) return; + if (this.uninstalling) { + if (!this.evenImage) { + this.evenImage = await buildEvenG1Firmware((progress) => { + if (live()) this.setStatus(describeEvenBuild(progress)); + }); + this.appendLog(`Even's firmware ${this.evenImage.version} downloaded and verified (${this.evenImage.bytes.toLocaleString()} bytes)`); + } + } else { + if (!this.image) { + this.image = await buildG1Firmware((progress) => { + if (live()) this.setStatus(describeBuild(progress)); + }); + this.appendLog(`firmware ${this.image.version} prepared and verified (${this.image.bytes.toLocaleString()} bytes)`); + } + await this.prepareFonts(live); + } + if (!live()) return; + + this.setPhase("flashing"); + this.setText(this.uninstalling ? "Restoring Even's Firmware" : "Installing Firmware", "Listening for your glasses..."); + const identity = loadPairedGlassesIdentity(); + const stored = loadDeviceAddresses(); + const pair = await this.scanner.waitForPair({ serial: identity?.serial, left: stored.left, right: stored.right }, LOCATE_MS); + if (!live()) return; + if (!pair) { + throw new Error("Couldn't hear both arms of your glasses. Make sure they're in the case with the lid open, and that no other app " + + "or phone is connected to them, then retry."); + } + saveG1Pair(pair); + + if (this.uninstalling) { + for (const side of G1_UNINSTALL_SIDES) { + await this.restoreArm(side, pair, live); + if (!live()) return; + } + this.restored(); + return; + } + this.unpairedArm = false; + for (const side of G1_SIDES) { + await this.installArm(side, pair, live); + if (!live()) return; + } + this.finished(); + } catch (error) { + if (live()) this.failed(formatErrorMessage(error)); + } + } + + private async installArm(side: G1Side, pair: GlassesPairCandidate, live: () => boolean): Promise { + const arm = pair[side]!; + const fromStock = arm.g1Firmware === "stock"; + this.setProgress(g1FlashPercent(side, 0, 1)); + this.setStatus(`Connecting to the ${side} arm...`); + const installed = await this.flash({ + address: arm.address, + side, + firmwarePath: this.image!.path, + mode: fromStock ? "stock" : "update", + connectWindowMs: CONNECT_MS, + }, (state) => { + if (state === "pairing") this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`); + else if (state === "checking") this.setStatus(`Checking the ${side} arm...`); + else if (state === "flashing") this.setStatus(`Sending the firmware to the ${side} arm. Nothing has changed yet.`); + else if (state === "committing") this.setStatus(`Installing on the ${side} arm. Keep the glasses in the case.`); + }, (sent, total) => this.setProgress(g1FlashPercent(side, sent, total))); + if (!live()) return; + this.setProgress(g1FlashPercent(side, 1, 1)); + if (!installed.flashed) { + this.appendLog(`${side} arm already runs ${installed.version}`); + return; + } + + this.setStatus(`The ${side} arm is restarting into the new firmware. This takes about 20 seconds; keep it in the case.`); + const identity = loadPairedGlassesIdentity(); + const back = await this.scanner.waitForG1v0Arm(side, identity?.serial ?? pair.serial, RETURN_MS); + if (!live()) return; + if (!back) { + throw new Error(`The ${side} arm hasn't come back yet. Leave the glasses in the plugged-in case for a few minutes, with the lid ` + + "open: an interrupted install finishes by itself. Then retry."); + } + saveG1Arm(side, back); + // Coming from firmware before 0.5.66, which had an address of its own: the phone needn't remember that one. + if (back.address !== arm.address) forgetG1Pairing(arm.address); + if (back.g1Firmware === "g1v0-safe") { + throw new Error(`The ${side} arm came back in safe mode: the new firmware restarted repeatedly. Retry to install it again.`); + } + + this.setStatus(`Checking the ${side} arm. If your phone asks to pair, accept it. ${G1_CASE_DELAY_HINT}`); + // An arm at a new address has no bond yet (coming from Even's firmware the address is kept from 0.5.66 on, and so is the + // bond). It may refuse one for a while: it's installed either way, and the session pairs it later. + const newAddress = back.address !== arm.address; + let running: G1FlashResult; + try { + running = await this.flash({ + address: back.address, + side, + firmwarePath: "", + mode: "probe", + connectWindowMs: newAddress ? FIRST_PAIRING_MS : RETURN_MS, + }); + } catch (error) { + if (!newAddress || !live()) throw error; + // Installed, as its advertising shows; it just won't pair yet. The next connection pairs it. + this.appendLog(`${side} arm not paired yet: ${formatErrorMessage(error)}`); + this.unpairedArm = true; + return; + } + if (!live()) return; + if (running.version !== installed.version) { + throw new Error(`The ${side} arm runs ${running.version}, not ${installed.version}: it didn't take the new firmware. Retry to try again.`); + } + this.appendLog(`${side} arm runs ${running.version}`); + } + + /** + * Even's firmware back on one arm, then a wait for it to advertise as Even's. An arm already on Even's firmware is + * left alone: a retry goes on from there. + */ + private async restoreArm(side: G1Side, pair: GlassesPairCandidate, live: () => boolean): Promise { + const arm = pair[side]!; + if (arm.g1Firmware === "stock") { + this.appendLog(`${side} arm already runs Even's firmware`); + this.setProgress(g1FlashPercent(side, 1, 1, G1_UNINSTALL_SIDES)); + return; + } + const even = this.evenImage!; + this.setProgress(g1FlashPercent(side, 0, 1, G1_UNINSTALL_SIDES)); + this.setStatus(`Connecting to the ${side} arm...`); + const result = await this.flash({ + address: arm.address, + side, + firmwarePath: even.appPath, + netCorePath: even.netCorePath, + mode: "restore", + connectWindowMs: CONNECT_MS, + }, (state) => { + if (state === "pairing") this.setStatus(`Pairing with the ${side} arm. If your phone asks, accept it.`); + else if (state === "checking") this.setStatus(`Checking the ${side} arm...`); + else if (state === "wiping") { + this.setStatus(`Erasing Faceclaw's storage on the ${side} arm, where Even's fonts were. This can take several minutes; keep the ` + + "glasses in the case. Nothing else has changed yet."); + } else if (state === "flashing") this.setStatus(`Sending Even's firmware to the ${side} arm. Its firmware hasn't changed yet.`); + else if (state === "committing") this.setStatus(`Installing on the ${side} arm. Keep the glasses in the case.`); + }, (sent, total) => this.setProgress(g1FlashPercent(side, sent, total, G1_UNINSTALL_SIDES))); + if (!live()) return; + if (result.wiped) this.wiped = true; + this.setProgress(g1FlashPercent(side, 1, 1, G1_UNINSTALL_SIDES)); + + this.setStatus(`The ${side} arm is restarting into Even's firmware. This takes a minute or two; keep it in the case.`); + const resetAt = Date.now(); + const identity = loadPairedGlassesIdentity(); + const back = await this.scanner.waitForArm(side, identity?.serial ?? pair.serial, RESTORE_RETURN_MS, + (heard) => heard.g1Firmware === "stock" || Date.now() - resetAt >= OLD_FIRMWARE_GRACE_MS); + if (!live()) return; + if (!back) { + throw new Error(`The ${side} arm hasn't come back yet. Leave the glasses in the plugged-in case for a few minutes, with the lid ` + + "open: an interrupted install finishes by itself. Then retry."); + } + if (back.g1Firmware !== "stock") { + throw new Error(`The ${side} arm came back on Faceclaw's firmware: it didn't take Even's. Retry to try again.`); + } + saveG1Arm(side, back); + this.restoredArm = true; + // Even's app makes its own pairing with Even's firmware; the one this phone made with g1v0 would only be in its way. + this.forgetPairing(back.address); + if (back.address !== arm.address) this.forgetPairing(arm.address); + this.appendLog(`${side} arm runs Even's firmware`); + } + + private forgetPairing(address: string): void { + if (!forgetG1Pairing(address)) this.pairingLeft = true; + } + + private async flash( + options: G1FlasherOptions, + onState?: (state: string) => void, + onProgress?: (sent: number, total: number) => void, + ) { + const flasher = new G1Flasher(options); + this.flasher = flasher; + flasher.onLog((line) => this.appendLog(line)); + if (onState) flasher.onState(onState); + if (onProgress) flasher.onProgress(onProgress); + try { + return await flasher.run(); + } finally { + if (this.flasher === flasher) this.flasher = null; + flasher.close(); + } + } + + /** A G2's install gets these from the same download; Faceclaw's fonts are a phone-side matter, so a failure here is no reason to stop. */ + private async prepareFonts(live: () => boolean): Promise { + if (hasExtractedEvenHubFonts()) return; + if (live()) this.setStatus("Preparing fonts..."); + try { + await downloadAndExtractEvenHubFonts(); + } catch (error) { + this.appendLog(`fonts not prepared: ${formatErrorMessage(error)}`); + } + } + + private finished(): void { + // The glasses are ready for the main page to connect to. + resumeAutoReconnect(); + this.setBusy(false); + this.setProgress(100); + this.setPhase("flashed"); + this.setText("All Done", `Both arms run Faceclaw's firmware ${G1V0_IMAGE.version}.` + (this.unpairedArm + ? " Keep the glasses in the case with the lid open until Faceclaw has connected: they only pair in the case." + : "")); + } + + private restored(): void { + // Stays manually disconnected: Faceclaw would only find firmware it can't run. + this.setBusy(false); + this.setProgress(100); + this.setPhase("flashed"); + if (!this.restoredArm) { + this.setText("All Done", "Both arms already run Even's firmware."); + return; + } + const steps = [`Both arms run Even's firmware ${EVEN_G1_RESTORE.version}.`]; + if (this.pairingLeft) { + steps.push("Before pairing them in Even's app, remove both arms in this phone's Bluetooth settings (\"Forget This Device\"): " + + "Faceclaw's firmware made that pairing, and Even's firmware makes its own."); + } else { + steps.push("To use them, pair them in Even's app."); + } + if (this.wiped) { + steps.push("Even's Chinese, Japanese and Korean text and its demo pictures were erased with Faceclaw's storage, and don't come back."); + } + this.setText("All Done", steps.join("\n\n")); + } + + private failed(message: string): void { + this.setBusy(false); + this.setPhase("error"); + this.setText("Something Went Wrong", message); + } + + private finish(): void { + if (!this.uninstalling) { + setPreviewOnlyMode(false); + setOnboardingCompleted(true); + } + this.teardown(); + finishOnboardingNavigation(); + } + + private leave(): void { + this.teardown(); + const frame = Frame.topmost(); + if (this.fromOnboarding && frame?.canGoBack()) { + frame.goBack(); + return; + } + if (!this.fromOnboarding) { + finishOnboardingNavigation(); + return; + } + frame?.navigate({ moduleName: "phone-ui/onboarding-page", clearHistory: true }); + } + + dispose(): void { + this.disposed = true; + this.teardown(); + } + + private teardown(): void { + ++this.generation; + this.scanner.stop(); + this.flasher?.close(); + this.flasher = null; + } + + // --- page state ----------------------------------------------------------- + + private setText(headline: string, status: string): void { + this.set("headline", headline); + this.set("status", status); + } + + private setStatus(status: string): void { + this.set("status", status); + } + + private setBusy(busy: boolean): void { + this.set("busy", busy); + this.notifyPropertyChange("busyVisibility", this.busyVisibility); + } + + private setProgress(percent: number): void { + this.set("progress", Math.max(0, Math.min(100, Math.round(percent)))); + } + + private setPhase(phase: Phase): void { + this.phase = phase; + for (const property of ["primaryLabel", "primaryVisibility", "secondaryVisibility", "progressVisibility"] as const) { + this.notifyPropertyChange(property, this[property]); + } + } + + private appendLog(line: string): void { + const stamp = new Date().toISOString().slice(11, 19); + this.set("log", this.log ? `${this.log}\n[${stamp}] ${line}` : `[${stamp}] ${line}`); + this.notifyPropertyChange("logVisibility", this.logVisibility); + } +} + +function describeEvenBuild(progress: G1BuildProgress): string { + switch (progress) { + case "downloading": + return "Downloading Even's firmware from Even's firmware server..."; + case "verifying": + return "Verifying the download..."; + default: + return "Saving the firmware..."; + } +} + +function describeBuild(progress: G1BuildProgress): string { + switch (progress) { + case "downloading": + return "Downloading the parts it needs from Even's firmware server..."; + case "verifying": + return "Verifying the download..."; + case "assembling": + return "Assembling the firmware..."; + default: + return "Saving the firmware..."; + } +} diff --git a/app/phone-ui/main-page.ios.ts b/app/phone-ui/main-page.ios.ts index 5f647c99..2054fad6 100644 --- a/app/phone-ui/main-page.ios.ts +++ b/app/phone-ui/main-page.ios.ts @@ -10,8 +10,6 @@ import { sampleBleTraffic } from '../native/ble-traffic' import { onAnySettingChanged, mirrorTouchSetting, showBleBandwidthSetting } from '../ui/dashboard-settings' import { loadDeviceAddresses } from '../g2/device-addresses' import { deviceAddressError } from '../g2/ios-peripheral-identity' -import { formatBatteryLine } from '../g2/glasses-display-state' -import { shell } from '../ui/shell/shell' export function createMainPage(): Page { const page = new Page() @@ -22,37 +20,26 @@ export function createMainPage(): Page { root.rows = 'auto,*' page.content = root const header = new GridLayout() - header.columns = '*,auto,auto,auto,auto'; header.className = 'main-header' + header.columns = '*,auto,auto,auto'; header.className = 'main-header' const title = new Label() title.text = 'Faceclaw'; title.className = 'action-bar-title' header.addChild(title) - // The foreground EvenHub app's icon, which opens its phone UI. UIImageView - // ignores padding, so a wrapper supplies Android's wider tap target. - const appIconButton = new GridLayout() - appIconButton.className = 'action-bar-app-icon'; appIconButton.verticalAlignment = 'middle' - appIconButton.visibility = 'collapse'; appIconButton.accessible = true - const appIcon = new Image() - appIcon.width = 21; appIcon.height = 21 - appIconButton.addChild(appIcon) - let phoneUiWindowId: string | null = null - appIconButton.on('tap', () => { if (phoneUiWindowId) controller.showEvenHubPhoneUi(phoneUiWindowId) }) - GridLayout.setColumn(appIconButton, 1); header.addChild(appIconButton) const state = new Label() state.text = 'Preview'; state.className = 'action-bar-status' state.verticalAlignment = 'middle' state.on('tap', () => { void openDevices() }) - GridLayout.setColumn(state, 2); header.addChild(state) + GridLayout.setColumn(state, 1); header.addChild(state) // Android's warning triangle: shown while the glasses report firmware Faceclaw can't run. const warning = new Label() warning.text = '\u26A0\uFE0F'; warning.className = 'action-bar-warning' warning.accessibilityLabel = 'Attention needed'; warning.verticalAlignment = 'middle' warning.visibility = 'collapse' warning.on('tap', () => { void showFirmwareWarning() }) - GridLayout.setColumn(warning, 3); header.addChild(warning) + GridLayout.setColumn(warning, 2); header.addChild(warning) const overflow = new Button() overflow.text = '⋮'; overflow.accessibilityLabel = 'More options'; overflow.className = 'overflow-button' overflow.on('tap', () => openMenu()) - GridLayout.setColumn(overflow, 4); header.addChild(overflow); root.addChild(header) + GridLayout.setColumn(overflow, 3); header.addChild(overflow); root.addChild(header) const body = new GridLayout() GridLayout.setRow(body, 1); root.addChild(body) const mirror = new Image() @@ -72,10 +59,6 @@ export function createMainPage(): Page { keyboardPanel.bindingContext = keyboardModel GridLayout.setRow(keyboardPanel, 1); root.addChild(keyboardPanel) let focusTimer: ReturnType | null = null - // The Settings tab's battery row. iOS reports charging sessions as - // connected, so "connected" is the whole live-link condition here. - let glassesLinked = false - const refreshBatteryLine = () => { model.batteryLine = formatBatteryLine(shell.getBatteryLevels(), glassesLinked) } const keyboardField = () => keyboardPanel.getViewById('keyboardInputField') const controller = new IosPreviewController((image, label) => { mirror.imageSource = image; model.set('padFocusLine', label) @@ -85,7 +68,6 @@ export function createMainPage(): Page { state.text = ({ connected: 'Connected', disconnected: 'Preview', connecting: 'Connecting', retrying: 'Reconnecting', disconnecting: 'Disconnecting', error: 'Failed' })[connection.phase] warning.visibility = connection.firmwareWarning ? 'visible' : 'collapse' - glassesLinked = connection.phase === 'connected'; refreshBatteryLine() }, session => { keyboardModel.setSession(session) controls.visibility = session ? 'collapse' : 'visible' @@ -95,11 +77,10 @@ export function createMainPage(): Page { focusTimer = setTimeout(() => { focusTimer = null; keyboardField()?.focus() }, 0) } else keyboardField()?.dismissSoftInput() }, button => { - phoneUiWindowId = button?.icon ? button.windowId : null - appIcon.imageSource = button?.icon ?? null - appIconButton.visibility = phoneUiWindowId ? 'visible' : 'collapse' - appIconButton.accessibilityLabel = button ? `Open ${button.title} on phone` : '' + // The foreground EvenHub app's button in the bar under the mirror. + model.evenHubPhoneUi = button }) + model.showEvenHubPhoneUi = windowId => controller.showEvenHubPhoneUi(windowId) async function navigateDevicePage(moduleName: string, context?: object): Promise { suppressAutoReconnect() await controller.disconnect() @@ -190,7 +171,8 @@ export function createMainPage(): Page { mirror.on('touch', touch(mirrorInput)) const cancelGestures = () => { watchInput.cancel(); ringInput.cancel(); mirrorInput.cancel() } model.on('propertyChange', (args: PropertyChangeData) => { - if (args.propertyName === 'watchTabVisibility') cancelGestures() + // The other pad took this one's place (Settings > Phone input style). + if (args.propertyName === 'watchPadVisibility') cancelGestures() }) let controlsLayoutTimer: ReturnType | null = null model.set('onControlsContentLayoutChanged', (args: { object: View }) => { @@ -263,7 +245,6 @@ export function createMainPage(): Page { const resume = () => { foreground = true; controller.resume(); syncBandwidth() } let keyboardObserver: any = null let offSettings: (() => void) | null = null - let offBattery: (() => void) | null = null page.on('loaded', () => { if (!keyboardObserver) keyboardObserver = NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock( UIKeyboardWillChangeFrameNotification, null, NSOperationQueue.mainQueue, notification => { @@ -273,16 +254,15 @@ export function createMainPage(): Page { root.paddingBottom = Math.max(0, view.bounds.size.height - local.origin.y - view.safeAreaInsets.bottom) }) Application.on(Application.suspendEvent, pause); Application.on(Application.resumeEvent, resume) - offSettings?.(); offSettings = onAnySettingChanged(() => { model.refreshDisplayControls(); syncBandwidth() }) - offBattery?.(); offBattery = shell.onBatteryLevelsChanged(refreshBatteryLine) - model.refreshDisplayControls(); refreshBatteryLine(); resume() + offSettings?.(); offSettings = onAnySettingChanged(() => { model.refreshInputStyle(); syncBandwidth() }) + model.refreshInputStyle(); resume() if (!isPreviewOnlyMode() && !isAutoReconnectSuppressed() && !deviceAddressError(loadDeviceAddresses())) void controller.connect() }) page.on('unloaded', () => { if (keyboardObserver) NSNotificationCenter.defaultCenter.removeObserver(keyboardObserver) keyboardObserver = null root.paddingBottom = 0 - pause(); offSettings?.(); offSettings = null; offBattery?.(); offBattery = null + pause(); offSettings?.(); offSettings = null Application.off(Application.suspendEvent, pause); Application.off(Application.resumeEvent, resume) }) return page diff --git a/app/phone-ui/main-page.xml b/app/phone-ui/main-page.xml index 846fa253..29c12f08 100644 --- a/app/phone-ui/main-page.xml +++ b/app/phone-ui/main-page.xml @@ -1,13 +1,12 @@ - - + + @@ -15,6 +14,7 @@ + @@ -31,8 +31,8 @@ visibility="{{ displayPreviewMessageVisibility }}">