From bbc8b271fba54f5217bd277ef4808487d98056e4 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 11:22:23 -0500
Subject: [PATCH 01/34] feat(debug): PoC live device screen mirror + remote
D-pad (Mirror tab)
Consumes the DisplayFrame PoC protobufs (2.99.0-screen-mirror-poc-SNAPSHOT
from mavenLocal, useMavenLocal committed on this branch): DisplayMirrorManager
reassembles FromRadio.display_frame chunks into MirrorFrame snapshots,
AdminController gains setDisplayMirror + sendInputEvent, and the Debug panel
gains a Mirror tab rendering the device's 1bpp framebuffer live with a D-pad
driving the firmware InputBroker. PoC: tab strings deliberately unlocalized.
---
.../data/manager/DisplayMirrorManagerImpl.kt | 79 ++++++++++
.../manager/FromRadioPacketHandlerImpl.kt | 8 +
.../core/repository/AdminController.kt | 12 ++
.../core/repository/DisplayMirrorManager.kt | 58 +++++++
.../core/service/AdminControllerImpl.kt | 18 +++
.../feature/settings/debugging/Debug.kt | 10 ++
.../settings/debugging/DisplayMirror.kt | 149 ++++++++++++++++++
gradle.properties | 3 +
gradle/libs.versions.toml | 5 +-
9 files changed, 341 insertions(+), 1 deletion(-)
create mode 100644 core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
create mode 100644 core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
create mode 100644 feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
new file mode 100644
index 00000000000..6c273a2cafa
--- /dev/null
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.data.manager
+
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.koin.core.annotation.Single
+import org.meshtastic.core.repository.DisplayMirrorManager
+import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.proto.DisplayFrame
+
+/**
+ * Display frame reassembly state machine.
+ *
+ * Chunks arrive in offset order within a frame (the firmware drains one snapshot before capturing the next), so a
+ * chunk with a new `frame_id` or `offset == 0` starts a new frame and an out-of-sequence chunk drops the partial
+ * frame. Called sequentially from [FromRadioPacketHandlerImpl] on a single IO coroutine.
+ */
+@Single
+class DisplayMirrorManagerImpl : DisplayMirrorManager {
+
+ private val _frame = MutableStateFlow(null)
+ override val frame = _frame.asStateFlow()
+
+ private var buffer: ByteArray? = null
+ private var frameId = 0
+ private var received = 0
+
+ override fun handleIncomingFrame(chunk: DisplayFrame) {
+ val data = chunk.data_.toByteArray()
+ val total = chunk.total_size
+
+ if (total <= 0 || total > MAX_FRAME_BYTES || chunk.offset + data.size > total) {
+ Logger.w { "DisplayMirror: dropping malformed chunk (offset=${chunk.offset} size=${data.size} total=$total)" }
+ return
+ }
+
+ if (chunk.offset == 0) {
+ buffer = ByteArray(total)
+ frameId = chunk.frame_id
+ received = 0
+ }
+
+ val buf = buffer
+ if (buf == null || chunk.frame_id != frameId || chunk.offset != received || buf.size != total) {
+ Logger.w { "DisplayMirror: out-of-sequence chunk (frame=${chunk.frame_id}/$frameId offset=${chunk.offset}/$received)" }
+ buffer = null
+ return
+ }
+
+ data.copyInto(buf, chunk.offset)
+ received += data.size
+
+ if (received == total) {
+ _frame.value = MirrorFrame(width = chunk.width, height = chunk.height, frameId = frameId, pixels = buf)
+ buffer = null
+ }
+ }
+
+ private companion object {
+ // Generous sanity cap: 320x240 at 1bpp is 9600 bytes.
+ const val MAX_FRAME_BYTES = 16384
+ }
+}
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
index 0253f8f9063..47ad420eb03 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
@@ -22,6 +22,7 @@ import kotlinx.coroutines.SupervisorJob
import org.koin.core.annotation.Single
import org.meshtastic.core.common.util.ioDispatcher
import org.meshtastic.core.model.util.isOtaStatusNotification
+import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.FirmwareUpdateStatusRepository
import org.meshtastic.core.repository.FromRadioPacketHandler
import org.meshtastic.core.repository.LockdownCoordinator
@@ -54,6 +55,7 @@ class FromRadioPacketHandlerImpl(
private val configFlowManager: Lazy,
private val configHandler: Lazy,
private val xmodemManager: Lazy,
+ private val displayMirrorManager: Lazy,
private val mqttManager: MqttManager,
private val packetHandler: PacketHandler,
private val serviceNotifications: MeshNotificationManager,
@@ -83,6 +85,7 @@ class FromRadioPacketHandlerImpl(
val regionPresets = proto.region_presets
val xmodemPacket = proto.xmodemPacket
val lockdownStatus = proto.lockdown_status
+ val displayFrame = proto.display_frame
when {
myInfo != null -> configFlowManager.value.handleMyInfo(myInfo, session)
@@ -130,6 +133,11 @@ class FromRadioPacketHandlerImpl(
xmodemPacket != null ->
runIfSessionActive(session, "XModem packet") { xmodemManager.value.handleIncomingXModem(xmodemPacket) }
+ displayFrame != null ->
+ runIfSessionActive(session, "display frame") {
+ displayMirrorManager.value.handleIncomingFrame(displayFrame)
+ }
+
lockdownStatus != null ->
runIfSessionActive(session, "lockdown status") {
lockdownCoordinator.handleLockdownStatus(lockdownStatus)
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
index 9e4adf7fee5..bf3f4af42d3 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
@@ -51,6 +51,18 @@ interface AdminController {
/** Updates a local radio channel. Same fire-and-forget contract as [setLocalConfig]. */
suspend fun setLocalChannel(channel: Channel)
+ /**
+ * Enables or disables live display mirroring on the locally connected node. While enabled, the device streams its
+ * framebuffer as `FromRadio.display_frame` chunks — collect them via [DisplayMirrorManager].
+ */
+ suspend fun setDisplayMirror(enabled: Boolean)
+
+ /**
+ * Injects a physical input event (button/key/touch) into the locally connected node's UI via the firmware
+ * InputBroker. Event codes are the firmware's `input_broker_event` values.
+ */
+ suspend fun sendInputEvent(eventCode: Int, kbChar: Int = 0, touchX: Int = 0, touchY: Int = 0)
+
// ── Remote configuration ────────────────────────────────────────────────
/** Updates the owner (user info) on a remote node. */
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
new file mode 100644
index 00000000000..aaabf8a87e6
--- /dev/null
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.repository
+
+import kotlinx.coroutines.flow.StateFlow
+import org.meshtastic.proto.DisplayFrame
+
+/**
+ * Reassembles the chunked [DisplayFrame] stream from the connected device into complete framebuffer snapshots.
+ *
+ * The device streams its 1bpp framebuffer as `FromRadio.display_frame` chunks while display mirroring is enabled
+ * (see `AdminMessage.set_display_mirror`). Chunks of one frame share a `frame_id`; a frame is complete when
+ * `offset + data.size == total_size`.
+ */
+interface DisplayMirrorManager {
+ /** Latest completely reassembled frame, or null before the first one arrives. */
+ val frame: StateFlow
+
+ /** Routes an incoming display frame chunk from the device to the reassembly state machine. */
+ fun handleIncomingFrame(chunk: DisplayFrame)
+}
+
+/**
+ * One complete device framebuffer snapshot.
+ *
+ * [pixels] is MONO_VLSB: 1 bit per pixel in vertical LSB-first pages — byte index = `x + (y / 8) * width`,
+ * bit index = `y % 8`.
+ */
+data class MirrorFrame(val width: Int, val height: Int, val frameId: Int, val pixels: ByteArray) {
+ override fun equals(other: Any?): Boolean =
+ other is MirrorFrame &&
+ other.width == width &&
+ other.height == height &&
+ other.frameId == frameId &&
+ other.pixels.contentEquals(pixels)
+
+ override fun hashCode(): Int {
+ var result = width
+ result = 31 * result + height
+ result = 31 * result + frameId
+ result = 31 * result + pixels.contentHashCode()
+ return result
+ }
+}
diff --git a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
index d47c3fdfb79..48a6d24f088 100644
--- a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
+++ b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
@@ -139,6 +139,24 @@ internal class AdminControllerImpl(
scope.handledLaunch { radioConfigRepository.setLocalConfig(config) }
}
+ override suspend fun setDisplayMirror(enabled: Boolean) {
+ commandSender.sendAdmin(myNodeNum) { AdminMessage(set_display_mirror = enabled) }
+ }
+
+ override suspend fun sendInputEvent(eventCode: Int, kbChar: Int, touchX: Int, touchY: Int) {
+ commandSender.sendAdmin(myNodeNum) {
+ AdminMessage(
+ send_input_event =
+ AdminMessage.InputEvent(
+ event_code = eventCode,
+ kb_char = kbChar,
+ touch_x = touchX,
+ touch_y = touchY,
+ ),
+ )
+ }
+ }
+
override suspend fun setConfig(destNum: Int, config: Config, packetId: Int) {
commandSender.sendAdmin(destNum, packetId) {
AdminMessage.Builder().also { wb -> wb.set_config = config }.build()
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
index 5af74080756..cf581fae895 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
@@ -185,11 +185,21 @@ fun DebugScreen(onNavigateUp: () -> Unit, viewModel: DebugViewModel) {
onClick = { selectedTab = 1 },
text = { Text(stringResource(Res.string.debug_tab_app_logs)) },
)
+ Tab(
+ selected = selectedTab == 2,
+ onClick = { selectedTab = 2 },
+ // PoC tab; deliberately unlocalized.
+ text = { Text("Mirror") },
+ )
}
if (selectedTab == 1) {
LogcatContent(modifier = Modifier.fillMaxSize())
return@Column
}
+ if (selectedTab == 2) {
+ DisplayMirrorContent(modifier = Modifier.fillMaxSize())
+ return@Column
+ }
LazyColumn(modifier = Modifier.fillMaxSize(), state = listState) {
stickyHeader {
val animatedAlpha by
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
new file mode 100644
index 00000000000..f3774f0f0a9
--- /dev/null
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import org.koin.compose.viewmodel.koinViewModel
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.repository.DisplayMirrorManager
+import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.RadioController
+
+// Firmware input_broker_event codes (src/input/InputBroker.h).
+private const val INPUT_SELECT = 10
+private const val INPUT_UP = 17
+private const val INPUT_DOWN = 18
+private const val INPUT_LEFT = 19
+private const val INPUT_RIGHT = 20
+private const val INPUT_BACK = 27
+
+@KoinViewModel
+class DisplayMirrorViewModel(
+ displayMirrorManager: DisplayMirrorManager,
+ private val radioController: RadioController,
+) : ViewModel() {
+
+ val frame: StateFlow = displayMirrorManager.frame
+
+ private val _mirroring = MutableStateFlow(false)
+ val mirroring: StateFlow = _mirroring.asStateFlow()
+
+ fun setMirror(enabled: Boolean) {
+ viewModelScope.launch {
+ radioController.setDisplayMirror(enabled)
+ _mirroring.value = enabled
+ }
+ }
+
+ fun sendKey(eventCode: Int) {
+ viewModelScope.launch { radioController.sendInputEvent(eventCode) }
+ }
+}
+
+/** PoC live view of the connected device's screen, with remote D-pad control. Strings are deliberately unlocalized. */
+@Composable
+fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
+ val frame by viewModel.frame.collectAsStateWithLifecycle()
+ val mirroring by viewModel.mirroring.collectAsStateWithLifecycle()
+
+ Column(
+ modifier = modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ Switch(checked = mirroring, onCheckedChange = viewModel::setMirror)
+ Text(text = if (mirroring) "Mirroring" else "Mirror off", style = MaterialTheme.typography.titleMedium)
+ }
+
+ val currentFrame = frame
+ if (currentFrame != null) {
+ MirrorFrameCanvas(currentFrame)
+ Text(
+ text = "${currentFrame.width}x${currentFrame.height} frame #${currentFrame.frameId}",
+ style = MaterialTheme.typography.labelSmall,
+ )
+ } else {
+ Text(text = "No frame received yet — enable mirroring above.")
+ }
+
+ // Remote D-pad
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_UP) }) { Text("Up") }
+ }
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_LEFT) }) { Text("Left") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_SELECT) }) { Text("OK") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_RIGHT) }) { Text("Right") }
+ }
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_DOWN) }) { Text("Down") }
+ }
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_BACK) }) { Text("Back") }
+ }
+ }
+}
+
+/** Draws a MONO_VLSB 1bpp framebuffer scaled to the available width, one filled rect per lit pixel. */
+@Composable
+private fun MirrorFrameCanvas(frame: MirrorFrame) {
+ val aspect = frame.width.toFloat() / frame.height.toFloat()
+ Canvas(modifier = Modifier.fillMaxWidth().aspectRatio(aspect).background(Color.Black)) {
+ val scale = size.width / frame.width
+ val pixel = Size(scale, scale)
+ for (y in 0 until frame.height) {
+ val page = (y / 8) * frame.width
+ val bit = 1 shl (y % 8)
+ for (x in 0 until frame.width) {
+ val index = page + x
+ if (index < frame.pixels.size && frame.pixels[index].toInt() and bit != 0) {
+ drawRect(color = Color.White, topLeft = Offset(x * scale, y * scale), size = pixel)
+ }
+ }
+ }
+ }
+}
diff --git a/gradle.properties b/gradle.properties
index d2a21957fe6..59fcb23b693 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -40,3 +40,6 @@ org.gradle.priority=low
# stays parallel if Isolated Projects is ever off.
org.gradle.tooling.parallel=true
org.gradle.welcome=never
+
+# PoC: resolve org.meshtastic:protobufs 2.99.0-screen-mirror-poc-SNAPSHOT from mavenLocal
+useMavenLocal=true
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 0d69db90b53..d63010b182a 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -109,7 +109,10 @@ jmdns = "3.6.4"
dbus-java = "5.2.2"
qrcode-kotlin = "4.5.0"
takpacket-sdk = "0.9.3"
-meshtastic-protobufs = "2.8.1.11-g28f4f5f-SNAPSHOT"
+# PoC: DisplayFrame screen mirroring, locally published from protobufs@screen-mirror-poc.
+# Revert to main's pin once protobufs#1054 lands. main pins 2.8.1.11-g28f4f5f-SNAPSHOT.
+# (requires -PuseMavenLocal or the gradle.properties flag on this branch)
+meshtastic-protobufs = "2.99.0-screen-mirror-poc-SNAPSHOT"
# Gradle Plugins
ccud = "2.8.0"
From b90146f7af4c00953506b8dfc277e591522c965c Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 11:34:34 -0500
Subject: [PATCH 02/34] fix(debug): keep the Mirror tab's D-pad above the fold
Cap the mirror canvas at 512.dp (4x for a 128px OLED) instead of filling
the window width, fold the frame info into the toggle row, and pair
Down/Back so the controls fit without scrolling on desktop.
---
.../settings/debugging/DisplayMirror.kt | 24 ++++++++++++-------
1 file changed, 15 insertions(+), 9 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index f3774f0f0a9..6428e860408 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -25,6 +25,7 @@ import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.FilledTonalButton
@@ -52,6 +53,9 @@ import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.RadioController
+// 4x scale for the common 128px-wide OLED; caps the canvas so the D-pad stays above the fold on desktop.
+private val MAX_CANVAS_WIDTH = 512.dp
+
// Firmware input_broker_event codes (src/input/InputBroker.h).
private const val INPUT_SELECT = 10
private const val INPUT_UP = 17
@@ -94,18 +98,20 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
+ val currentFrame = frame
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Switch(checked = mirroring, onCheckedChange = viewModel::setMirror)
Text(text = if (mirroring) "Mirroring" else "Mirror off", style = MaterialTheme.typography.titleMedium)
+ if (currentFrame != null) {
+ Text(
+ text = "${currentFrame.width}x${currentFrame.height} frame #${currentFrame.frameId}",
+ style = MaterialTheme.typography.labelSmall,
+ )
+ }
}
- val currentFrame = frame
if (currentFrame != null) {
MirrorFrameCanvas(currentFrame)
- Text(
- text = "${currentFrame.width}x${currentFrame.height} frame #${currentFrame.frameId}",
- style = MaterialTheme.typography.labelSmall,
- )
} else {
Text(text = "No frame received yet — enable mirroring above.")
}
@@ -121,18 +127,18 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
}
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
FilledTonalButton(onClick = { viewModel.sendKey(INPUT_DOWN) }) { Text("Down") }
- }
- Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
FilledTonalButton(onClick = { viewModel.sendKey(INPUT_BACK) }) { Text("Back") }
}
}
}
-/** Draws a MONO_VLSB 1bpp framebuffer scaled to the available width, one filled rect per lit pixel. */
+/** Draws a MONO_VLSB 1bpp framebuffer scaled up, one filled rect per lit pixel. Width-capped so the controls stay in view on desktop. */
@Composable
private fun MirrorFrameCanvas(frame: MirrorFrame) {
val aspect = frame.width.toFloat() / frame.height.toFloat()
- Canvas(modifier = Modifier.fillMaxWidth().aspectRatio(aspect).background(Color.Black)) {
+ Canvas(
+ modifier = Modifier.widthIn(max = MAX_CANVAS_WIDTH).fillMaxWidth().aspectRatio(aspect).background(Color.Black),
+ ) {
val scale = size.width / frame.width
val pixel = Size(scale, scale)
for (y in 0 until frame.height) {
From 3e5987eb1e88840ec05400110585df535f837e0e Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 12:21:57 -0500
Subject: [PATCH 03/34] refactor(debug): harden screen mirror from adversarial
review
Manager: validate format (MONO_VLSB only) and geometry (width/height must
describe exactly total_size bytes) so malformed device input can't reach
aspectRatio and crash; unit tests for reassembly, drops, restarts.
AdminController: setDisplayMirror/sendInputEvent become non-suspend
immediate sends (teardown-safe, input never queues behind bulk admin) and
gain requestDisplayFrame. Mirror tab: render each frame once into a 1:1
ImageBitmap scaled with FilterQuality.None (kills the fractional-scale
seams), gate controls on connection state, reset the toggle on disconnect,
stop the stream on tab dispose and ViewModel clear, add a one-shot Refresh,
inject AdminController/ConnectionStateProvider instead of RadioController.
Dispatch: display_frame test coverage incl. revoked-session.
---
.../data/manager/DisplayMirrorManagerImpl.kt | 39 +++--
.../manager/FromRadioPacketHandlerImpl.kt | 9 +-
.../manager/DisplayMirrorManagerImplTest.kt | 134 ++++++++++++++++++
.../DisplayMirrorManagerImplTest.kt.bak | 134 ++++++++++++++++++
.../manager/FromRadioPacketHandlerImplTest.kt | 15 ++
.../core/repository/AdminController.kt | 13 +-
.../core/repository/DisplayMirrorManager.kt | 21 ++-
.../core/service/AdminControllerImpl.kt | 24 ++--
.../core/testing/FakeRadioController.kt | 6 +
.../settings/debugging/DisplayMirror.kt | 124 +++++++++++-----
10 files changed, 447 insertions(+), 72 deletions(-)
create mode 100644 core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
create mode 100644 core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index 6c273a2cafa..edb51a8da9e 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -27,9 +27,9 @@ import org.meshtastic.proto.DisplayFrame
/**
* Display frame reassembly state machine.
*
- * Chunks arrive in offset order within a frame (the firmware drains one snapshot before capturing the next), so a
- * chunk with a new `frame_id` or `offset == 0` starts a new frame and an out-of-sequence chunk drops the partial
- * frame. Called sequentially from [FromRadioPacketHandlerImpl] on a single IO coroutine.
+ * Chunks of one frame arrive contiguously and in offset order (FromRadio is a reliable ordered stream), so a chunk with
+ * a new `frame_id` or `offset == 0` starts a new frame and an out-of-sequence chunk drops the partial frame. Calls are
+ * serialized by the single receive-loop collector in MeshServiceOrchestrator (recreated per session).
*/
@Single
class DisplayMirrorManagerImpl : DisplayMirrorManager {
@@ -45,10 +45,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
val data = chunk.data_.toByteArray()
val total = chunk.total_size
- if (total <= 0 || total > MAX_FRAME_BYTES || chunk.offset + data.size > total) {
- Logger.w { "DisplayMirror: dropping malformed chunk (offset=${chunk.offset} size=${data.size} total=$total)" }
- return
- }
+ if (!isAcceptableChunk(chunk, data.size)) return
if (chunk.offset == 0) {
buffer = ByteArray(total)
@@ -58,7 +55,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
val buf = buffer
if (buf == null || chunk.frame_id != frameId || chunk.offset != received || buf.size != total) {
- Logger.w { "DisplayMirror: out-of-sequence chunk (frame=${chunk.frame_id}/$frameId offset=${chunk.offset}/$received)" }
+ Logger.w { "DisplayMirror: bad chunk ${chunk.frame_id}@${chunk.offset}, expected $frameId@$received" }
buffer = null
return
}
@@ -72,8 +69,34 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
}
}
+ /**
+ * Format must be MONO_VLSB and width/height must describe exactly total_size bytes; a zero or lying dimension would
+ * otherwise reach the renderer (aspectRatio requires > 0).
+ */
+ private fun isAcceptableChunk(chunk: DisplayFrame, dataSize: Int): Boolean {
+ val total = chunk.total_size
+ val expectedSize = chunk.width * ((chunk.height + PIXELS_PER_PAGE - 1) / PIXELS_PER_PAGE)
+ val acceptable =
+ chunk.format == DisplayFrame.Format.MONO_VLSB &&
+ chunk.width > 0 &&
+ chunk.height > 0 &&
+ expectedSize == total &&
+ total <= MAX_FRAME_BYTES &&
+ chunk.offset + dataSize <= total
+ if (!acceptable) {
+ Logger.w {
+ "DisplayMirror: dropping bad chunk (format=${chunk.format} ${chunk.width}x${chunk.height} " +
+ "offset=${chunk.offset} size=$dataSize total=$total)"
+ }
+ }
+ return acceptable
+ }
+
private companion object {
// Generous sanity cap: 320x240 at 1bpp is 9600 bytes.
const val MAX_FRAME_BYTES = 16384
+
+ // MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
+ const val PIXELS_PER_PAGE = 8
}
}
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
index 47ad420eb03..799b8e4dfff 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
@@ -45,6 +45,7 @@ import org.meshtastic.core.resources.key_verification_request_title
import org.meshtastic.core.resources.key_verification_title
import org.meshtastic.core.resources.low_entropy_key_title
import org.meshtastic.proto.ClientNotification
+import org.meshtastic.proto.DisplayFrame
import org.meshtastic.proto.FromRadio
/** Implementation of [FromRadioPacketHandler] that dispatches [FromRadio] variants to specialized handlers. */
@@ -133,10 +134,7 @@ class FromRadioPacketHandlerImpl(
xmodemPacket != null ->
runIfSessionActive(session, "XModem packet") { xmodemManager.value.handleIncomingXModem(xmodemPacket) }
- displayFrame != null ->
- runIfSessionActive(session, "display frame") {
- displayMirrorManager.value.handleIncomingFrame(displayFrame)
- }
+ displayFrame != null -> handleDisplayFrame(displayFrame, session)
lockdownStatus != null ->
runIfSessionActive(session, "lockdown status") {
@@ -154,6 +152,9 @@ class FromRadioPacketHandlerImpl(
}
}
+ private fun handleDisplayFrame(frame: DisplayFrame, session: RadioSessionContext) =
+ runIfSessionActive(session, "display frame") { displayMirrorManager.value.handleIncomingFrame(frame) }
+
private fun runIfSessionActive(session: RadioSessionContext, operation: String, block: () -> Unit) {
if (!radioInterfaceService.runIfSessionActive(session, block)) {
Logger.d { "Discarding $operation from stale transport session" }
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
new file mode 100644
index 00000000000..d50da08a2f3
--- /dev/null
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.data.manager
+
+import okio.ByteString.Companion.toByteString
+import org.meshtastic.proto.DisplayFrame
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class DisplayMirrorManagerImplTest {
+
+ private val manager = DisplayMirrorManagerImpl()
+
+ // 128x64 MONO_VLSB frame = 1024 bytes; the firmware chunks at 384.
+ private fun chunk(
+ frameId: Int = 1,
+ offset: Int = 0,
+ data: ByteArray,
+ total: Int = FRAME_BYTES,
+ width: Int = WIDTH,
+ height: Int = HEIGHT,
+ format: DisplayFrame.Format = DisplayFrame.Format.MONO_VLSB,
+ ) = DisplayFrame(
+ width = width,
+ height = height,
+ format = format,
+ frame_id = frameId,
+ offset = offset,
+ total_size = total,
+ data_ = data.toByteString(),
+ )
+
+ private fun bytes(size: Int, fill: Int) = ByteArray(size) { fill.toByte() }
+
+ @Test
+ fun `reassembles a three-chunk frame in order`() {
+ manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2)))
+ assertNull(manager.frame.value)
+
+ manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3)))
+
+ val frame = manager.frame.value!!
+ assertEquals(WIDTH, frame.width)
+ assertEquals(HEIGHT, frame.height)
+ assertEquals(1, frame.frameId)
+ assertContentEquals(bytes(384, 1) + bytes(384, 2) + bytes(256, 3), frame.pixels)
+ }
+
+ @Test
+ fun `single-chunk frame completes immediately`() {
+ // 64x32 = 256 bytes fits one chunk
+ manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
+
+ assertEquals(256, manager.frame.value?.pixels?.size)
+ }
+
+ @Test
+ fun `out-of-sequence chunk drops the partial frame`() {
+ manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3))) // gap: 384 missing
+
+ manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2))) // too late
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `offset zero restarts mid-frame on device reboot or torn capture`() {
+ manager.handleIncomingFrame(chunk(frameId = 5, offset = 0, data = bytes(384, 1)))
+
+ // New frame id starting over at offset 0 wins
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 0, data = bytes(384, 4)))
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 384, data = bytes(384, 5)))
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 768, data = bytes(256, 6)))
+
+ assertEquals(6, manager.frame.value?.frameId)
+ }
+
+ @Test
+ fun `frame id change mid-frame without offset zero is dropped`() {
+ manager.handleIncomingFrame(chunk(frameId = 1, offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(frameId = 2, offset = 384, data = bytes(384, 2)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects geometry that does not match total size`() {
+ manager.handleIncomingFrame(
+ chunk(width = 64, height = 64, total = 256, data = bytes(256, 1)),
+ ) // 64x64 needs 512
+ manager.handleIncomingFrame(chunk(width = 0, height = 64, total = 0, data = ByteArray(0)))
+ manager.handleIncomingFrame(chunk(width = 128, height = 0, total = 0, data = ByteArray(0)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects unsupported format`() {
+ manager.handleIncomingFrame(
+ chunk(
+ width = 64,
+ height = 32,
+ total = 256,
+ data = bytes(256, 1),
+ format = DisplayFrame.Format.FORMAT_UNSPECIFIED,
+ ),
+ )
+
+ assertNull(manager.frame.value)
+ }
+
+ private companion object {
+ const val WIDTH = 128
+ const val HEIGHT = 64
+ const val FRAME_BYTES = 1024
+ }
+}
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
new file mode 100644
index 00000000000..f3fe7f4a66d
--- /dev/null
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.data.manager
+
+import okio.ByteString.Companion.toByteString
+import org.meshtastic.proto.DisplayFrame
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class DisplayMirrorManagerImplTest {
+
+ private val manager = DisplayMirrorManagerImpl()
+
+ // 128x64 MONO_VLSB frame = 1024 bytes; the firmware chunks at 384.
+ private fun chunk(
+ frameId: Int = 1,
+ offset: Int = 0,
+ data: ByteArray,
+ total: Int = FRAME_BYTES,
+ width: Int = WIDTH,
+ height: Int = HEIGHT,
+ format: DisplayFrame.Format = DisplayFrame.Format.MONO_VLSB,
+ ) = DisplayFrame(
+ width = width,
+ height = height,
+ format = format,
+ frame_id = frameId,
+ offset = offset,
+ total_size = total,
+ data_ = data.toByteString(),
+ )
+
+ private fun bytes(size: Int, fill: Int) = ByteArray(size) { fill.toByte() }
+
+ @Test
+ fun `reassembles a three-chunk frame in order`() {
+ manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2)))
+ assertNull(manager.frame.value)
+
+ manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3)))
+
+ val frame = manager.frame.value!!
+ assertEquals(WIDTH, frame.width)
+ assertEquals(HEIGHT, frame.height)
+ assertEquals(1, frame.frameId)
+ assertContentEquals(bytes(384, 1) + bytes(384, 2) + bytes(256, 3), frame.pixels)
+ }
+
+ @Test
+ fun `single-chunk frame completes immediately`() {
+ // 64x32 = 256 bytes fits one chunk
+ manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
+
+ assertEquals(256, manager.frame.value?.pixels?.size)
+ }
+
+ @Test
+ fun `out-of-sequence chunk drops the partial frame`() {
+ manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3))) // gap: 384 missing
+
+ manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2))) // too late
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `offset zero restarts mid-frame (device reboot or torn capture)`() {
+ manager.handleIncomingFrame(chunk(frameId = 5, offset = 0, data = bytes(384, 1)))
+
+ // New frame id starting over at offset 0 wins
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 0, data = bytes(384, 4)))
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 384, data = bytes(384, 5)))
+ manager.handleIncomingFrame(chunk(frameId = 6, offset = 768, data = bytes(256, 6)))
+
+ assertEquals(6, manager.frame.value?.frameId)
+ }
+
+ @Test
+ fun `frame id change mid-frame without offset zero is dropped`() {
+ manager.handleIncomingFrame(chunk(frameId = 1, offset = 0, data = bytes(384, 1)))
+ manager.handleIncomingFrame(chunk(frameId = 2, offset = 384, data = bytes(384, 2)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects geometry that does not match total size`() {
+ manager.handleIncomingFrame(
+ chunk(width = 64, height = 64, total = 256, data = bytes(256, 1)),
+ ) // 64x64 needs 512
+ manager.handleIncomingFrame(chunk(width = 0, height = 64, total = 0, data = ByteArray(0)))
+ manager.handleIncomingFrame(chunk(width = 128, height = 0, total = 0, data = ByteArray(0)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects unsupported format`() {
+ manager.handleIncomingFrame(
+ chunk(
+ width = 64,
+ height = 32,
+ total = 256,
+ data = bytes(256, 1),
+ format = DisplayFrame.Format.FORMAT_UNSPECIFIED,
+ ),
+ )
+
+ assertNull(manager.frame.value)
+ }
+
+ private companion object {
+ const val WIDTH = 128
+ const val HEIGHT = 64
+ const val FRAME_BYTES = 1024
+ }
+}
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
index 18644aade4c..dbd196b775b 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
@@ -27,6 +27,7 @@ import dev.mokkery.verify
import dev.mokkery.verify.VerifyMode
import dev.mokkery.verifySuspend
import org.meshtastic.core.model.util.isOtaStatusNotification
+import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.FirmwareUpdateStatusRepository
import org.meshtastic.core.repository.MeshConfigFlowManager
import org.meshtastic.core.repository.MeshConfigHandler
@@ -43,6 +44,7 @@ import org.meshtastic.proto.Channel
import org.meshtastic.proto.ClientNotification
import org.meshtastic.proto.Config
import org.meshtastic.proto.DeviceMetadata
+import org.meshtastic.proto.DisplayFrame
import org.meshtastic.proto.FromRadio
import org.meshtastic.proto.LoRaRegionPresetMap
import org.meshtastic.proto.LockdownStatus
@@ -68,6 +70,7 @@ class FromRadioPacketHandlerImplTest {
private val configFlowManager: MeshConfigFlowManager = mock(MockMode.autofill)
private val configHandler: MeshConfigHandler = mock(MockMode.autofill)
private val xmodemManager: XModemManager = mock(MockMode.autofill)
+ private val displayMirrorManager: DisplayMirrorManager = mock(MockMode.autofill)
private val lockdownCoordinator = FakeLockdownCoordinator()
private val firmwareUpdateStatusRepository = FirmwareUpdateStatusRepository()
private val radioInterfaceService: RadioInterfaceService = mock(MockMode.autofill)
@@ -105,6 +108,7 @@ class FromRadioPacketHandlerImplTest {
lazy { configFlowManager },
lazy { configHandler },
lazy { xmodemManager },
+ lazy { displayMirrorManager },
mqttManager,
packetHandler,
serviceNotifications,
@@ -220,13 +224,24 @@ class FromRadioPacketHandlerImplTest {
handle(FromRadio.Builder().also { wb -> wb.queueStatus = queueStatus }.build())
handle(FromRadio.Builder().also { wb -> wb.xmodemPacket = xmodemPacket }.build())
handle(FromRadio.Builder().also { wb -> wb.lockdown_status = lockdownStatus }.build())
+ handle(FromRadio(display_frame = DisplayFrame(width = 128, height = 64)))
verify(mode = VerifyMode.exactly(0)) { mqttManager.handleMqttProxyMessage(any()) }
verify(mode = VerifyMode.exactly(0)) { packetHandler.handleQueueStatus(any()) }
verify(mode = VerifyMode.exactly(0)) { xmodemManager.handleIncomingXModem(any()) }
+ verify(mode = VerifyMode.exactly(0)) { displayMirrorManager.handleIncomingFrame(any()) }
assertEquals(null, lockdownCoordinator.lastStatus)
}
+ @Test
+ fun `handleFromRadio routes DISPLAY_FRAME to displayMirrorManager`() {
+ val frame = DisplayFrame(width = 128, height = 64, frame_id = 1, total_size = 1024)
+
+ handle(FromRadio(display_frame = frame))
+
+ verify { displayMirrorManager.handleIncomingFrame(frame) }
+ }
+
@Test
fun `handleFromRadio routes LOCKDOWN_STATUS to lockdownCoordinator`() {
val lockdownStatus =
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
index bf3f4af42d3..f94c5b717c5 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/AdminController.kt
@@ -53,15 +53,20 @@ interface AdminController {
/**
* Enables or disables live display mirroring on the locally connected node. While enabled, the device streams its
- * framebuffer as `FromRadio.display_frame` chunks — collect them via [DisplayMirrorManager].
+ * framebuffer as `FromRadio.display_frame` chunks — collect them via [DisplayMirrorManager]. Non-suspend (immediate
+ * send, bypassing the outbound FIFO) so lifecycle teardown can reliably disable the stream.
*/
- suspend fun setDisplayMirror(enabled: Boolean)
+ fun setDisplayMirror(enabled: Boolean)
+
+ /** Requests a single framebuffer frame from the locally connected node, delivered like mirrored frames. */
+ fun requestDisplayFrame()
/**
* Injects a physical input event (button/key/touch) into the locally connected node's UI via the firmware
- * InputBroker. Event codes are the firmware's `input_broker_event` values.
+ * InputBroker. Event codes are the firmware's `input_broker_event` values. Non-suspend immediate send: input must
+ * not queue behind bulk admin traffic.
*/
- suspend fun sendInputEvent(eventCode: Int, kbChar: Int = 0, touchX: Int = 0, touchY: Int = 0)
+ fun sendInputEvent(eventCode: Int, kbChar: Int = 0, touchX: Int = 0, touchY: Int = 0)
// ── Remote configuration ────────────────────────────────────────────────
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
index aaabf8a87e6..3cd303118d4 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -22,9 +22,9 @@ import org.meshtastic.proto.DisplayFrame
/**
* Reassembles the chunked [DisplayFrame] stream from the connected device into complete framebuffer snapshots.
*
- * The device streams its 1bpp framebuffer as `FromRadio.display_frame` chunks while display mirroring is enabled
- * (see `AdminMessage.set_display_mirror`). Chunks of one frame share a `frame_id`; a frame is complete when
- * `offset + data.size == total_size`.
+ * The device streams its 1bpp framebuffer as `FromRadio.display_frame` chunks while display mirroring is enabled (see
+ * `AdminMessage.set_display_mirror`). Chunks of one frame share a `frame_id`; a frame is complete when `offset +
+ * data.size == total_size`.
*/
interface DisplayMirrorManager {
/** Latest completely reassembled frame, or null before the first one arrives. */
@@ -37,16 +37,15 @@ interface DisplayMirrorManager {
/**
* One complete device framebuffer snapshot.
*
- * [pixels] is MONO_VLSB: 1 bit per pixel in vertical LSB-first pages — byte index = `x + (y / 8) * width`,
- * bit index = `y % 8`.
+ * [pixels] is MONO_VLSB: 1 bit per pixel in vertical LSB-first pages — byte index = `x + (y / 8) * width`, bit index =
+ * `y % 8`.
*/
data class MirrorFrame(val width: Int, val height: Int, val frameId: Int, val pixels: ByteArray) {
- override fun equals(other: Any?): Boolean =
- other is MirrorFrame &&
- other.width == width &&
- other.height == height &&
- other.frameId == frameId &&
- other.pixels.contentEquals(pixels)
+ override fun equals(other: Any?): Boolean = other is MirrorFrame &&
+ other.width == width &&
+ other.height == height &&
+ other.frameId == frameId &&
+ other.pixels.contentEquals(pixels)
override fun hashCode(): Int {
var result = width
diff --git a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
index 48a6d24f088..c35fa077260 100644
--- a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
+++ b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
@@ -139,20 +139,24 @@ internal class AdminControllerImpl(
scope.handledLaunch { radioConfigRepository.setLocalConfig(config) }
}
- override suspend fun setDisplayMirror(enabled: Boolean) {
- commandSender.sendAdmin(myNodeNum) { AdminMessage(set_display_mirror = enabled) }
+ override fun setDisplayMirror(enabled: Boolean) {
+ commandSender.sendAdminImmediate(myNodeNum) { AdminMessage(set_display_mirror = enabled) }
}
- override suspend fun sendInputEvent(eventCode: Int, kbChar: Int, touchX: Int, touchY: Int) {
- commandSender.sendAdmin(myNodeNum) {
+ override fun requestDisplayFrame() {
+ commandSender.sendAdminImmediate(myNodeNum) { AdminMessage(get_display_frame_request = true) }
+ }
+
+ override fun sendInputEvent(eventCode: Int, kbChar: Int, touchX: Int, touchY: Int) {
+ commandSender.sendAdminImmediate(myNodeNum) {
AdminMessage(
send_input_event =
- AdminMessage.InputEvent(
- event_code = eventCode,
- kb_char = kbChar,
- touch_x = touchX,
- touch_y = touchY,
- ),
+ AdminMessage.InputEvent(
+ event_code = eventCode,
+ kb_char = kbChar,
+ touch_x = touchX,
+ touch_y = touchY,
+ ),
)
}
}
diff --git a/core/testing/src/commonMain/kotlin/org/meshtastic/core/testing/FakeRadioController.kt b/core/testing/src/commonMain/kotlin/org/meshtastic/core/testing/FakeRadioController.kt
index 691d88e05db..0089f6b3333 100644
--- a/core/testing/src/commonMain/kotlin/org/meshtastic/core/testing/FakeRadioController.kt
+++ b/core/testing/src/commonMain/kotlin/org/meshtastic/core/testing/FakeRadioController.kt
@@ -276,6 +276,12 @@ class FakeRadioController :
override suspend fun refreshMetadata(destNum: Int) {}
+ override fun setDisplayMirror(enabled: Boolean) {}
+
+ override fun requestDisplayFrame() {}
+
+ override fun sendInputEvent(eventCode: Int, kbChar: Int, touchX: Int, touchY: Int) {}
+
override suspend fun setLocalConfig(config: Config) {
if (throwOnSetLocalConfig) error("Fake local config write failure")
if (rejectLocalConfigWritesRemaining > 0) {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 6428e860408..7436852f629 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -16,8 +16,7 @@
*/
package org.meshtastic.feature.settings.debugging
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.background
+import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
@@ -30,32 +29,49 @@ import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.FilledTonalButton
import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Canvas
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.dp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
import org.koin.compose.viewmodel.koinViewModel
import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.repository.AdminController
+import org.meshtastic.core.repository.ConnectionStateProvider
import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
-import org.meshtastic.core.repository.RadioController
-// 4x scale for the common 128px-wide OLED; caps the canvas so the D-pad stays above the fold on desktop.
+// 4x scale for the common 128px-wide OLED; caps the image so the D-pad stays above the fold on desktop.
private val MAX_CANVAS_WIDTH = 512.dp
+// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
+private const val PIXELS_PER_PAGE = 8
+
// Firmware input_broker_event codes (src/input/InputBroker.h).
private const val INPUT_SELECT = 10
private const val INPUT_UP = 17
@@ -67,24 +83,41 @@ private const val INPUT_BACK = 27
@KoinViewModel
class DisplayMirrorViewModel(
displayMirrorManager: DisplayMirrorManager,
- private val radioController: RadioController,
+ connectionStateProvider: ConnectionStateProvider,
+ private val adminController: AdminController,
) : ViewModel() {
val frame: StateFlow = displayMirrorManager.frame
+ val connected: StateFlow =
+ connectionStateProvider.connectionState
+ .map { it is ConnectionState.Connected }
+ .stateIn(viewModelScope, SharingStarted.Eagerly, false)
+
private val _mirroring = MutableStateFlow(false)
val mirroring: StateFlow = _mirroring.asStateFlow()
+ init {
+ // The device forgets the (non-persisted) mirror setting on disconnect/reboot;
+ // mirror the reset locally so the toggle never claims a dead stream is live.
+ viewModelScope.launch { connected.collect { if (!it) _mirroring.value = false } }
+ }
+
fun setMirror(enabled: Boolean) {
- viewModelScope.launch {
- radioController.setDisplayMirror(enabled)
- _mirroring.value = enabled
- }
+ adminController.setDisplayMirror(enabled)
+ _mirroring.value = enabled
}
- fun sendKey(eventCode: Int) {
- viewModelScope.launch { radioController.sendInputEvent(eventCode) }
+ fun requestFrame() = adminController.requestDisplayFrame()
+
+ fun sendKey(eventCode: Int) = adminController.sendInputEvent(eventCode)
+
+ /** Stops a live stream when the mirror UI goes away; safe to call redundantly. */
+ fun stopMirroring() {
+ if (_mirroring.value) setMirror(false)
}
+
+ override fun onCleared() = stopMirroring()
}
/** PoC live view of the connected device's screen, with remote D-pad control. Strings are deliberately unlocalized. */
@@ -92,6 +125,10 @@ class DisplayMirrorViewModel(
fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
val frame by viewModel.frame.collectAsStateWithLifecycle()
val mirroring by viewModel.mirroring.collectAsStateWithLifecycle()
+ val connected by viewModel.connected.collectAsStateWithLifecycle()
+
+ // Don't leave the device streaming to a hidden tab or abandoned screen.
+ DisposableEffect(Unit) { onDispose { viewModel.stopMirroring() } }
Column(
modifier = modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp),
@@ -100,8 +137,9 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
) {
val currentFrame = frame
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- Switch(checked = mirroring, onCheckedChange = viewModel::setMirror)
+ Switch(checked = mirroring, onCheckedChange = viewModel::setMirror, enabled = connected)
Text(text = if (mirroring) "Mirroring" else "Mirror off", style = MaterialTheme.typography.titleMedium)
+ OutlinedButton(onClick = viewModel::requestFrame, enabled = connected) { Text("Refresh") }
if (currentFrame != null) {
Text(
text = "${currentFrame.width}x${currentFrame.height} frame #${currentFrame.frameId}",
@@ -110,46 +148,62 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
}
}
- if (currentFrame != null) {
- MirrorFrameCanvas(currentFrame)
- } else {
- Text(text = "No frame received yet — enable mirroring above.")
+ when {
+ !connected -> Text(text = "Not connected to a device.")
+ currentFrame != null -> MirrorFrameImage(currentFrame)
+ else -> Text(text = "No frame received yet — enable mirroring or tap Refresh.")
}
// Remote D-pad
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_UP) }) { Text("Up") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_UP) }, enabled = connected) { Text("Up") }
}
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_LEFT) }) { Text("Left") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_SELECT) }) { Text("OK") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_RIGHT) }) { Text("Right") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_LEFT) }, enabled = connected) { Text("Left") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_SELECT) }, enabled = connected) { Text("OK") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_RIGHT) }, enabled = connected) { Text("Right") }
}
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_DOWN) }) { Text("Down") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_BACK) }) { Text("Back") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_DOWN) }, enabled = connected) { Text("Down") }
+ FilledTonalButton(onClick = { viewModel.sendKey(INPUT_BACK) }, enabled = connected) { Text("Back") }
}
}
}
-/** Draws a MONO_VLSB 1bpp framebuffer scaled up, one filled rect per lit pixel. Width-capped so the controls stay in view on desktop. */
+/**
+ * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
+ * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
+ */
@Composable
-private fun MirrorFrameCanvas(frame: MirrorFrame) {
- val aspect = frame.width.toFloat() / frame.height.toFloat()
- Canvas(
- modifier = Modifier.widthIn(max = MAX_CANVAS_WIDTH).fillMaxWidth().aspectRatio(aspect).background(Color.Black),
- ) {
- val scale = size.width / frame.width
- val pixel = Size(scale, scale)
+private fun MirrorFrameImage(frame: MirrorFrame, modifier: Modifier = Modifier) {
+ val bitmap = remember(frame) { renderFrame(frame) }
+ Image(
+ bitmap = bitmap,
+ contentDescription = "Device screen",
+ modifier =
+ modifier
+ .widthIn(max = MAX_CANVAS_WIDTH)
+ .fillMaxWidth()
+ .aspectRatio(frame.width.toFloat() / frame.height.toFloat()),
+ filterQuality = FilterQuality.None,
+ )
+}
+
+private fun renderFrame(frame: MirrorFrame): ImageBitmap {
+ val bitmap = ImageBitmap(frame.width, frame.height)
+ val size = Size(frame.width.toFloat(), frame.height.toFloat())
+ CanvasDrawScope().draw(Density(1f), LayoutDirection.Ltr, Canvas(bitmap), size) {
+ drawRect(color = Color.Black)
+ val pixel = Size(1f, 1f)
for (y in 0 until frame.height) {
- val page = (y / 8) * frame.width
- val bit = 1 shl (y % 8)
+ val page = (y / PIXELS_PER_PAGE) * frame.width
+ val bit = 1 shl (y % PIXELS_PER_PAGE)
for (x in 0 until frame.width) {
- val index = page + x
- if (index < frame.pixels.size && frame.pixels[index].toInt() and bit != 0) {
- drawRect(color = Color.White, topLeft = Offset(x * scale, y * scale), size = pixel)
+ if (frame.pixels[page + x].toInt() and bit != 0) {
+ drawRect(color = Color.White, topLeft = Offset(x.toFloat(), y.toFloat()), size = pixel)
}
}
}
}
+ return bitmap
}
From 42a1fa4ad8198a0ca97e077a28a6b88dc0f464b3 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 12:34:37 -0500
Subject: [PATCH 04/34] feat(metadata): describe the display in
DeviceMetadata.display
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Populates the new DisplayInfo during the handshake — dimensions from the
live display device, MONO_VLSB frame format, PanelClass from the panel
defines (EINK/HUB75/TFT/LCD/OLED), has_touch from HAS_TOUCHSCREEN — so
clients can gate mirroring UI and adapt to the panel. Absent on
display-less builds. Regenerates protos (DisplayInfo, DisplayFrame rect
fields reserved for dirty-rect streaming).
---
.../drawable/ic_keyboard_arrow_left.xml | 9 +
.../drawable/ic_keyboard_arrow_right.xml | 9 +
.../org/meshtastic/core/ui/icon/Navigation.kt | 6 +
.../settings/debugging/DisplayMirror.kt | 260 +++++++++++++++++-
4 files changed, 270 insertions(+), 14 deletions(-)
create mode 100644 core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_left.xml
create mode 100644 core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_right.xml
diff --git a/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_left.xml b/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_left.xml
new file mode 100644
index 00000000000..2d023ab1074
--- /dev/null
+++ b/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_left.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_right.xml b/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_right.xml
new file mode 100644
index 00000000000..30d777e4324
--- /dev/null
+++ b/core/resources/src/commonMain/composeResources/drawable/ic_keyboard_arrow_right.xml
@@ -0,0 +1,9 @@
+
+
+
diff --git a/core/ui/src/commonMain/kotlin/org/meshtastic/core/ui/icon/Navigation.kt b/core/ui/src/commonMain/kotlin/org/meshtastic/core/ui/icon/Navigation.kt
index 0fa667bfa3d..afbb17d7594 100644
--- a/core/ui/src/commonMain/kotlin/org/meshtastic/core/ui/icon/Navigation.kt
+++ b/core/ui/src/commonMain/kotlin/org/meshtastic/core/ui/icon/Navigation.kt
@@ -26,6 +26,8 @@ import org.meshtastic.core.resources.ic_chevron_right
import org.meshtastic.core.resources.ic_expand_less
import org.meshtastic.core.resources.ic_expand_more
import org.meshtastic.core.resources.ic_keyboard_arrow_down
+import org.meshtastic.core.resources.ic_keyboard_arrow_left
+import org.meshtastic.core.resources.ic_keyboard_arrow_right
import org.meshtastic.core.resources.ic_keyboard_arrow_up
val MeshtasticIcons.ArrowBack: ImageVector
@@ -36,6 +38,10 @@ val MeshtasticIcons.KeyboardArrowDown: ImageVector
@Composable get() = vectorResource(Res.drawable.ic_keyboard_arrow_down)
val MeshtasticIcons.KeyboardArrowUp: ImageVector
@Composable get() = vectorResource(Res.drawable.ic_keyboard_arrow_up)
+val MeshtasticIcons.KeyboardArrowLeft: ImageVector
+ @Composable get() = vectorResource(Res.drawable.ic_keyboard_arrow_left)
+val MeshtasticIcons.KeyboardArrowRight: ImageVector
+ @Composable get() = vectorResource(Res.drawable.ic_keyboard_arrow_right)
val MeshtasticIcons.ArrowDownward: ImageVector
@Composable get() = vectorResource(Res.drawable.ic_arrow_downward)
val MeshtasticIcons.ExpandMore: ImageVector
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 7436852f629..ab7a77ee064 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -16,18 +16,28 @@
*/
package org.meshtastic.feature.settings.debugging
+import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.FilledTonalButton
+import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Switch
@@ -35,9 +45,15 @@ import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Canvas
@@ -45,18 +61,28 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.FilterQuality
import androidx.compose.ui.graphics.ImageBitmap
import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.dp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
import org.koin.compose.viewmodel.koinViewModel
import org.koin.core.annotation.KoinViewModel
@@ -65,15 +91,34 @@ import org.meshtastic.core.repository.AdminController
import org.meshtastic.core.repository.ConnectionStateProvider
import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.NodeRepository
+import org.meshtastic.core.ui.icon.KeyboardArrowDown
+import org.meshtastic.core.ui.icon.KeyboardArrowLeft
+import org.meshtastic.core.ui.icon.KeyboardArrowRight
+import org.meshtastic.core.ui.icon.KeyboardArrowUp
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.proto.DisplayInfo
// 4x scale for the common 128px-wide OLED; caps the image so the D-pad stays above the fold on desktop.
private val MAX_CANVAS_WIDTH = 512.dp
+// M3 comfortable target for remote-control keys (48dp minimum + breathing room).
+private val DPAD_KEY_SIZE = 56.dp
+private val DPAD_GAP = 8.dp
+
+// OS-typematic-style auto-repeat, slowed to what a LoRa radio UI can render.
+private const val REPEAT_INITIAL_DELAY_MS = 500L
+private const val REPEAT_INTERVAL_MS = 100L
+
+// Swipes on the mirror shorter than this are ignored as accidental.
+private val SWIPE_THRESHOLD = 48.dp
+
// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
private const val PIXELS_PER_PAGE = 8
// Firmware input_broker_event codes (src/input/InputBroker.h).
private const val INPUT_SELECT = 10
+private const val INPUT_SELECT_LONG = 11
private const val INPUT_UP = 17
private const val INPUT_DOWN = 18
private const val INPUT_LEFT = 19
@@ -84,6 +129,7 @@ private const val INPUT_BACK = 27
class DisplayMirrorViewModel(
displayMirrorManager: DisplayMirrorManager,
connectionStateProvider: ConnectionStateProvider,
+ nodeRepository: NodeRepository,
private val adminController: AdminController,
) : ViewModel() {
@@ -94,6 +140,12 @@ class DisplayMirrorViewModel(
.map { it is ConnectionState.Connected }
.stateIn(viewModelScope, SharingStarted.Eagerly, false)
+ /** Panel description from the connect handshake; null on display-less nodes and pre-DisplayInfo firmware. */
+ val displayInfo: StateFlow =
+ nodeRepository.ourNodeInfo
+ .map { it?.metadata?.display }
+ .stateIn(viewModelScope, SharingStarted.Eagerly, null)
+
private val _mirroring = MutableStateFlow(false)
val mirroring: StateFlow = _mirroring.asStateFlow()
@@ -126,6 +178,7 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
val frame by viewModel.frame.collectAsStateWithLifecycle()
val mirroring by viewModel.mirroring.collectAsStateWithLifecycle()
val connected by viewModel.connected.collectAsStateWithLifecycle()
+ val displayInfo by viewModel.displayInfo.collectAsStateWithLifecycle()
// Don't leave the device streaming to a hidden tab or abandoned screen.
DisposableEffect(Unit) { onDispose { viewModel.stopMirroring() } }
@@ -148,31 +201,210 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
}
}
+ if (displayInfo?.panel_class == DisplayInfo.PanelClass.EINK) {
+ Text(
+ text = "E-ink display: refresh is slow — prefer one-shot Refresh over continuous mirroring.",
+ style = MaterialTheme.typography.labelSmall,
+ )
+ }
+
when {
!connected -> Text(text = "Not connected to a device.")
- currentFrame != null -> MirrorFrameImage(currentFrame)
+ currentFrame != null -> MirrorSurface(currentFrame, onEvent = viewModel::sendKey)
else -> Text(text = "No frame received yet — enable mirroring or tap Refresh.")
}
- // Remote D-pad
- Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_UP) }, enabled = connected) { Text("Up") }
+ DpadCluster(enabled = connected, onEvent = viewModel::sendKey)
+ }
+}
+
+/**
+ * The live mirror plus its direct input affordances: click to focus (keyboard capture — arrows, Enter/Space = OK,
+ * Esc/Backspace = Back), swipe in a cardinal direction for a single direction event.
+ */
+@Composable
+private fun MirrorSurface(frame: MirrorFrame, onEvent: (Int) -> Unit, modifier: Modifier = Modifier) {
+ val focusRequester = remember { FocusRequester() }
+ var focused by remember { mutableStateOf(false) }
+ val focusColor = MaterialTheme.colorScheme.primary
+
+ Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ Box(
+ modifier =
+ modifier
+ .focusRequester(focusRequester)
+ .onFocusChanged { focused = it.isFocused }
+ .focusable()
+ .onPreviewKeyEvent { event ->
+ if (event.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
+ keyToInputEvent(event.key)?.let {
+ onEvent(it)
+ true
+ } ?: false
+ }
+ .pointerInput(Unit) { detectTapGestures(onTap = { focusRequester.requestFocus() }) }
+ .swipeToDirection(onEvent)
+ .border(width = 2.dp, color = if (focused) focusColor else Color.Transparent),
+ ) {
+ MirrorFrameImage(frame)
}
- Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_LEFT) }, enabled = connected) { Text("Left") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_SELECT) }, enabled = connected) { Text("OK") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_RIGHT) }, enabled = connected) { Text("Right") }
+ Text(
+ text =
+ if (focused) {
+ "Keyboard active: arrows navigate · Enter selects · Esc goes back"
+ } else {
+ "Click the screen for keyboard control, or swipe it to navigate"
+ },
+ style = MaterialTheme.typography.labelSmall,
+ )
+ }
+}
+
+private fun keyToInputEvent(key: Key): Int? = when (key) {
+ Key.DirectionUp -> INPUT_UP
+ Key.DirectionDown -> INPUT_DOWN
+ Key.DirectionLeft -> INPUT_LEFT
+ Key.DirectionRight -> INPUT_RIGHT
+ Key.Enter, Key.NumPadEnter, Key.Spacebar -> INPUT_SELECT
+ Key.Escape, Key.Backspace -> INPUT_BACK
+ else -> null
+}
+
+/** Converts a completed drag into one direction event along its dominant axis, ignoring short accidental swipes. */
+private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointerInput(Unit) {
+ val threshold = SWIPE_THRESHOLD.toPx()
+ var drag = Offset.Zero
+ detectDragGestures(
+ onDragStart = { drag = Offset.Zero },
+ onDrag = { change, amount ->
+ change.consume()
+ drag += amount
+ },
+ onDragEnd = {
+ val horizontal = drag.x
+ val vertical = drag.y
+ when {
+ kotlin.math.abs(horizontal) < threshold && kotlin.math.abs(vertical) < threshold -> Unit
+ kotlin.math.abs(horizontal) >= kotlin.math.abs(vertical) ->
+ onEvent(if (horizontal > 0) INPUT_RIGHT else INPUT_LEFT)
+ else -> onEvent(if (vertical > 0) INPUT_DOWN else INPUT_UP)
+ }
+ },
+ )
+}
+
+/**
+ * Cross-shaped 5-way cluster with Back below-left, following the TV-remote convention: directions auto-repeat on
+ * hold (500ms delay, then 10Hz — slow enough for the radio to render), OK long-press sends the firmware's
+ * SELECT_LONG.
+ */
+@Composable
+private fun DpadCluster(enabled: Boolean, onEvent: (Int) -> Unit, modifier: Modifier = Modifier) {
+ Column(modifier = modifier, horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(DPAD_GAP)) {
+ RepeatingKey(MeshtasticIcons.KeyboardArrowUp, "Up", enabled) { onEvent(INPUT_UP) }
+ Row(horizontalArrangement = Arrangement.spacedBy(DPAD_GAP)) {
+ RepeatingKey(MeshtasticIcons.KeyboardArrowLeft, "Left", enabled) { onEvent(INPUT_LEFT) }
+ OkKey(enabled = enabled, onSelect = { onEvent(INPUT_SELECT) }, onSelectLong = { onEvent(INPUT_SELECT_LONG) })
+ RepeatingKey(MeshtasticIcons.KeyboardArrowRight, "Right", enabled) { onEvent(INPUT_RIGHT) }
+ }
+ RepeatingKey(MeshtasticIcons.KeyboardArrowDown, "Down", enabled) { onEvent(INPUT_DOWN) }
+ Row(modifier = Modifier.widthIn(min = DPAD_KEY_SIZE * 3 + DPAD_GAP * 2)) {
+ BackKey(enabled = enabled) { onEvent(INPUT_BACK) }
}
- Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_DOWN) }, enabled = connected) { Text("Down") }
- FilledTonalButton(onClick = { viewModel.sendKey(INPUT_BACK) }, enabled = connected) { Text("Back") }
+ }
+}
+
+/** A direction key: fires on press, then auto-repeats while held. */
+@Composable
+private fun RepeatingKey(icon: ImageVector, label: String, enabled: Boolean, onEvent: () -> Unit) {
+ var pressed by remember { mutableStateOf(false) }
+ val background =
+ when {
+ !enabled -> MaterialTheme.colorScheme.surfaceVariant
+ pressed -> MaterialTheme.colorScheme.primaryContainer
+ else -> MaterialTheme.colorScheme.secondaryContainer
}
+ Box(
+ contentAlignment = Alignment.Center,
+ modifier =
+ Modifier
+ .size(DPAD_KEY_SIZE)
+ .clip(CircleShape)
+ .background(background)
+ .pointerInput(enabled) {
+ if (!enabled) return@pointerInput
+ coroutineScope {
+ detectTapGestures(
+ onPress = {
+ pressed = true
+ onEvent()
+ val repeater = launch {
+ delay(REPEAT_INITIAL_DELAY_MS)
+ while (isActive) {
+ onEvent()
+ delay(REPEAT_INTERVAL_MS)
+ }
+ }
+ tryAwaitRelease()
+ repeater.cancel()
+ pressed = false
+ },
+ )
+ }
+ },
+ ) {
+ Icon(imageVector = icon, contentDescription = label, tint = contentColorFor(enabled))
+ }
+}
+
+/** Center OK: tap selects, long-press sends SELECT_LONG. */
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+private fun OkKey(enabled: Boolean, onSelect: () -> Unit, onSelectLong: () -> Unit) {
+ Box(
+ contentAlignment = Alignment.Center,
+ modifier =
+ Modifier
+ .size(DPAD_KEY_SIZE)
+ .clip(CircleShape)
+ .background(
+ if (enabled) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
+ )
+ .combinedClickable(enabled = enabled, onLongClick = onSelectLong, onClick = onSelect),
+ ) {
+ Text(
+ text = "OK",
+ style = MaterialTheme.typography.titleSmall,
+ color = if (enabled) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ }
+}
+
+@Composable
+private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
+ Box(
+ contentAlignment = Alignment.Center,
+ modifier =
+ Modifier
+ .size(DPAD_KEY_SIZE)
+ .clip(CircleShape)
+ .background(
+ if (enabled) MaterialTheme.colorScheme.secondaryContainer else MaterialTheme.colorScheme.surfaceVariant,
+ )
+ .combinedClickable(enabled = enabled, onClick = onBack),
+ ) {
+ Text(text = "Back", style = MaterialTheme.typography.labelMedium, color = contentColorFor(enabled))
}
}
+@Composable
+private fun contentColorFor(enabled: Boolean): Color =
+ if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
+
/**
- * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
- * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
+ * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with
+ * nearest-neighbor filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame
+ * instead of per recomposition.
*/
@Composable
private fun MirrorFrameImage(frame: MirrorFrame, modifier: Modifier = Modifier) {
From f67252661179f30d3172d618a38b5752c57d977d Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 12:40:55 -0500
Subject: [PATCH 05/34] feat(debug): TV-remote-grade mirror controls and
DisplayInfo awareness
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Replace the flat button stack with the researched control surface:
cross-shaped 5-way cluster (56dp circular keys, 8dp gaps, Material
Symbols chevrons with contentDescriptions), directions auto-repeat on
hold (500ms then 10Hz — slow enough for the radio to render), OK
long-press sends SELECT_LONG, Back sits below per TV-remote convention.
The mirror itself becomes an input surface: click to capture the
keyboard (arrows / Enter / Esc, with a visible focus ring and hint) and
swipe in a cardinal direction to navigate. Consumes the new
DeviceMetadata.display: shows an e-ink hint steering toward one-shot
Refresh. Adds keyboard_arrow_left/right icons (Material Symbols rounded,
transposed from the existing up glyph).
---
.../settings/debugging/DisplayMirror.kt | 108 ++++++++++--------
1 file changed, 63 insertions(+), 45 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index ab7a77ee064..2f603685b81 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -142,9 +142,7 @@ class DisplayMirrorViewModel(
/** Panel description from the connect handshake; null on display-less nodes and pre-DisplayInfo firmware. */
val displayInfo: StateFlow =
- nodeRepository.ourNodeInfo
- .map { it?.metadata?.display }
- .stateIn(viewModelScope, SharingStarted.Eagerly, null)
+ nodeRepository.ourNodeInfo.map { it?.metadata?.display }.stateIn(viewModelScope, SharingStarted.Eagerly, null)
private val _mirroring = MutableStateFlow(false)
val mirroring: StateFlow = _mirroring.asStateFlow()
@@ -228,11 +226,14 @@ private fun MirrorSurface(frame: MirrorFrame, onEvent: (Int) -> Unit, modifier:
var focused by remember { mutableStateOf(false) }
val focusColor = MaterialTheme.colorScheme.primary
- Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ Column(
+ modifier = modifier,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
Box(
modifier =
- modifier
- .focusRequester(focusRequester)
+ Modifier.focusRequester(focusRequester)
.onFocusChanged { focused = it.isFocused }
.focusable()
.onPreviewKeyEvent { event ->
@@ -262,11 +263,22 @@ private fun MirrorSurface(frame: MirrorFrame, onEvent: (Int) -> Unit, modifier:
private fun keyToInputEvent(key: Key): Int? = when (key) {
Key.DirectionUp -> INPUT_UP
+
Key.DirectionDown -> INPUT_DOWN
+
Key.DirectionLeft -> INPUT_LEFT
+
Key.DirectionRight -> INPUT_RIGHT
- Key.Enter, Key.NumPadEnter, Key.Spacebar -> INPUT_SELECT
- Key.Escape, Key.Backspace -> INPUT_BACK
+
+ Key.Enter,
+ Key.NumPadEnter,
+ Key.Spacebar,
+ -> INPUT_SELECT
+
+ Key.Escape,
+ Key.Backspace,
+ -> INPUT_BACK
+
else -> null
}
@@ -285,8 +297,10 @@ private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointe
val vertical = drag.y
when {
kotlin.math.abs(horizontal) < threshold && kotlin.math.abs(vertical) < threshold -> Unit
+
kotlin.math.abs(horizontal) >= kotlin.math.abs(vertical) ->
onEvent(if (horizontal > 0) INPUT_RIGHT else INPUT_LEFT)
+
else -> onEvent(if (vertical > 0) INPUT_DOWN else INPUT_UP)
}
},
@@ -294,17 +308,24 @@ private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointe
}
/**
- * Cross-shaped 5-way cluster with Back below-left, following the TV-remote convention: directions auto-repeat on
- * hold (500ms delay, then 10Hz — slow enough for the radio to render), OK long-press sends the firmware's
- * SELECT_LONG.
+ * Cross-shaped 5-way cluster with Back below-left, following the TV-remote convention: directions auto-repeat on hold
+ * (500ms delay, then 10Hz — slow enough for the radio to render), OK long-press sends the firmware's SELECT_LONG.
*/
@Composable
private fun DpadCluster(enabled: Boolean, onEvent: (Int) -> Unit, modifier: Modifier = Modifier) {
- Column(modifier = modifier, horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(DPAD_GAP)) {
+ Column(
+ modifier = modifier,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(DPAD_GAP),
+ ) {
RepeatingKey(MeshtasticIcons.KeyboardArrowUp, "Up", enabled) { onEvent(INPUT_UP) }
Row(horizontalArrangement = Arrangement.spacedBy(DPAD_GAP)) {
RepeatingKey(MeshtasticIcons.KeyboardArrowLeft, "Left", enabled) { onEvent(INPUT_LEFT) }
- OkKey(enabled = enabled, onSelect = { onEvent(INPUT_SELECT) }, onSelectLong = { onEvent(INPUT_SELECT_LONG) })
+ OkKey(
+ enabled = enabled,
+ onSelect = { onEvent(INPUT_SELECT) },
+ onSelectLong = { onEvent(INPUT_SELECT_LONG) },
+ )
RepeatingKey(MeshtasticIcons.KeyboardArrowRight, "Right", enabled) { onEvent(INPUT_RIGHT) }
}
RepeatingKey(MeshtasticIcons.KeyboardArrowDown, "Down", enabled) { onEvent(INPUT_DOWN) }
@@ -327,31 +348,27 @@ private fun RepeatingKey(icon: ImageVector, label: String, enabled: Boolean, onE
Box(
contentAlignment = Alignment.Center,
modifier =
- Modifier
- .size(DPAD_KEY_SIZE)
- .clip(CircleShape)
- .background(background)
- .pointerInput(enabled) {
- if (!enabled) return@pointerInput
- coroutineScope {
- detectTapGestures(
- onPress = {
- pressed = true
- onEvent()
- val repeater = launch {
- delay(REPEAT_INITIAL_DELAY_MS)
- while (isActive) {
- onEvent()
- delay(REPEAT_INTERVAL_MS)
- }
+ Modifier.size(DPAD_KEY_SIZE).clip(CircleShape).background(background).pointerInput(enabled) {
+ if (!enabled) return@pointerInput
+ coroutineScope {
+ detectTapGestures(
+ onPress = {
+ pressed = true
+ onEvent()
+ val repeater = launch {
+ delay(REPEAT_INITIAL_DELAY_MS)
+ while (isActive) {
+ onEvent()
+ delay(REPEAT_INTERVAL_MS)
}
- tryAwaitRelease()
- repeater.cancel()
- pressed = false
- },
- )
- }
- },
+ }
+ tryAwaitRelease()
+ repeater.cancel()
+ pressed = false
+ },
+ )
+ }
+ },
) {
Icon(imageVector = icon, contentDescription = label, tint = contentColorFor(enabled))
}
@@ -364,8 +381,7 @@ private fun OkKey(enabled: Boolean, onSelect: () -> Unit, onSelectLong: () -> Un
Box(
contentAlignment = Alignment.Center,
modifier =
- Modifier
- .size(DPAD_KEY_SIZE)
+ Modifier.size(DPAD_KEY_SIZE)
.clip(CircleShape)
.background(
if (enabled) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
@@ -385,11 +401,14 @@ private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
Box(
contentAlignment = Alignment.Center,
modifier =
- Modifier
- .size(DPAD_KEY_SIZE)
+ Modifier.size(DPAD_KEY_SIZE)
.clip(CircleShape)
.background(
- if (enabled) MaterialTheme.colorScheme.secondaryContainer else MaterialTheme.colorScheme.surfaceVariant,
+ if (enabled) {
+ MaterialTheme.colorScheme.secondaryContainer
+ } else {
+ MaterialTheme.colorScheme.surfaceVariant
+ },
)
.combinedClickable(enabled = enabled, onClick = onBack),
) {
@@ -402,9 +421,8 @@ private fun contentColorFor(enabled: Boolean): Color =
if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
/**
- * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with
- * nearest-neighbor filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame
- * instead of per recomposition.
+ * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
+ * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
*/
@Composable
private fun MirrorFrameImage(frame: MirrorFrame, modifier: Modifier = Modifier) {
From 68ae85f1d74b4dc0611c007f027d1f9e9b887b9e Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 13:02:02 -0500
Subject: [PATCH 06/34] feat(debug): color-accurate mirror via DisplayPalette
DisplayMirrorManager reassembles FromRadio.display_palette chunks
(signature-keyed, defaults captured on the offset-0 chunk) into a
MirrorPalette; frames carry palette_signature and the renderer resolves
each pixel through the region table (last overlapping region wins,
matching firmware precedence) with RGB565 conversion, falling back to
monochrome when the referenced palette hasn't arrived. Renderer split
into MirrorFrameRenderer.kt.
---
.../data/manager/DisplayMirrorManagerImpl.kt | 49 ++++++-
.../manager/FromRadioPacketHandlerImpl.kt | 7 +
.../manager/DisplayMirrorManagerImplTest.kt | 45 +++++++
.../core/repository/DisplayMirrorManager.kt | 28 +++-
.../settings/debugging/DisplayMirror.kt | 69 ++--------
.../settings/debugging/MirrorFrameRenderer.kt | 123 ++++++++++++++++++
6 files changed, 262 insertions(+), 59 deletions(-)
create mode 100644 feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index edb51a8da9e..e100865cb29 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -22,7 +22,9 @@ import kotlinx.coroutines.flow.asStateFlow
import org.koin.core.annotation.Single
import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.proto.DisplayFrame
+import org.meshtastic.proto.DisplayPalette
/**
* Display frame reassembly state machine.
@@ -37,10 +39,19 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private val _frame = MutableStateFlow(null)
override val frame = _frame.asStateFlow()
+ private val _palette = MutableStateFlow(null)
+ override val palette = _palette.asStateFlow()
+
private var buffer: ByteArray? = null
private var frameId = 0
private var received = 0
+ private var paletteRegions = mutableListOf()
+ private var paletteSignature = 0
+ private var paletteReceived = 0
+ private var paletteDefaultOn = 0
+ private var paletteDefaultOff = 0
+
override fun handleIncomingFrame(chunk: DisplayFrame) {
val data = chunk.data_.toByteArray()
val total = chunk.total_size
@@ -64,11 +75,47 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
received += data.size
if (received == total) {
- _frame.value = MirrorFrame(width = chunk.width, height = chunk.height, frameId = frameId, pixels = buf)
+ _frame.value =
+ MirrorFrame(
+ width = chunk.width,
+ height = chunk.height,
+ frameId = frameId,
+ paletteSignature = chunk.palette_signature,
+ pixels = buf,
+ )
buffer = null
}
}
+ override fun handleIncomingPalette(chunk: DisplayPalette) {
+ if (chunk.region_offset == 0) {
+ paletteRegions = mutableListOf()
+ paletteSignature = chunk.signature
+ paletteReceived = 0
+ // Defaults are authoritative on the first chunk; later chunks may omit them.
+ paletteDefaultOn = chunk.default_on_color
+ paletteDefaultOff = chunk.default_off_color
+ }
+ if (chunk.signature != paletteSignature || chunk.region_offset != paletteReceived) {
+ Logger.w { "DisplayMirror: bad palette chunk ${chunk.signature}@${chunk.region_offset}" }
+ paletteRegions.clear()
+ paletteReceived = -1 // poison until the next offset-0 chunk restarts
+ return
+ }
+ paletteRegions.addAll(chunk.regions)
+ paletteReceived += chunk.regions.size
+
+ if (paletteReceived >= chunk.region_total) {
+ _palette.value =
+ MirrorPalette(
+ signature = chunk.signature,
+ defaultOnColor = paletteDefaultOn,
+ defaultOffColor = paletteDefaultOff,
+ regions = paletteRegions.toList(),
+ )
+ }
+ }
+
/**
* Format must be MONO_VLSB and width/height must describe exactly total_size bytes; a zero or lying dimension would
* otherwise reach the renderer (aspectRatio requires > 0).
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
index 799b8e4dfff..2ce393781a0 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImpl.kt
@@ -46,6 +46,7 @@ import org.meshtastic.core.resources.key_verification_title
import org.meshtastic.core.resources.low_entropy_key_title
import org.meshtastic.proto.ClientNotification
import org.meshtastic.proto.DisplayFrame
+import org.meshtastic.proto.DisplayPalette
import org.meshtastic.proto.FromRadio
/** Implementation of [FromRadioPacketHandler] that dispatches [FromRadio] variants to specialized handlers. */
@@ -87,6 +88,7 @@ class FromRadioPacketHandlerImpl(
val xmodemPacket = proto.xmodemPacket
val lockdownStatus = proto.lockdown_status
val displayFrame = proto.display_frame
+ val displayPalette = proto.display_palette
when {
myInfo != null -> configFlowManager.value.handleMyInfo(myInfo, session)
@@ -136,6 +138,8 @@ class FromRadioPacketHandlerImpl(
displayFrame != null -> handleDisplayFrame(displayFrame, session)
+ displayPalette != null -> handleDisplayPalette(displayPalette, session)
+
lockdownStatus != null ->
runIfSessionActive(session, "lockdown status") {
lockdownCoordinator.handleLockdownStatus(lockdownStatus)
@@ -155,6 +159,9 @@ class FromRadioPacketHandlerImpl(
private fun handleDisplayFrame(frame: DisplayFrame, session: RadioSessionContext) =
runIfSessionActive(session, "display frame") { displayMirrorManager.value.handleIncomingFrame(frame) }
+ private fun handleDisplayPalette(palette: DisplayPalette, session: RadioSessionContext) =
+ runIfSessionActive(session, "display palette") { displayMirrorManager.value.handleIncomingPalette(palette) }
+
private fun runIfSessionActive(session: RadioSessionContext, operation: String, block: () -> Unit) {
if (!radioInterfaceService.runIfSessionActive(session, block)) {
Logger.d { "Discarding $operation from stale transport session" }
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
index d50da08a2f3..1af13b31cc8 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -18,6 +18,7 @@ package org.meshtastic.core.data.manager
import okio.ByteString.Companion.toByteString
import org.meshtastic.proto.DisplayFrame
+import org.meshtastic.proto.DisplayPalette
import kotlin.test.Test
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals
@@ -126,6 +127,50 @@ class DisplayMirrorManagerImplTest {
assertNull(manager.frame.value)
}
+ @Test
+ fun `reassembles a two-chunk palette and tags frames with its signature`() {
+ val region =
+ DisplayPalette.ColorRegion(x = 0, y = 0, width = 128, height = 16, on_color = 0xF800, off_color = 0)
+ manager.handleIncomingPalette(
+ DisplayPalette(
+ signature = 42,
+ default_on_color = 0xFFFF,
+ default_off_color = 0,
+ region_offset = 0,
+ region_total = 3,
+ regions = listOf(region, region),
+ ),
+ )
+ assertNull(manager.palette.value)
+
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 42, region_offset = 2, region_total = 3, regions = listOf(region)),
+ )
+
+ val palette = manager.palette.value!!
+ assertEquals(42, palette.signature)
+ assertEquals(0xFFFF, palette.defaultOnColor)
+ assertEquals(3, palette.regions.size)
+ }
+
+ @Test
+ fun `out-of-sequence palette chunk is dropped until a restart`() {
+ val region = DisplayPalette.ColorRegion(x = 0, y = 0, width = 8, height = 8)
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 7, region_offset = 0, region_total = 2, regions = listOf(region)),
+ )
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 7, region_offset = 5, region_total = 2, regions = listOf(region)),
+ )
+ assertNull(manager.palette.value)
+
+ // A fresh offset-0 chunk recovers
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 8, region_offset = 0, region_total = 1, regions = listOf(region)),
+ )
+ assertEquals(8, manager.palette.value?.signature)
+ }
+
private companion object {
const val WIDTH = 128
const val HEIGHT = 64
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
index 3cd303118d4..058802d9d58 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -18,6 +18,7 @@ package org.meshtastic.core.repository
import kotlinx.coroutines.flow.StateFlow
import org.meshtastic.proto.DisplayFrame
+import org.meshtastic.proto.DisplayPalette
/**
* Reassembles the chunked [DisplayFrame] stream from the connected device into complete framebuffer snapshots.
@@ -30,27 +31,52 @@ interface DisplayMirrorManager {
/** Latest completely reassembled frame, or null before the first one arrives. */
val frame: StateFlow
+ /** Latest completely reassembled color palette, or null when the device renders monochrome. */
+ val palette: StateFlow
+
/** Routes an incoming display frame chunk from the device to the reassembly state machine. */
fun handleIncomingFrame(chunk: DisplayFrame)
+
+ /** Routes an incoming palette chunk from the device to the reassembly state machine. */
+ fun handleIncomingPalette(chunk: DisplayPalette)
}
+/**
+ * A complete color palette for [MirrorFrame]s whose `paletteSignature` matches [signature]: per-region RGB565 on/off
+ * colors (later regions override earlier ones where they overlap) plus defaults for pixels outside all regions.
+ */
+data class MirrorPalette(
+ val signature: Int,
+ val defaultOnColor: Int,
+ val defaultOffColor: Int,
+ val regions: List,
+)
+
/**
* One complete device framebuffer snapshot.
*
* [pixels] is MONO_VLSB: 1 bit per pixel in vertical LSB-first pages — byte index = `x + (y / 8) * width`, bit index =
* `y % 8`.
*/
-data class MirrorFrame(val width: Int, val height: Int, val frameId: Int, val pixels: ByteArray) {
+data class MirrorFrame(
+ val width: Int,
+ val height: Int,
+ val frameId: Int,
+ val paletteSignature: Int,
+ val pixels: ByteArray,
+) {
override fun equals(other: Any?): Boolean = other is MirrorFrame &&
other.width == width &&
other.height == height &&
other.frameId == frameId &&
+ other.paletteSignature == paletteSignature &&
other.pixels.contentEquals(pixels)
override fun hashCode(): Int {
var result = width
result = 31 * result + height
result = 31 * result + frameId
+ result = 31 * result + paletteSignature
result = 31 * result + pixels.contentHashCode()
return result
}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 2f603685b81..58d4b19d98c 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -17,7 +17,6 @@
package org.meshtastic.feature.settings.debugging
import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.combinedClickable
@@ -28,9 +27,7 @@ import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.widthIn
@@ -55,12 +52,7 @@ import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.Canvas
import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.FilterQuality
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEventType
@@ -68,8 +60,6 @@ import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.unit.Density
-import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.dp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -91,6 +81,7 @@ import org.meshtastic.core.repository.AdminController
import org.meshtastic.core.repository.ConnectionStateProvider
import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.core.repository.NodeRepository
import org.meshtastic.core.ui.icon.KeyboardArrowDown
import org.meshtastic.core.ui.icon.KeyboardArrowLeft
@@ -99,9 +90,6 @@ import org.meshtastic.core.ui.icon.KeyboardArrowUp
import org.meshtastic.core.ui.icon.MeshtasticIcons
import org.meshtastic.proto.DisplayInfo
-// 4x scale for the common 128px-wide OLED; caps the image so the D-pad stays above the fold on desktop.
-private val MAX_CANVAS_WIDTH = 512.dp
-
// M3 comfortable target for remote-control keys (48dp minimum + breathing room).
private val DPAD_KEY_SIZE = 56.dp
private val DPAD_GAP = 8.dp
@@ -113,9 +101,6 @@ private const val REPEAT_INTERVAL_MS = 100L
// Swipes on the mirror shorter than this are ignored as accidental.
private val SWIPE_THRESHOLD = 48.dp
-// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
-private const val PIXELS_PER_PAGE = 8
-
// Firmware input_broker_event codes (src/input/InputBroker.h).
private const val INPUT_SELECT = 10
private const val INPUT_SELECT_LONG = 11
@@ -135,6 +120,8 @@ class DisplayMirrorViewModel(
val frame: StateFlow = displayMirrorManager.frame
+ val palette: StateFlow = displayMirrorManager.palette
+
val connected: StateFlow =
connectionStateProvider.connectionState
.map { it is ConnectionState.Connected }
@@ -174,6 +161,7 @@ class DisplayMirrorViewModel(
@Composable
fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
val frame by viewModel.frame.collectAsStateWithLifecycle()
+ val palette by viewModel.palette.collectAsStateWithLifecycle()
val mirroring by viewModel.mirroring.collectAsStateWithLifecycle()
val connected by viewModel.connected.collectAsStateWithLifecycle()
val displayInfo by viewModel.displayInfo.collectAsStateWithLifecycle()
@@ -208,7 +196,7 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
when {
!connected -> Text(text = "Not connected to a device.")
- currentFrame != null -> MirrorSurface(currentFrame, onEvent = viewModel::sendKey)
+ currentFrame != null -> MirrorSurface(currentFrame, palette, onEvent = viewModel::sendKey)
else -> Text(text = "No frame received yet — enable mirroring or tap Refresh.")
}
@@ -221,7 +209,12 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
* Esc/Backspace = Back), swipe in a cardinal direction for a single direction event.
*/
@Composable
-private fun MirrorSurface(frame: MirrorFrame, onEvent: (Int) -> Unit, modifier: Modifier = Modifier) {
+private fun MirrorSurface(
+ frame: MirrorFrame,
+ palette: MirrorPalette?,
+ onEvent: (Int) -> Unit,
+ modifier: Modifier = Modifier,
+) {
val focusRequester = remember { FocusRequester() }
var focused by remember { mutableStateOf(false) }
val focusColor = MaterialTheme.colorScheme.primary
@@ -247,7 +240,7 @@ private fun MirrorSurface(frame: MirrorFrame, onEvent: (Int) -> Unit, modifier:
.swipeToDirection(onEvent)
.border(width = 2.dp, color = if (focused) focusColor else Color.Transparent),
) {
- MirrorFrameImage(frame)
+ MirrorFrameImage(frame, palette)
}
Text(
text =
@@ -419,41 +412,3 @@ private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
@Composable
private fun contentColorFor(enabled: Boolean): Color =
if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
-
-/**
- * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
- * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
- */
-@Composable
-private fun MirrorFrameImage(frame: MirrorFrame, modifier: Modifier = Modifier) {
- val bitmap = remember(frame) { renderFrame(frame) }
- Image(
- bitmap = bitmap,
- contentDescription = "Device screen",
- modifier =
- modifier
- .widthIn(max = MAX_CANVAS_WIDTH)
- .fillMaxWidth()
- .aspectRatio(frame.width.toFloat() / frame.height.toFloat()),
- filterQuality = FilterQuality.None,
- )
-}
-
-private fun renderFrame(frame: MirrorFrame): ImageBitmap {
- val bitmap = ImageBitmap(frame.width, frame.height)
- val size = Size(frame.width.toFloat(), frame.height.toFloat())
- CanvasDrawScope().draw(Density(1f), LayoutDirection.Ltr, Canvas(bitmap), size) {
- drawRect(color = Color.Black)
- val pixel = Size(1f, 1f)
- for (y in 0 until frame.height) {
- val page = (y / PIXELS_PER_PAGE) * frame.width
- val bit = 1 shl (y % PIXELS_PER_PAGE)
- for (x in 0 until frame.width) {
- if (frame.pixels[page + x].toInt() and bit != 0) {
- drawRect(color = Color.White, topLeft = Offset(x.toFloat(), y.toFloat()), size = pixel)
- }
- }
- }
- }
- return bitmap
-}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
new file mode 100644
index 00000000000..7bff3ef7182
--- /dev/null
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Canvas
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.FilterQuality
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.MirrorPalette
+
+// 4x scale for the common 128px-wide OLED; caps the image so the D-pad stays above the fold on desktop.
+private val MAX_CANVAS_WIDTH = 512.dp
+
+// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
+private const val PIXELS_PER_PAGE = 8
+
+/**
+ * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
+ * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
+ */
+@Composable
+internal fun MirrorFrameImage(frame: MirrorFrame, palette: MirrorPalette?, modifier: Modifier = Modifier) {
+ // A palette only applies when the frame references it; otherwise render monochrome.
+ val activePalette = palette?.takeIf { frame.paletteSignature != 0 && it.signature == frame.paletteSignature }
+ val bitmap = remember(frame, activePalette) { renderFrame(frame, activePalette) }
+ Image(
+ bitmap = bitmap,
+ contentDescription = "Device screen",
+ modifier =
+ modifier
+ .widthIn(max = MAX_CANVAS_WIDTH)
+ .fillMaxWidth()
+ .aspectRatio(frame.width.toFloat() / frame.height.toFloat()),
+ filterQuality = FilterQuality.None,
+ )
+}
+
+private class ResolvedRegion(
+ val left: Int,
+ val top: Int,
+ val right: Int,
+ val bottom: Int,
+ val on: Color,
+ val off: Color,
+)
+
+private fun rgb565ToColor(v: Int): Color = Color(
+ red = ((v ushr 11) and 0x1F) * 255 / 31,
+ green = ((v ushr 5) and 0x3F) * 255 / 63,
+ blue = (v and 0x1F) * 255 / 31,
+)
+
+private fun renderFrame(frame: MirrorFrame, palette: MirrorPalette?): ImageBitmap {
+ val defaultOn = palette?.let { rgb565ToColor(it.defaultOnColor) } ?: Color.White
+ val defaultOff = palette?.let { rgb565ToColor(it.defaultOffColor) } ?: Color.Black
+ val regions =
+ palette?.regions.orEmpty().map {
+ ResolvedRegion(
+ left = it.x,
+ top = it.y,
+ right = it.x + it.width,
+ bottom = it.y + it.height,
+ on = rgb565ToColor(it.on_color),
+ off = rgb565ToColor(it.off_color),
+ )
+ }
+
+ val bitmap = ImageBitmap(frame.width, frame.height)
+ val size = Size(frame.width.toFloat(), frame.height.toFloat())
+ CanvasDrawScope().draw(Density(1f), LayoutDirection.Ltr, Canvas(bitmap), size) {
+ drawRect(color = defaultOff)
+ val pixel = Size(1f, 1f)
+ for (y in 0 until frame.height) {
+ val page = (y / PIXELS_PER_PAGE) * frame.width
+ val bit = 1 shl (y % PIXELS_PER_PAGE)
+ // Cull to the regions overlapping this row; the last matching region wins,
+ // matching the firmware's precedence.
+ val rowRegions = regions.filter { y >= it.top && y < it.bottom }
+ for (x in 0 until frame.width) {
+ val set = frame.pixels[page + x].toInt() and bit != 0
+ val region = rowRegions.lastOrNull { x >= it.left && x < it.right }
+ val color =
+ when {
+ region != null -> if (set) region.on else region.off
+ set -> defaultOn
+ else -> defaultOff
+ }
+ if (color != defaultOff) {
+ drawRect(color = color, topLeft = Offset(x.toFloat(), y.toFloat()), size = pixel)
+ }
+ }
+ }
+ }
+ return bitmap
+}
From cff81edfe8ac3cf980899b9e1332a1cf0ff5a8e5 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 13:19:56 -0500
Subject: [PATCH 07/34] feat(debug): adaptive mirror layout and
keyboard-capture exit
Controls sit beside the mirror when the content width allows (>=760dp,
BoxWithConstraints) and stack below it otherwise; tapping the mirror now
toggles keyboard capture instead of only acquiring it, with the hint text
naming the way out.
---
.../settings/debugging/DisplayMirror.kt | 60 +++++++++++++++++--
1 file changed, 54 insertions(+), 6 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 58d4b19d98c..e715d32aa0b 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -25,9 +25,11 @@ import androidx.compose.foundation.gestures.detectDragGestures
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.widthIn
@@ -44,6 +46,7 @@ import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -60,6 +63,7 @@ import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.unit.dp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -101,6 +105,9 @@ private const val REPEAT_INTERVAL_MS = 100L
// Swipes on the mirror shorter than this are ignored as accidental.
private val SWIPE_THRESHOLD = 48.dp
+// Mirror + D-pad fit comfortably side by side above this content width.
+private val SIDE_BY_SIDE_MIN_WIDTH = 760.dp
+
// Firmware input_broker_event codes (src/input/InputBroker.h).
private const val INPUT_SELECT = 10
private const val INPUT_SELECT_LONG = 11
@@ -195,12 +202,44 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
}
when {
- !connected -> Text(text = "Not connected to a device.")
- currentFrame != null -> MirrorSurface(currentFrame, palette, onEvent = viewModel::sendKey)
- else -> Text(text = "No frame received yet — enable mirroring or tap Refresh.")
+ !connected -> {
+ Text(text = "Not connected to a device.")
+ DpadCluster(enabled = false, onEvent = viewModel::sendKey)
+ }
+
+ currentFrame == null -> {
+ Text(text = "No frame received yet — enable mirroring or tap Refresh.")
+ DpadCluster(enabled = connected, onEvent = viewModel::sendKey)
+ }
+
+ else -> MirrorWithControls(currentFrame, palette, enabled = connected, onEvent = viewModel::sendKey)
}
+ }
+}
- DpadCluster(enabled = connected, onEvent = viewModel::sendKey)
+/** Controls sit beside the mirror when the window is wide enough, below it otherwise. */
+@Composable
+private fun MirrorWithControls(frame: MirrorFrame, palette: MirrorPalette?, enabled: Boolean, onEvent: (Int) -> Unit) {
+ BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
+ if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH) {
+ Row(
+ horizontalArrangement = Arrangement.spacedBy(24.dp, Alignment.CenterHorizontally),
+ verticalAlignment = Alignment.CenterVertically,
+ modifier = Modifier.fillMaxWidth(),
+ ) {
+ MirrorSurface(frame, palette, onEvent = onEvent, modifier = Modifier.weight(1f, fill = false))
+ DpadCluster(enabled = enabled, onEvent = onEvent)
+ }
+ } else {
+ Column(
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ modifier = Modifier.fillMaxWidth(),
+ ) {
+ MirrorSurface(frame, palette, onEvent = onEvent)
+ DpadCluster(enabled = enabled, onEvent = onEvent)
+ }
+ }
}
}
@@ -216,7 +255,9 @@ private fun MirrorSurface(
modifier: Modifier = Modifier,
) {
val focusRequester = remember { FocusRequester() }
+ val focusManager = LocalFocusManager.current
var focused by remember { mutableStateOf(false) }
+ val isFocused by rememberUpdatedState(focused)
val focusColor = MaterialTheme.colorScheme.primary
Column(
@@ -236,7 +277,14 @@ private fun MirrorSurface(
true
} ?: false
}
- .pointerInput(Unit) { detectTapGestures(onTap = { focusRequester.requestFocus() }) }
+ .pointerInput(Unit) {
+ detectTapGestures(
+ onTap = {
+ // Tap toggles keyboard control so there is always a way out of capture.
+ if (isFocused) focusManager.clearFocus() else focusRequester.requestFocus()
+ },
+ )
+ }
.swipeToDirection(onEvent)
.border(width = 2.dp, color = if (focused) focusColor else Color.Transparent),
) {
@@ -245,7 +293,7 @@ private fun MirrorSurface(
Text(
text =
if (focused) {
- "Keyboard active: arrows navigate · Enter selects · Esc goes back"
+ "Keyboard active: arrows · Enter = OK · Esc = back — click the screen again to exit"
} else {
"Click the screen for keyboard control, or swipe it to navigate"
},
From 107631397a3fbfd05b5ce42e607a605734825cf4 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:01:37 -0500
Subject: [PATCH 08/34] refactor(debug): pre-PR review fixes for the mirror
Circular D-pad ring replaces the cross cluster (wedge hit-testing with a
radial dead band, hold-to-repeat, per-wedge semantics, haptics), keyboard
capture becomes an explicit chip with tap-to-toggle, and taps on touch
devices forward real panel coordinates (long-press = SELECT, matching the
physical touch driver). Manager gains reset() (wired to ViewModel creation
and disconnect), a palette region cap, and first-chunk geometry pinning;
renderer uses bit-replicated RGB565 and run-length row drawing with the
pixel resolver extracted pure and tested; KeyUp of captured keys is
consumed; ViewModel moved to its own file; all strings localized; the
stray .bak test file is gone.
---
.skills/compose-ui/strings-index.txt | 19 +
.../data/manager/DisplayMirrorManagerImpl.kt | 50 ++-
.../manager/DisplayMirrorManagerImplTest.kt | 33 ++
.../DisplayMirrorManagerImplTest.kt.bak | 134 -------
.../manager/FromRadioPacketHandlerImplTest.kt | 12 +
.../core/repository/DisplayMirrorManager.kt | 6 +
.../composeResources/values/strings.xml | 19 +
.../feature/settings/debugging/Debug.kt | 4 +-
.../settings/debugging/DisplayMirror.kt | 347 ++++++++----------
.../debugging/DisplayMirrorViewModel.kt | 95 +++++
.../feature/settings/debugging/DpadRing.kt | 276 ++++++++++++++
.../settings/debugging/MirrorFrameRenderer.kt | 99 +++--
.../debugging/MirrorColorResolverTest.kt | 87 +++++
13 files changed, 809 insertions(+), 372 deletions(-)
delete mode 100644 core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
create mode 100644 feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
create mode 100644 feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DpadRing.kt
create mode 100644 feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/MirrorColorResolverTest.kt
diff --git a/.skills/compose-ui/strings-index.txt b/.skills/compose-ui/strings-index.txt
index ed13dd5a814..c14d26f9972 100644
--- a/.skills/compose-ui/strings-index.txt
+++ b/.skills/compose-ui/strings-index.txt
@@ -341,6 +341,7 @@ debug_search_prev
debug_store_logs_summary
debug_store_logs_title
debug_tab_app_logs
+debug_tab_mirror
debug_tab_packets
deep_link_connect_message
deep_link_connect_title
@@ -1177,6 +1178,24 @@ metric_channel_label
micrograms_per_cubic_meter
min
minimum_wake_time_seconds
+### MIRROR ###
+mirror_active
+mirror_back
+mirror_device_screen
+mirror_eink_hint
+mirror_frame_info
+mirror_hint_keyboard_active
+mirror_hint_tap_keyboard
+mirror_hint_tap_touch
+mirror_key_down
+mirror_key_left
+mirror_key_ok
+mirror_key_right
+mirror_key_up
+mirror_keyboard
+mirror_no_frame
+mirror_not_connected
+mirror_off
modem_preset
module_settings
modules_already_unlocked
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index e100865cb29..61be808a117 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -31,7 +31,8 @@ import org.meshtastic.proto.DisplayPalette
*
* Chunks of one frame arrive contiguously and in offset order (FromRadio is a reliable ordered stream), so a chunk with
* a new `frame_id` or `offset == 0` starts a new frame and an out-of-sequence chunk drops the partial frame. Calls are
- * serialized by the single receive-loop collector in MeshServiceOrchestrator (recreated per session).
+ * serialized by the single receive-loop collector in MeshServiceOrchestrator; this singleton's state outlives a
+ * session, so [reset] must be called when one ends.
*/
@Single
class DisplayMirrorManagerImpl : DisplayMirrorManager {
@@ -45,6 +46,8 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private var buffer: ByteArray? = null
private var frameId = 0
private var received = 0
+ private var frameWidth = 0
+ private var frameHeight = 0
private var paletteRegions = mutableListOf()
private var paletteSignature = 0
@@ -62,10 +65,13 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
buffer = ByteArray(total)
frameId = chunk.frame_id
received = 0
+ // Geometry is authoritative on the first chunk; a later chunk may not transpose it.
+ frameWidth = chunk.width
+ frameHeight = chunk.height
}
val buf = buffer
- if (buf == null || chunk.frame_id != frameId || chunk.offset != received || buf.size != total) {
+ if (buf == null || !matchesCurrentFrame(chunk, buf.size)) {
Logger.w { "DisplayMirror: bad chunk ${chunk.frame_id}@${chunk.offset}, expected $frameId@$received" }
buffer = null
return
@@ -77,8 +83,8 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
if (received == total) {
_frame.value =
MirrorFrame(
- width = chunk.width,
- height = chunk.height,
+ width = frameWidth,
+ height = frameHeight,
frameId = frameId,
paletteSignature = chunk.palette_signature,
pixels = buf,
@@ -96,8 +102,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
paletteDefaultOn = chunk.default_on_color
paletteDefaultOff = chunk.default_off_color
}
- if (chunk.signature != paletteSignature || chunk.region_offset != paletteReceived) {
- Logger.w { "DisplayMirror: bad palette chunk ${chunk.signature}@${chunk.region_offset}" }
+ if (!isAcceptablePaletteChunk(chunk)) {
paletteRegions.clear()
paletteReceived = -1 // poison until the next offset-0 chunk restarts
return
@@ -116,6 +121,26 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
}
}
+ private fun matchesCurrentFrame(chunk: DisplayFrame, bufSize: Int): Boolean {
+ val inSequence = chunk.frame_id == frameId && chunk.offset == received && bufSize == chunk.total_size
+ val geometryStable = chunk.width == frameWidth && chunk.height == frameHeight
+ return inSequence && geometryStable
+ }
+
+ /** Sequenced continuation of the current palette, within the region cap; logs and rejects anything else. */
+ private fun isAcceptablePaletteChunk(chunk: DisplayPalette): Boolean {
+ val withinCap =
+ chunk.region_total <= MAX_PALETTE_REGIONS &&
+ paletteReceived >= 0 &&
+ paletteReceived + chunk.regions.size <= MAX_PALETTE_REGIONS
+ val inSequence = chunk.signature == paletteSignature && chunk.region_offset == paletteReceived
+ val acceptable = withinCap && inSequence
+ if (!acceptable) {
+ Logger.w { "DisplayMirror: bad palette chunk ${chunk.signature}@${chunk.region_offset}" }
+ }
+ return acceptable
+ }
+
/**
* Format must be MONO_VLSB and width/height must describe exactly total_size bytes; a zero or lying dimension would
* otherwise reach the renderer (aspectRatio requires > 0).
@@ -139,10 +164,23 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
return acceptable
}
+ override fun reset() {
+ buffer = null
+ received = 0
+ paletteRegions = mutableListOf()
+ paletteReceived = 0
+ paletteSignature = 0
+ _frame.value = null
+ _palette.value = null
+ }
+
private companion object {
// Generous sanity cap: 320x240 at 1bpp is 9600 bytes.
const val MAX_FRAME_BYTES = 16384
+ // The firmware's region table caps at 48; anything past this is a bug or an attack.
+ const val MAX_PALETTE_REGIONS = 512
+
// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
const val PIXELS_PER_PAGE = 8
}
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
index 1af13b31cc8..652b89a4424 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -171,6 +171,39 @@ class DisplayMirrorManagerImplTest {
assertEquals(8, manager.palette.value?.signature)
}
+ @Test
+ fun `reset clears frames palettes and partial state`() {
+ manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 9, region_offset = 0, region_total = 0, regions = emptyList()),
+ )
+
+ manager.reset()
+
+ assertNull(manager.frame.value)
+ assertNull(manager.palette.value)
+ }
+
+ @Test
+ fun `rejects palettes past the region cap`() {
+ val region = DisplayPalette.ColorRegion(x = 0, y = 0, width = 8, height = 8)
+ manager.handleIncomingPalette(
+ DisplayPalette(signature = 3, region_offset = 0, region_total = 100_000, regions = listOf(region)),
+ )
+
+ assertNull(manager.palette.value)
+ }
+
+ @Test
+ fun `chunk that changes geometry mid-frame is dropped`() {
+ manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
+ // Transposed geometry with the same total size must not complete the frame
+ manager.handleIncomingFrame(chunk(width = 64, height = 128, offset = 384, data = bytes(384, 2)))
+ manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3)))
+
+ assertNull(manager.frame.value)
+ }
+
private companion object {
const val WIDTH = 128
const val HEIGHT = 64
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
deleted file mode 100644
index f3fe7f4a66d..00000000000
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt.bak
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (c) 2026 Meshtastic LLC
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-package org.meshtastic.core.data.manager
-
-import okio.ByteString.Companion.toByteString
-import org.meshtastic.proto.DisplayFrame
-import kotlin.test.Test
-import kotlin.test.assertContentEquals
-import kotlin.test.assertEquals
-import kotlin.test.assertNull
-
-class DisplayMirrorManagerImplTest {
-
- private val manager = DisplayMirrorManagerImpl()
-
- // 128x64 MONO_VLSB frame = 1024 bytes; the firmware chunks at 384.
- private fun chunk(
- frameId: Int = 1,
- offset: Int = 0,
- data: ByteArray,
- total: Int = FRAME_BYTES,
- width: Int = WIDTH,
- height: Int = HEIGHT,
- format: DisplayFrame.Format = DisplayFrame.Format.MONO_VLSB,
- ) = DisplayFrame(
- width = width,
- height = height,
- format = format,
- frame_id = frameId,
- offset = offset,
- total_size = total,
- data_ = data.toByteString(),
- )
-
- private fun bytes(size: Int, fill: Int) = ByteArray(size) { fill.toByte() }
-
- @Test
- fun `reassembles a three-chunk frame in order`() {
- manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
- manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2)))
- assertNull(manager.frame.value)
-
- manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3)))
-
- val frame = manager.frame.value!!
- assertEquals(WIDTH, frame.width)
- assertEquals(HEIGHT, frame.height)
- assertEquals(1, frame.frameId)
- assertContentEquals(bytes(384, 1) + bytes(384, 2) + bytes(256, 3), frame.pixels)
- }
-
- @Test
- fun `single-chunk frame completes immediately`() {
- // 64x32 = 256 bytes fits one chunk
- manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
-
- assertEquals(256, manager.frame.value?.pixels?.size)
- }
-
- @Test
- fun `out-of-sequence chunk drops the partial frame`() {
- manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
- manager.handleIncomingFrame(chunk(offset = 768, data = bytes(256, 3))) // gap: 384 missing
-
- manager.handleIncomingFrame(chunk(offset = 384, data = bytes(384, 2))) // too late
- assertNull(manager.frame.value)
- }
-
- @Test
- fun `offset zero restarts mid-frame (device reboot or torn capture)`() {
- manager.handleIncomingFrame(chunk(frameId = 5, offset = 0, data = bytes(384, 1)))
-
- // New frame id starting over at offset 0 wins
- manager.handleIncomingFrame(chunk(frameId = 6, offset = 0, data = bytes(384, 4)))
- manager.handleIncomingFrame(chunk(frameId = 6, offset = 384, data = bytes(384, 5)))
- manager.handleIncomingFrame(chunk(frameId = 6, offset = 768, data = bytes(256, 6)))
-
- assertEquals(6, manager.frame.value?.frameId)
- }
-
- @Test
- fun `frame id change mid-frame without offset zero is dropped`() {
- manager.handleIncomingFrame(chunk(frameId = 1, offset = 0, data = bytes(384, 1)))
- manager.handleIncomingFrame(chunk(frameId = 2, offset = 384, data = bytes(384, 2)))
-
- assertNull(manager.frame.value)
- }
-
- @Test
- fun `rejects geometry that does not match total size`() {
- manager.handleIncomingFrame(
- chunk(width = 64, height = 64, total = 256, data = bytes(256, 1)),
- ) // 64x64 needs 512
- manager.handleIncomingFrame(chunk(width = 0, height = 64, total = 0, data = ByteArray(0)))
- manager.handleIncomingFrame(chunk(width = 128, height = 0, total = 0, data = ByteArray(0)))
-
- assertNull(manager.frame.value)
- }
-
- @Test
- fun `rejects unsupported format`() {
- manager.handleIncomingFrame(
- chunk(
- width = 64,
- height = 32,
- total = 256,
- data = bytes(256, 1),
- format = DisplayFrame.Format.FORMAT_UNSPECIFIED,
- ),
- )
-
- assertNull(manager.frame.value)
- }
-
- private companion object {
- const val WIDTH = 128
- const val HEIGHT = 64
- const val FRAME_BYTES = 1024
- }
-}
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
index dbd196b775b..2eb779d3482 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
@@ -45,6 +45,7 @@ import org.meshtastic.proto.ClientNotification
import org.meshtastic.proto.Config
import org.meshtastic.proto.DeviceMetadata
import org.meshtastic.proto.DisplayFrame
+import org.meshtastic.proto.DisplayPalette
import org.meshtastic.proto.FromRadio
import org.meshtastic.proto.LoRaRegionPresetMap
import org.meshtastic.proto.LockdownStatus
@@ -225,11 +226,13 @@ class FromRadioPacketHandlerImplTest {
handle(FromRadio.Builder().also { wb -> wb.xmodemPacket = xmodemPacket }.build())
handle(FromRadio.Builder().also { wb -> wb.lockdown_status = lockdownStatus }.build())
handle(FromRadio(display_frame = DisplayFrame(width = 128, height = 64)))
+ handle(FromRadio(display_palette = DisplayPalette(signature = 1)))
verify(mode = VerifyMode.exactly(0)) { mqttManager.handleMqttProxyMessage(any()) }
verify(mode = VerifyMode.exactly(0)) { packetHandler.handleQueueStatus(any()) }
verify(mode = VerifyMode.exactly(0)) { xmodemManager.handleIncomingXModem(any()) }
verify(mode = VerifyMode.exactly(0)) { displayMirrorManager.handleIncomingFrame(any()) }
+ verify(mode = VerifyMode.exactly(0)) { displayMirrorManager.handleIncomingPalette(any()) }
assertEquals(null, lockdownCoordinator.lastStatus)
}
@@ -242,6 +245,15 @@ class FromRadioPacketHandlerImplTest {
verify { displayMirrorManager.handleIncomingFrame(frame) }
}
+ @Test
+ fun `handleFromRadio routes DISPLAY_PALETTE to displayMirrorManager`() {
+ val palette = DisplayPalette(signature = 7, region_total = 0)
+
+ handle(FromRadio(display_palette = palette))
+
+ verify { displayMirrorManager.handleIncomingPalette(palette) }
+ }
+
@Test
fun `handleFromRadio routes LOCKDOWN_STATUS to lockdownCoordinator`() {
val lockdownStatus =
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
index 058802d9d58..7f075df2935 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -39,6 +39,12 @@ interface DisplayMirrorManager {
/** Routes an incoming palette chunk from the device to the reassembly state machine. */
fun handleIncomingPalette(chunk: DisplayPalette)
+
+ /**
+ * Clears all held state — latest frame, latest palette, and partial reassembly buffers. Call when a session ends or
+ * a fresh mirror UI opens, so a previous device's final screen is never shown as if live.
+ */
+ fun reset()
}
/**
diff --git a/core/resources/src/commonMain/composeResources/values/strings.xml b/core/resources/src/commonMain/composeResources/values/strings.xml
index e0cb031919b..a315669226b 100644
--- a/core/resources/src/commonMain/composeResources/values/strings.xml
+++ b/core/resources/src/commonMain/composeResources/values/strings.xml
@@ -371,6 +371,7 @@
Disable to skip writing mesh logs to disk
Store mesh logs
App logs
+ Mirror
Packets
A link is asking this app to connect to the device at %1$s. Only continue if you trust where the link came from.
Connect to this device?
@@ -1219,6 +1220,24 @@
µg/m³
Min
Minimum wake time
+
+ Mirroring
+ Back
+ Device screen
+ E-ink display: refresh is slow — prefer one-shot Refresh over continuous mirroring.
+ %1$d×%2$d · frame #%3$d
+ Arrows · Enter = OK · Esc = back
+ Click the screen for keyboard control, or swipe it to navigate
+ Tap the screen to touch the device, or swipe to navigate
+ Down
+ Left
+ OK
+ Right
+ Up
+ Keyboard
+ No frame received yet — enable mirroring or tap Refresh.
+ Not connected to a device.
+ Mirror off
Presets
Module configuration
Modules already unlocked
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
index cf581fae895..66390eeb52a 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/Debug.kt
@@ -77,6 +77,7 @@ import org.meshtastic.core.resources.debug_panel
import org.meshtastic.core.resources.debug_store_logs_summary
import org.meshtastic.core.resources.debug_store_logs_title
import org.meshtastic.core.resources.debug_tab_app_logs
+import org.meshtastic.core.resources.debug_tab_mirror
import org.meshtastic.core.resources.debug_tab_packets
import org.meshtastic.core.resources.log_retention_days
import org.meshtastic.core.resources.log_retention_days_quantity
@@ -188,8 +189,7 @@ fun DebugScreen(onNavigateUp: () -> Unit, viewModel: DebugViewModel) {
Tab(
selected = selectedTab == 2,
onClick = { selectedTab = 2 },
- // PoC tab; deliberately unlocalized.
- text = { Text("Mirror") },
+ text = { Text(stringResource(Res.string.debug_tab_mirror)) },
)
}
if (selectedTab == 1) {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index e715d32aa0b..fc57d1a7df4 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -16,7 +16,6 @@
*/
package org.meshtastic.feature.settings.debugging
-import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.combinedClickable
@@ -32,11 +31,10 @@ import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Icon
+import androidx.compose.material3.FilterChip
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Switch
@@ -56,7 +54,7 @@ import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEventType
import androidx.compose.ui.input.key.key
@@ -64,43 +62,34 @@ import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.LocalHapticFeedback
import androidx.compose.ui.unit.dp
-import androidx.lifecycle.ViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.stringResource
import org.koin.compose.viewmodel.koinViewModel
-import org.koin.core.annotation.KoinViewModel
-import org.meshtastic.core.model.ConnectionState
-import org.meshtastic.core.repository.AdminController
-import org.meshtastic.core.repository.ConnectionStateProvider
-import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
-import org.meshtastic.core.repository.NodeRepository
-import org.meshtastic.core.ui.icon.KeyboardArrowDown
-import org.meshtastic.core.ui.icon.KeyboardArrowLeft
-import org.meshtastic.core.ui.icon.KeyboardArrowRight
-import org.meshtastic.core.ui.icon.KeyboardArrowUp
-import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.mirror_active
+import org.meshtastic.core.resources.mirror_back
+import org.meshtastic.core.resources.mirror_eink_hint
+import org.meshtastic.core.resources.mirror_frame_info
+import org.meshtastic.core.resources.mirror_hint_keyboard_active
+import org.meshtastic.core.resources.mirror_hint_tap_keyboard
+import org.meshtastic.core.resources.mirror_hint_tap_touch
+import org.meshtastic.core.resources.mirror_keyboard
+import org.meshtastic.core.resources.mirror_no_frame
+import org.meshtastic.core.resources.mirror_not_connected
+import org.meshtastic.core.resources.mirror_off
+import org.meshtastic.core.resources.refresh
import org.meshtastic.proto.DisplayInfo
// M3 comfortable target for remote-control keys (48dp minimum + breathing room).
private val DPAD_KEY_SIZE = 56.dp
-private val DPAD_GAP = 8.dp
// OS-typematic-style auto-repeat, slowed to what a LoRa radio UI can render.
-private const val REPEAT_INITIAL_DELAY_MS = 500L
-private const val REPEAT_INTERVAL_MS = 100L
+internal const val REPEAT_INITIAL_DELAY_MS = 500L
+internal const val REPEAT_INTERVAL_MS = 100L
// Swipes on the mirror shorter than this are ignored as accidental.
private val SWIPE_THRESHOLD = 48.dp
@@ -108,63 +97,18 @@ private val SWIPE_THRESHOLD = 48.dp
// Mirror + D-pad fit comfortably side by side above this content width.
private val SIDE_BY_SIDE_MIN_WIDTH = 760.dp
-// Firmware input_broker_event codes (src/input/InputBroker.h).
-private const val INPUT_SELECT = 10
-private const val INPUT_SELECT_LONG = 11
-private const val INPUT_UP = 17
-private const val INPUT_DOWN = 18
-private const val INPUT_LEFT = 19
-private const val INPUT_RIGHT = 20
-private const val INPUT_BACK = 27
-
-@KoinViewModel
-class DisplayMirrorViewModel(
- displayMirrorManager: DisplayMirrorManager,
- connectionStateProvider: ConnectionStateProvider,
- nodeRepository: NodeRepository,
- private val adminController: AdminController,
-) : ViewModel() {
-
- val frame: StateFlow = displayMirrorManager.frame
-
- val palette: StateFlow = displayMirrorManager.palette
-
- val connected: StateFlow =
- connectionStateProvider.connectionState
- .map { it is ConnectionState.Connected }
- .stateIn(viewModelScope, SharingStarted.Eagerly, false)
-
- /** Panel description from the connect handshake; null on display-less nodes and pre-DisplayInfo firmware. */
- val displayInfo: StateFlow =
- nodeRepository.ourNodeInfo.map { it?.metadata?.display }.stateIn(viewModelScope, SharingStarted.Eagerly, null)
-
- private val _mirroring = MutableStateFlow(false)
- val mirroring: StateFlow = _mirroring.asStateFlow()
-
- init {
- // The device forgets the (non-persisted) mirror setting on disconnect/reboot;
- // mirror the reset locally so the toggle never claims a dead stream is live.
- viewModelScope.launch { connected.collect { if (!it) _mirroring.value = false } }
- }
-
- fun setMirror(enabled: Boolean) {
- adminController.setDisplayMirror(enabled)
- _mirroring.value = enabled
- }
-
- fun requestFrame() = adminController.requestDisplayFrame()
-
- fun sendKey(eventCode: Int) = adminController.sendInputEvent(eventCode)
-
- /** Stops a live stream when the mirror UI goes away; safe to call redundantly. */
- fun stopMirroring() {
- if (_mirroring.value) setMirror(false)
- }
-
- override fun onCleared() = stopMirroring()
-}
-
-/** PoC live view of the connected device's screen, with remote D-pad control. Strings are deliberately unlocalized. */
+// Firmware input_broker_event codes (src/input/InputBroker.h). USER_PRESS is
+// what physical touch drivers emit for a tap, with touch coordinates attached.
+internal const val INPUT_SELECT = 10
+internal const val INPUT_SELECT_LONG = 11
+internal const val INPUT_UP = 17
+internal const val INPUT_DOWN = 18
+internal const val INPUT_LEFT = 19
+internal const val INPUT_RIGHT = 20
+internal const val INPUT_BACK = 27
+internal const val INPUT_USER_PRESS = 28
+
+/** Live view of the connected device's screen, with remote D-pad, keyboard, and touch control. */
@Composable
fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
val frame by viewModel.frame.collectAsStateWithLifecycle()
@@ -184,42 +128,66 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
val currentFrame = frame
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
Switch(checked = mirroring, onCheckedChange = viewModel::setMirror, enabled = connected)
- Text(text = if (mirroring) "Mirroring" else "Mirror off", style = MaterialTheme.typography.titleMedium)
- OutlinedButton(onClick = viewModel::requestFrame, enabled = connected) { Text("Refresh") }
+ Text(
+ text = stringResource(if (mirroring) Res.string.mirror_active else Res.string.mirror_off),
+ style = MaterialTheme.typography.titleMedium,
+ )
+ OutlinedButton(onClick = viewModel::requestFrame, enabled = connected) {
+ Text(stringResource(Res.string.refresh))
+ }
if (currentFrame != null) {
Text(
- text = "${currentFrame.width}x${currentFrame.height} frame #${currentFrame.frameId}",
+ text =
+ stringResource(
+ Res.string.mirror_frame_info,
+ currentFrame.width,
+ currentFrame.height,
+ currentFrame.frameId,
+ ),
style = MaterialTheme.typography.labelSmall,
)
}
}
if (displayInfo?.panel_class == DisplayInfo.PanelClass.EINK) {
- Text(
- text = "E-ink display: refresh is slow — prefer one-shot Refresh over continuous mirroring.",
- style = MaterialTheme.typography.labelSmall,
- )
+ Text(text = stringResource(Res.string.mirror_eink_hint), style = MaterialTheme.typography.labelSmall)
}
when {
!connected -> {
- Text(text = "Not connected to a device.")
+ Text(text = stringResource(Res.string.mirror_not_connected))
DpadCluster(enabled = false, onEvent = viewModel::sendKey)
}
currentFrame == null -> {
- Text(text = "No frame received yet — enable mirroring or tap Refresh.")
+ Text(text = stringResource(Res.string.mirror_no_frame))
DpadCluster(enabled = connected, onEvent = viewModel::sendKey)
}
- else -> MirrorWithControls(currentFrame, palette, enabled = connected, onEvent = viewModel::sendKey)
+ else ->
+ MirrorWithControls(
+ currentFrame,
+ palette,
+ enabled = connected,
+ hasTouch = displayInfo?.has_touch == true,
+ onEvent = viewModel::sendKey,
+ onTouch = viewModel::sendTouch,
+ )
}
}
}
/** Controls sit beside the mirror when the window is wide enough, below it otherwise. */
+@Suppress("LongParameterList")
@Composable
-private fun MirrorWithControls(frame: MirrorFrame, palette: MirrorPalette?, enabled: Boolean, onEvent: (Int) -> Unit) {
+private fun MirrorWithControls(
+ frame: MirrorFrame,
+ palette: MirrorPalette?,
+ enabled: Boolean,
+ hasTouch: Boolean,
+ onEvent: (Int) -> Unit,
+ onTouch: (Int, Int, Int) -> Unit,
+) {
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH) {
Row(
@@ -227,7 +195,7 @@ private fun MirrorWithControls(frame: MirrorFrame, palette: MirrorPalette?, enab
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.fillMaxWidth(),
) {
- MirrorSurface(frame, palette, onEvent = onEvent, modifier = Modifier.weight(1f, fill = false))
+ MirrorSurface(frame, palette, hasTouch, onEvent, onTouch, modifier = Modifier.weight(1f, fill = false))
DpadCluster(enabled = enabled, onEvent = onEvent)
}
} else {
@@ -236,7 +204,7 @@ private fun MirrorWithControls(frame: MirrorFrame, palette: MirrorPalette?, enab
verticalArrangement = Arrangement.spacedBy(12.dp),
modifier = Modifier.fillMaxWidth(),
) {
- MirrorSurface(frame, palette, onEvent = onEvent)
+ MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
DpadCluster(enabled = enabled, onEvent = onEvent)
}
}
@@ -244,22 +212,28 @@ private fun MirrorWithControls(frame: MirrorFrame, palette: MirrorPalette?, enab
}
/**
- * The live mirror plus its direct input affordances: click to focus (keyboard capture — arrows, Enter/Space = OK,
- * Esc/Backspace = Back), swipe in a cardinal direction for a single direction event.
+ * The live mirror plus its direct input affordances: a Keyboard chip toggles key capture (arrows, Enter/Space = OK,
+ * Esc/Backspace = Back), swiping in a cardinal direction sends one direction event, and on touch-capable devices
+ * tapping or long-pressing the image forwards real touch coordinates; elsewhere a tap toggles capture.
*/
@Composable
+@Suppress("LongParameterList")
private fun MirrorSurface(
frame: MirrorFrame,
palette: MirrorPalette?,
+ hasTouch: Boolean,
onEvent: (Int) -> Unit,
+ onTouch: (Int, Int, Int) -> Unit,
modifier: Modifier = Modifier,
) {
val focusRequester = remember { FocusRequester() }
val focusManager = LocalFocusManager.current
var focused by remember { mutableStateOf(false) }
- val isFocused by rememberUpdatedState(focused)
+ val currentFrame by rememberUpdatedState(frame)
val focusColor = MaterialTheme.colorScheme.primary
+ fun toggleKeyboard() = if (focused) focusManager.clearFocus() else focusRequester.requestFocus()
+
Column(
modifier = modifier,
horizontalAlignment = Alignment.CenterHorizontally,
@@ -271,17 +245,34 @@ private fun MirrorSurface(
.onFocusChanged { focused = it.isFocused }
.focusable()
.onPreviewKeyEvent { event ->
- if (event.type != KeyEventType.KeyDown) return@onPreviewKeyEvent false
- keyToInputEvent(event.key)?.let {
- onEvent(it)
- true
- } ?: false
+ val mapped = keyToInputEvent(event.key) ?: return@onPreviewKeyEvent false
+ // Consume KeyUp of mapped keys too, or Space/arrows leak to the scroll container.
+ if (event.type == KeyEventType.KeyDown) onEvent(mapped)
+ true
}
- .pointerInput(Unit) {
+ .pointerInput(hasTouch) {
detectTapGestures(
- onTap = {
- // Tap toggles keyboard control so there is always a way out of capture.
- if (isFocused) focusManager.clearFocus() else focusRequester.requestFocus()
+ onTap = { offset ->
+ if (hasTouch) {
+ onTouch(
+ INPUT_USER_PRESS,
+ offset.toDeviceX(size.width, currentFrame),
+ offset.toDeviceY(size.height, currentFrame),
+ )
+ } else {
+ // Tap toggles keyboard control so there is always a way out of capture.
+ toggleKeyboard()
+ }
+ },
+ onLongPress = { offset ->
+ // Physical touch drivers map a long-press to SELECT with coordinates.
+ if (hasTouch) {
+ onTouch(
+ INPUT_SELECT,
+ offset.toDeviceX(size.width, currentFrame),
+ offset.toDeviceY(size.height, currentFrame),
+ )
+ }
},
)
}
@@ -290,18 +281,39 @@ private fun MirrorSurface(
) {
MirrorFrameImage(frame, palette)
}
+ MirrorControlHints(focused = focused, hasTouch = hasTouch, onToggleKeyboard = { toggleKeyboard() })
+ }
+}
+
+@Composable
+private fun MirrorControlHints(focused: Boolean, hasTouch: Boolean, onToggleKeyboard: () -> Unit) {
+ Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ FilterChip(
+ selected = focused,
+ onClick = onToggleKeyboard,
+ label = { Text(stringResource(Res.string.mirror_keyboard)) },
+ )
Text(
text =
- if (focused) {
- "Keyboard active: arrows · Enter = OK · Esc = back — click the screen again to exit"
- } else {
- "Click the screen for keyboard control, or swipe it to navigate"
- },
+ stringResource(
+ when {
+ focused -> Res.string.mirror_hint_keyboard_active
+ hasTouch -> Res.string.mirror_hint_tap_touch
+ else -> Res.string.mirror_hint_tap_keyboard
+ },
+ ),
style = MaterialTheme.typography.labelSmall,
)
}
}
+/** Scales a tap position on the scaled-up mirror image back to panel pixel coordinates. */
+private fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
+ (x / boxWidthPx * frame.width).toInt().coerceIn(0, frame.width - 1)
+
+private fun Offset.toDeviceY(boxHeightPx: Int, frame: MirrorFrame): Int =
+ (y / boxHeightPx * frame.height).toInt().coerceIn(0, frame.height - 1)
+
private fun keyToInputEvent(key: Key): Int? = when (key) {
Key.DirectionUp -> INPUT_UP
@@ -348,97 +360,27 @@ private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointe
)
}
-/**
- * Cross-shaped 5-way cluster with Back below-left, following the TV-remote convention: directions auto-repeat on hold
- * (500ms delay, then 10Hz — slow enough for the radio to render), OK long-press sends the firmware's SELECT_LONG.
- */
+/** The remote cluster: circular 5-way ring (see [DpadRing]) with Back below-left, per TV-remote convention. */
@Composable
private fun DpadCluster(enabled: Boolean, onEvent: (Int) -> Unit, modifier: Modifier = Modifier) {
Column(
modifier = modifier,
- horizontalAlignment = Alignment.CenterHorizontally,
- verticalArrangement = Arrangement.spacedBy(DPAD_GAP),
- ) {
- RepeatingKey(MeshtasticIcons.KeyboardArrowUp, "Up", enabled) { onEvent(INPUT_UP) }
- Row(horizontalArrangement = Arrangement.spacedBy(DPAD_GAP)) {
- RepeatingKey(MeshtasticIcons.KeyboardArrowLeft, "Left", enabled) { onEvent(INPUT_LEFT) }
- OkKey(
- enabled = enabled,
- onSelect = { onEvent(INPUT_SELECT) },
- onSelectLong = { onEvent(INPUT_SELECT_LONG) },
- )
- RepeatingKey(MeshtasticIcons.KeyboardArrowRight, "Right", enabled) { onEvent(INPUT_RIGHT) }
- }
- RepeatingKey(MeshtasticIcons.KeyboardArrowDown, "Down", enabled) { onEvent(INPUT_DOWN) }
- Row(modifier = Modifier.widthIn(min = DPAD_KEY_SIZE * 3 + DPAD_GAP * 2)) {
- BackKey(enabled = enabled) { onEvent(INPUT_BACK) }
- }
- }
-}
-
-/** A direction key: fires on press, then auto-repeats while held. */
-@Composable
-private fun RepeatingKey(icon: ImageVector, label: String, enabled: Boolean, onEvent: () -> Unit) {
- var pressed by remember { mutableStateOf(false) }
- val background =
- when {
- !enabled -> MaterialTheme.colorScheme.surfaceVariant
- pressed -> MaterialTheme.colorScheme.primaryContainer
- else -> MaterialTheme.colorScheme.secondaryContainer
- }
- Box(
- contentAlignment = Alignment.Center,
- modifier =
- Modifier.size(DPAD_KEY_SIZE).clip(CircleShape).background(background).pointerInput(enabled) {
- if (!enabled) return@pointerInput
- coroutineScope {
- detectTapGestures(
- onPress = {
- pressed = true
- onEvent()
- val repeater = launch {
- delay(REPEAT_INITIAL_DELAY_MS)
- while (isActive) {
- onEvent()
- delay(REPEAT_INTERVAL_MS)
- }
- }
- tryAwaitRelease()
- repeater.cancel()
- pressed = false
- },
- )
- }
- },
- ) {
- Icon(imageVector = icon, contentDescription = label, tint = contentColorFor(enabled))
- }
-}
-
-/** Center OK: tap selects, long-press sends SELECT_LONG. */
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-private fun OkKey(enabled: Boolean, onSelect: () -> Unit, onSelectLong: () -> Unit) {
- Box(
- contentAlignment = Alignment.Center,
- modifier =
- Modifier.size(DPAD_KEY_SIZE)
- .clip(CircleShape)
- .background(
- if (enabled) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
- )
- .combinedClickable(enabled = enabled, onLongClick = onSelectLong, onClick = onSelect),
+ horizontalAlignment = Alignment.Start,
+ verticalArrangement = Arrangement.spacedBy(12.dp),
) {
- Text(
- text = "OK",
- style = MaterialTheme.typography.titleSmall,
- color = if (enabled) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant,
+ DpadRing(
+ enabled = enabled,
+ onEvent = onEvent,
+ onSelect = { onEvent(INPUT_SELECT) },
+ onSelectLong = { onEvent(INPUT_SELECT_LONG) },
)
+ BackKey(enabled = enabled) { onEvent(INPUT_BACK) }
}
}
@Composable
private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
+ val haptics = LocalHapticFeedback.current
Box(
contentAlignment = Alignment.Center,
modifier =
@@ -451,9 +393,16 @@ private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
MaterialTheme.colorScheme.surfaceVariant
},
)
- .combinedClickable(enabled = enabled, onClick = onBack),
+ .combinedClickable(enabled = enabled) {
+ haptics.performHapticFeedback(HapticFeedbackType.VirtualKey)
+ onBack()
+ },
) {
- Text(text = "Back", style = MaterialTheme.typography.labelMedium, color = contentColorFor(enabled))
+ Text(
+ text = stringResource(Res.string.mirror_back),
+ style = MaterialTheme.typography.labelMedium,
+ color = contentColorFor(enabled),
+ )
}
}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
new file mode 100644
index 00000000000..cc1e72c8465
--- /dev/null
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import org.koin.core.annotation.KoinViewModel
+import org.meshtastic.core.model.ConnectionState
+import org.meshtastic.core.repository.AdminController
+import org.meshtastic.core.repository.ConnectionStateProvider
+import org.meshtastic.core.repository.DisplayMirrorManager
+import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.repository.MirrorPalette
+import org.meshtastic.core.repository.NodeRepository
+import org.meshtastic.proto.DisplayInfo
+
+@KoinViewModel
+class DisplayMirrorViewModel(
+ private val displayMirrorManager: DisplayMirrorManager,
+ connectionStateProvider: ConnectionStateProvider,
+ nodeRepository: NodeRepository,
+ private val adminController: AdminController,
+) : ViewModel() {
+
+ val frame: StateFlow = displayMirrorManager.frame
+
+ val palette: StateFlow = displayMirrorManager.palette
+
+ val connected: StateFlow =
+ connectionStateProvider.connectionState
+ .map { it is ConnectionState.Connected }
+ .stateIn(viewModelScope, SharingStarted.Eagerly, false)
+
+ /** Panel description from the connect handshake; null on display-less nodes and pre-DisplayInfo firmware. */
+ val displayInfo: StateFlow =
+ nodeRepository.ourNodeInfo.map { it?.metadata?.display }.stateIn(viewModelScope, SharingStarted.Eagerly, null)
+
+ private val _mirroring = MutableStateFlow(false)
+ val mirroring: StateFlow = _mirroring.asStateFlow()
+
+ init {
+ // A fresh mirror UI must never show a previous device's final screen as if live.
+ displayMirrorManager.reset()
+ // The device forgets the (non-persisted) mirror setting on disconnect/reboot;
+ // mirror the reset locally so the toggle never claims a dead stream is live.
+ viewModelScope.launch {
+ connected.collect {
+ if (!it) {
+ _mirroring.value = false
+ displayMirrorManager.reset()
+ }
+ }
+ }
+ }
+
+ fun setMirror(enabled: Boolean) {
+ adminController.setDisplayMirror(enabled)
+ _mirroring.value = enabled
+ }
+
+ fun requestFrame() = adminController.requestDisplayFrame()
+
+ fun sendKey(eventCode: Int) = adminController.sendInputEvent(eventCode)
+
+ /** Forwards a tap/long-press on the mirrored image as a device touch event with panel coordinates. */
+ fun sendTouch(eventCode: Int, x: Int, y: Int) = adminController.sendInputEvent(eventCode, touchX = x, touchY = y)
+
+ /** Stops a live stream when the mirror UI goes away; safe to call redundantly. */
+ fun stopMirroring() {
+ if (_mirroring.value) setMirror(false)
+ }
+
+ override fun onCleared() = stopMirroring()
+}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DpadRing.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DpadRing.kt
new file mode 100644
index 00000000000..3895d7650d0
--- /dev/null
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DpadRing.kt
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.waitForUpOrCancellation
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.hapticfeedback.HapticFeedback
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.onClick
+import androidx.compose.ui.semantics.role
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.StringResource
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.mirror_key_down
+import org.meshtastic.core.resources.mirror_key_left
+import org.meshtastic.core.resources.mirror_key_ok
+import org.meshtastic.core.resources.mirror_key_right
+import org.meshtastic.core.resources.mirror_key_up
+import org.meshtastic.core.ui.icon.KeyboardArrowDown
+import org.meshtastic.core.ui.icon.KeyboardArrowLeft
+import org.meshtastic.core.ui.icon.KeyboardArrowRight
+import org.meshtastic.core.ui.icon.KeyboardArrowUp
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import kotlin.math.PI
+import kotlin.math.atan2
+import kotlin.math.hypot
+
+// Geometry per the TV-remote research: ~220dp ring, 72-80dp center disc,
+// a radial dead band between disc and ring so ambiguous presses do nothing.
+private val RING_DIAMETER = 220.dp
+private val OK_DISC_DIAMETER = 76.dp
+private val DEAD_ZONE = 12.dp
+
+private const val WEDGE_SWEEP_DEG = 90f
+private const val FULL_CIRCLE_DEG = 360f
+private const val RAD_TO_DEG = (180.0 / PI).toFloat()
+
+// Minimum comfortable assistive-tech target (M3).
+private val SEMANTICS_TARGET = 48.dp
+
+// One direction wedge of the ring: hit-test bounds, highlight arc, icon placement.
+private class Wedge(
+ val eventCode: Int,
+ val label: StringResource,
+ val startAngleDeg: Float,
+ val iconOffsetX: Dp,
+ val iconOffsetY: Dp,
+)
+
+@Suppress("MagicNumber")
+private fun buildWedges(iconRadius: Dp): List = listOf(
+ Wedge(INPUT_RIGHT, Res.string.mirror_key_right, -45f, iconRadius, 0.dp),
+ Wedge(INPUT_DOWN, Res.string.mirror_key_down, 45f, 0.dp, iconRadius),
+ Wedge(INPUT_LEFT, Res.string.mirror_key_left, 135f, -iconRadius, 0.dp),
+ Wedge(INPUT_UP, Res.string.mirror_key_up, 225f, 0.dp, -iconRadius),
+)
+
+@Composable
+private fun wedgeIcon(eventCode: Int) = when (eventCode) {
+ INPUT_UP -> MeshtasticIcons.KeyboardArrowUp
+ INPUT_DOWN -> MeshtasticIcons.KeyboardArrowDown
+ INPUT_LEFT -> MeshtasticIcons.KeyboardArrowLeft
+ else -> MeshtasticIcons.KeyboardArrowRight
+}
+
+private fun List.at(angleDeg: Float): Wedge = first { wedge ->
+ val start = (wedge.startAngleDeg + FULL_CIRCLE_DEG) % FULL_CIRCLE_DEG
+ val normalized = if (angleDeg < start) angleDeg + FULL_CIRCLE_DEG else angleDeg
+ normalized >= start && normalized < start + WEDGE_SWEEP_DEG
+}
+
+/**
+ * Circular 5-way remote cluster: four direction wedges around a center OK disc, the layout every TV remote converged
+ * on. Directions fire on press and auto-repeat while held; OK taps SELECT and long-presses SELECT_LONG. Wedge
+ * hit-testing is by angle with a dead band around the disc; each wedge also carries its own semantics node so screen
+ * readers see four buttons, not one blob.
+ */
+@Composable
+internal fun DpadRing(
+ enabled: Boolean,
+ onEvent: (Int) -> Unit,
+ onSelect: () -> Unit,
+ onSelectLong: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val haptics = LocalHapticFeedback.current
+ var pressedWedge by remember { mutableStateOf(null) }
+ // Icons and semantics targets sit on the ring stroke's center line.
+ val wedges = remember { buildWedges((RING_DIAMETER / 2 + OK_DISC_DIAMETER / 2 + DEAD_ZONE) / 2) }
+
+ val ringColor =
+ if (enabled) MaterialTheme.colorScheme.secondaryContainer else MaterialTheme.colorScheme.surfaceVariant
+ val pressedColor = MaterialTheme.colorScheme.primaryContainer
+
+ Box(modifier = modifier.size(RING_DIAMETER), contentAlignment = Alignment.Center) {
+ Canvas(
+ modifier =
+ Modifier.size(RING_DIAMETER)
+ .ringPresses(enabled, wedges, haptics, onPressChange = { pressedWedge = it }, onEvent = onEvent),
+ ) {
+ drawRing(ringColor, pressedColor, wedges, pressedWedge)
+ }
+ WedgeDecorations(wedges = wedges, enabled = enabled, onEvent = onEvent)
+ OkDisc(enabled = enabled, haptics = haptics, onSelect = onSelect, onSelectLong = onSelectLong)
+ }
+}
+
+/** Press handling for the ring: angle hit-testing outside the dead band, then fire + auto-repeat until release. */
+private fun Modifier.ringPresses(
+ enabled: Boolean,
+ wedges: List,
+ haptics: HapticFeedback,
+ onPressChange: (Int?) -> Unit,
+ onEvent: (Int) -> Unit,
+): Modifier = pointerInput(enabled) {
+ if (!enabled) return@pointerInput
+ val outerR = size.width / 2f
+ val innerR = (OK_DISC_DIAMETER.toPx() / 2f) + DEAD_ZONE.toPx()
+ val center = Offset(outerR, outerR)
+ coroutineScope {
+ awaitEachGesture {
+ val down = awaitFirstDown()
+ val d = down.position - center
+ val r = hypot(d.x, d.y)
+ if (r < innerR || r > outerR) return@awaitEachGesture
+ down.consume()
+ val angle = (atan2(d.y, d.x) * RAD_TO_DEG + FULL_CIRCLE_DEG) % FULL_CIRCLE_DEG
+ val wedge = wedges.at(angle)
+ onPressChange(wedge.eventCode)
+ haptics.performHapticFeedback(HapticFeedbackType.VirtualKey)
+ onEvent(wedge.eventCode)
+ val repeater = launch {
+ delay(REPEAT_INITIAL_DELAY_MS)
+ while (isActive) {
+ haptics.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick)
+ onEvent(wedge.eventCode)
+ delay(REPEAT_INTERVAL_MS)
+ }
+ }
+ try {
+ waitForUpOrCancellation()
+ } finally {
+ // The pointerInput coroutine can be cancelled mid-press (enabled
+ // flip, node removal); never leave a wedge stuck highlighted.
+ repeater.cancel()
+ onPressChange(null)
+ }
+ }
+ }
+}
+
+private fun DrawScope.drawRing(ringColor: Color, pressedColor: Color, wedges: List, pressedWedge: Int?) {
+ val outerR = size.width / 2f
+ val visualInnerR = (OK_DISC_DIAMETER.toPx() / 2f) + DEAD_ZONE.toPx()
+ val strokeWidth = outerR - visualInnerR
+ val strokeRadius = (outerR + visualInnerR) / 2f
+ drawCircle(color = ringColor, radius = strokeRadius, style = Stroke(width = strokeWidth))
+ pressedWedge?.let { pressed ->
+ val wedge = wedges.first { it.eventCode == pressed }
+ drawArc(
+ color = pressedColor,
+ startAngle = wedge.startAngleDeg,
+ sweepAngle = WEDGE_SWEEP_DEG,
+ useCenter = false,
+ topLeft = Offset(outerR - strokeRadius, outerR - strokeRadius),
+ size = Size(strokeRadius * 2f, strokeRadius * 2f),
+ style = Stroke(width = strokeWidth),
+ )
+ }
+}
+
+/** Chevron icons plus one invisible semantics button per wedge so assistive tech sees four discrete controls. */
+@Composable
+private fun WedgeDecorations(wedges: List, enabled: Boolean, onEvent: (Int) -> Unit) {
+ val iconColor =
+ if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
+ wedges.forEach { wedge ->
+ val label = stringResource(wedge.label)
+ Icon(
+ imageVector = wedgeIcon(wedge.eventCode),
+ contentDescription = null,
+ tint = iconColor,
+ modifier = Modifier.offset(x = wedge.iconOffsetX, y = wedge.iconOffsetY),
+ )
+ Box(
+ modifier =
+ Modifier.offset(x = wedge.iconOffsetX, y = wedge.iconOffsetY).size(SEMANTICS_TARGET).semantics {
+ role = Role.Button
+ contentDescription = label
+ onClick(label = label) {
+ if (enabled) onEvent(wedge.eventCode)
+ enabled
+ }
+ },
+ )
+ }
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+private fun OkDisc(enabled: Boolean, haptics: HapticFeedback, onSelect: () -> Unit, onSelectLong: () -> Unit) {
+ Box(
+ contentAlignment = Alignment.Center,
+ modifier =
+ Modifier.size(OK_DISC_DIAMETER)
+ .clip(CircleShape)
+ .background(
+ if (enabled) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.surfaceVariant,
+ )
+ .combinedClickable(
+ enabled = enabled,
+ onLongClick = onSelectLong,
+ onClick = {
+ haptics.performHapticFeedback(HapticFeedbackType.VirtualKey)
+ onSelect()
+ },
+ ),
+ ) {
+ val okColor = if (enabled) MaterialTheme.colorScheme.onPrimary else MaterialTheme.colorScheme.onSurfaceVariant
+ Text(
+ text = stringResource(Res.string.mirror_key_ok),
+ style = MaterialTheme.typography.titleMedium,
+ color = okColor,
+ )
+ }
+}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
index 7bff3ef7182..14272d637da 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
@@ -33,8 +33,11 @@ import androidx.compose.ui.graphics.drawscope.CanvasDrawScope
import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.mirror_device_screen
// 4x scale for the common 128px-wide OLED; caps the image so the D-pad stays above the fold on desktop.
private val MAX_CANVAS_WIDTH = 512.dp
@@ -53,7 +56,7 @@ internal fun MirrorFrameImage(frame: MirrorFrame, palette: MirrorPalette?, modif
val bitmap = remember(frame, activePalette) { renderFrame(frame, activePalette) }
Image(
bitmap = bitmap,
- contentDescription = "Device screen",
+ contentDescription = stringResource(Res.string.mirror_device_screen),
modifier =
modifier
.widthIn(max = MAX_CANVAS_WIDTH)
@@ -63,7 +66,8 @@ internal fun MirrorFrameImage(frame: MirrorFrame, palette: MirrorPalette?, modif
)
}
-private class ResolvedRegion(
+/** One colorized rectangle with palette colors pre-resolved to Compose colors. */
+internal class ResolvedRegion(
val left: Int,
val top: Int,
val right: Int,
@@ -72,51 +76,84 @@ private class ResolvedRegion(
val off: Color,
)
-private fun rgb565ToColor(v: Int): Color = Color(
- red = ((v ushr 11) and 0x1F) * 255 / 31,
- green = ((v ushr 5) and 0x3F) * 255 / 63,
- blue = (v and 0x1F) * 255 / 31,
-)
+/** Expands RGB565 to 8-bit channels by bit replication (the canonical expansion; plain scaling floors). */
+@Suppress("MagicNumber")
+internal fun rgb565ToColor(v: Int): Color {
+ val r5 = (v ushr 11) and 0x1F
+ val g6 = (v ushr 5) and 0x3F
+ val b5 = v and 0x1F
+ return Color(red = (r5 shl 3) or (r5 ushr 2), green = (g6 shl 2) or (g6 ushr 4), blue = (b5 shl 3) or (b5 ushr 2))
+}
+
+/**
+ * Resolves one pixel against the regions overlapping its row, highest table index winning — the firmware's precedence.
+ * [rowRegions] must already be culled to the pixel's row.
+ */
+internal fun resolvePixelColor(
+ x: Int,
+ set: Boolean,
+ rowRegions: List,
+ defaultOn: Color,
+ defaultOff: Color,
+): Color {
+ for (i in rowRegions.indices.reversed()) {
+ val region = rowRegions[i]
+ if (x >= region.left && x < region.right) return if (set) region.on else region.off
+ }
+ return if (set) defaultOn else defaultOff
+}
+
+internal fun MirrorPalette.resolveRegions(): List = regions.map {
+ ResolvedRegion(
+ left = it.x,
+ top = it.y,
+ right = it.x + it.width,
+ bottom = it.y + it.height,
+ on = rgb565ToColor(it.on_color),
+ off = rgb565ToColor(it.off_color),
+ )
+}
private fun renderFrame(frame: MirrorFrame, palette: MirrorPalette?): ImageBitmap {
val defaultOn = palette?.let { rgb565ToColor(it.defaultOnColor) } ?: Color.White
val defaultOff = palette?.let { rgb565ToColor(it.defaultOffColor) } ?: Color.Black
- val regions =
- palette?.regions.orEmpty().map {
- ResolvedRegion(
- left = it.x,
- top = it.y,
- right = it.x + it.width,
- bottom = it.y + it.height,
- on = rgb565ToColor(it.on_color),
- off = rgb565ToColor(it.off_color),
- )
- }
+ val regions = palette?.resolveRegions().orEmpty()
val bitmap = ImageBitmap(frame.width, frame.height)
val size = Size(frame.width.toFloat(), frame.height.toFloat())
CanvasDrawScope().draw(Density(1f), LayoutDirection.Ltr, Canvas(bitmap), size) {
drawRect(color = defaultOff)
- val pixel = Size(1f, 1f)
+ val rowRegions = ArrayList(regions.size)
for (y in 0 until frame.height) {
+ rowRegions.clear()
+ for (region in regions) if (y >= region.top && y < region.bottom) rowRegions.add(region)
+
val page = (y / PIXELS_PER_PAGE) * frame.width
val bit = 1 shl (y % PIXELS_PER_PAGE)
- // Cull to the regions overlapping this row; the last matching region wins,
- // matching the firmware's precedence.
- val rowRegions = regions.filter { y >= it.top && y < it.bottom }
+ // Emit horizontal runs of identical color; framebuffers are run-heavy,
+ // and one draw per run beats one draw per pixel by orders of magnitude.
+ var runStart = 0
+ var runColor: Color? = null
+ fun flush(endExclusive: Int) {
+ val color = runColor
+ if (color != null && color != defaultOff) {
+ drawRect(
+ color = color,
+ topLeft = Offset(runStart.toFloat(), y.toFloat()),
+ size = Size((endExclusive - runStart).toFloat(), 1f),
+ )
+ }
+ }
for (x in 0 until frame.width) {
val set = frame.pixels[page + x].toInt() and bit != 0
- val region = rowRegions.lastOrNull { x >= it.left && x < it.right }
- val color =
- when {
- region != null -> if (set) region.on else region.off
- set -> defaultOn
- else -> defaultOff
- }
- if (color != defaultOff) {
- drawRect(color = color, topLeft = Offset(x.toFloat(), y.toFloat()), size = pixel)
+ val color = resolvePixelColor(x, set, rowRegions, defaultOn, defaultOff)
+ if (color != runColor) {
+ flush(x)
+ runStart = x
+ runColor = color
}
}
+ flush(frame.width)
}
}
return bitmap
diff --git a/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/MirrorColorResolverTest.kt b/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/MirrorColorResolverTest.kt
new file mode 100644
index 00000000000..0561e5da7ef
--- /dev/null
+++ b/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/MirrorColorResolverTest.kt
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.compose.ui.graphics.Color
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class MirrorColorResolverTest {
+
+ @Test
+ fun `rgb565 expands by bit replication`() {
+ assertEquals(Color(255, 255, 255), rgb565ToColor(0xFFFF))
+ assertEquals(Color(0, 0, 0), rgb565ToColor(0x0000))
+ assertEquals(Color(255, 0, 0), rgb565ToColor(0xF800))
+ assertEquals(Color(0, 255, 0), rgb565ToColor(0x07E0))
+ assertEquals(Color(0, 0, 255), rgb565ToColor(0x001F))
+ // 5-bit 16 replicates to 10000100b = 132, where plain scaling floors to 131
+ assertEquals(132, (rgb565ToColor(16 shl 11).red * 255).toInt())
+ }
+
+ @Test
+ fun `highest-index region wins where regions overlap`() {
+ val under = ResolvedRegion(left = 0, top = 0, right = 100, bottom = 10, on = Color.Red, off = Color.Black)
+ val over = ResolvedRegion(left = 50, top = 0, right = 100, bottom = 10, on = Color.Green, off = Color.Blue)
+ val rows = listOf(under, over)
+
+ assertEquals(
+ Color.Red,
+ resolvePixelColor(x = 10, set = true, rowRegions = rows, defaultOn = Color.White, defaultOff = Color.Black),
+ )
+ assertEquals(
+ Color.Green,
+ resolvePixelColor(x = 60, set = true, rowRegions = rows, defaultOn = Color.White, defaultOff = Color.Black),
+ )
+ assertEquals(
+ Color.Blue,
+ resolvePixelColor(
+ x = 60,
+ set = false,
+ rowRegions = rows,
+ defaultOn = Color.White,
+ defaultOff = Color.Black,
+ ),
+ )
+ }
+
+ @Test
+ fun `pixels outside all regions use the defaults`() {
+ val region = ResolvedRegion(left = 0, top = 0, right = 10, bottom = 10, on = Color.Red, off = Color.Black)
+
+ assertEquals(
+ Color.White,
+ resolvePixelColor(
+ x = 50,
+ set = true,
+ rowRegions = listOf(region),
+ defaultOn = Color.White,
+ defaultOff = Color.Gray,
+ ),
+ )
+ assertEquals(
+ Color.Gray,
+ resolvePixelColor(
+ x = 50,
+ set = false,
+ rowRegions = listOf(region),
+ defaultOn = Color.White,
+ defaultOff = Color.Gray,
+ ),
+ )
+ }
+}
From b92c950232d567a06872890f2950eff02da47b88 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 16:02:29 -0500
Subject: [PATCH 09/34] feat(debug): render MUI dirty-rect streams
(Format.RGB565)
DisplayMirrorManager reassembles RGB565 rect chunks (sequence, geometry,
and panel-bound validation) and composites them into a persistent
little-endian RGB565 canvas emitted per completed rect; the renderer gains
a true-color branch using the same run-length row drawing. Mono frames are
untouched.
---
.../data/manager/DisplayMirrorManagerImpl.kt | 95 +++++++++++++++++++
.../core/repository/DisplayMirrorManager.kt | 18 ++--
.../settings/debugging/MirrorFrameRenderer.kt | 47 ++++++++-
3 files changed, 153 insertions(+), 7 deletions(-)
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index 61be808a117..7a5e4bdbd64 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -21,6 +21,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import org.koin.core.annotation.Single
import org.meshtastic.core.repository.DisplayMirrorManager
+import org.meshtastic.core.repository.MirrorFormat
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.proto.DisplayFrame
@@ -56,6 +57,14 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private var paletteDefaultOff = 0
override fun handleIncomingFrame(chunk: DisplayFrame) {
+ if (chunk.format == DisplayFrame.Format.RGB565 && chunk.rect_width > 0) {
+ handleRectChunk(chunk)
+ } else {
+ handleMonoChunk(chunk)
+ }
+ }
+
+ private fun handleMonoChunk(chunk: DisplayFrame) {
val data = chunk.data_.toByteArray()
val total = chunk.total_size
@@ -164,9 +173,92 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
return acceptable
}
+ // ── RGB565 dirty-rect stream (LVGL/MUI devices) ─────────────────────────
+ // Rects composite into a persistent little-endian RGB565 canvas; frames
+ // are emitted coalesced so a burst of rects costs one canvas copy.
+
+ private var canvas: ByteArray? = null
+ private var canvasWidth = 0
+ private var canvasHeight = 0
+ private var rectBuffer: ByteArray? = null
+ private var rectReceived = 0
+ private var rectFrameId = 0
+
+ private fun handleRectChunk(chunk: DisplayFrame) {
+ val data = chunk.data_.toByteArray()
+ if (chunk.offset == 0) {
+ rectBuffer = ByteArray(chunk.total_size)
+ rectFrameId = chunk.frame_id
+ rectReceived = 0
+ }
+ if (!isAcceptableRectChunk(chunk, data.size)) {
+ rectBuffer = null
+ return
+ }
+ val buf = rectBuffer ?: return
+ data.copyInto(buf, chunk.offset)
+ rectReceived += data.size
+ if (rectReceived == chunk.total_size) {
+ compositeRect(chunk, buf)
+ rectBuffer = null
+ }
+ }
+
+ private fun isAcceptableRectChunk(chunk: DisplayFrame, dataSize: Int): Boolean {
+ val bytes = chunk.rect_width * chunk.rect_height * 2
+ val withinPanel =
+ chunk.width in 1..MAX_PANEL_EDGE &&
+ chunk.height in 1..MAX_PANEL_EDGE &&
+ chunk.rect_x + chunk.rect_width <= chunk.width &&
+ chunk.rect_y + chunk.rect_height <= chunk.height
+ val inSequence = rectBuffer != null && chunk.frame_id == rectFrameId && chunk.offset == rectReceived
+ val acceptable =
+ withinPanel && inSequence && bytes == chunk.total_size && chunk.offset + dataSize <= chunk.total_size
+ if (!acceptable) {
+ Logger.w {
+ "DisplayMirror: dropping bad rect ${chunk.rect_width}x${chunk.rect_height} total=${chunk.total_size}"
+ }
+ }
+ return acceptable
+ }
+
+ private fun compositeRect(chunk: DisplayFrame, rect: ByteArray) {
+ if (canvas == null || canvasWidth != chunk.width || canvasHeight != chunk.height) {
+ canvas = ByteArray(chunk.width * chunk.height * 2)
+ canvasWidth = chunk.width
+ canvasHeight = chunk.height
+ }
+ val target = canvas ?: return
+ val rowBytes = chunk.rect_width * 2
+ for (row in 0 until chunk.rect_height) {
+ val src = row * rowBytes
+ val dst = ((chunk.rect_y + row) * canvasWidth + chunk.rect_x) * 2
+ rect.copyInto(target, dst, src, src + rowBytes)
+ }
+ // One emission per completed rect: rects are already flush-coalesced
+ // device-side, and StateFlow conflates under a slow collector.
+ emitCanvas(chunk.frame_id)
+ }
+
+ private fun emitCanvas(frameId: Int) {
+ val target = canvas ?: return
+ _frame.value =
+ MirrorFrame(
+ width = canvasWidth,
+ height = canvasHeight,
+ frameId = frameId,
+ paletteSignature = 0,
+ pixels = target.copyOf(),
+ format = MirrorFormat.RGB565,
+ )
+ }
+
override fun reset() {
buffer = null
received = 0
+ canvas = null
+ rectBuffer = null
+ rectReceived = 0
paletteRegions = mutableListOf()
paletteReceived = 0
paletteSignature = 0
@@ -181,6 +273,9 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
// The firmware's region table caps at 48; anything past this is a bug or an attack.
const val MAX_PALETTE_REGIONS = 512
+ // Sanity bound for RGB565 panels (largest realistic is 800x480).
+ const val MAX_PANEL_EDGE = 1024
+
// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
const val PIXELS_PER_PAGE = 8
}
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
index 7f075df2935..cdfd971b718 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -58,24 +58,30 @@ data class MirrorPalette(
val regions: List,
)
-/**
- * One complete device framebuffer snapshot.
- *
- * [pixels] is MONO_VLSB: 1 bit per pixel in vertical LSB-first pages — byte index = `x + (y / 8) * width`, bit index =
- * `y % 8`.
- */
+/** Pixel encodings a [MirrorFrame] can carry. */
+enum class MirrorFormat {
+ /** 1 bit per pixel, vertical LSB-first pages — byte index `x + (y / 8) * width`, bit index `y % 8`. */
+ MONO_VLSB,
+
+ /** 16 bits per pixel, little-endian RGB565, rows tightly packed. */
+ RGB565,
+}
+
+/** One complete device framebuffer snapshot in [format]. */
data class MirrorFrame(
val width: Int,
val height: Int,
val frameId: Int,
val paletteSignature: Int,
val pixels: ByteArray,
+ val format: MirrorFormat = MirrorFormat.MONO_VLSB,
) {
override fun equals(other: Any?): Boolean = other is MirrorFrame &&
other.width == width &&
other.height == height &&
other.frameId == frameId &&
other.paletteSignature == paletteSignature &&
+ other.format == format &&
other.pixels.contentEquals(pixels)
override fun hashCode(): Int {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
index 14272d637da..0c69d608f1d 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
@@ -34,6 +34,7 @@ import androidx.compose.ui.unit.Density
import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.dp
import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.repository.MirrorFormat
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.core.resources.Res
@@ -76,6 +77,11 @@ internal class ResolvedRegion(
val off: Color,
)
+/** Reads one little-endian RGB565 value from a packed pixel row. */
+@Suppress("MagicNumber")
+private fun leRgb565At(pixels: ByteArray, index: Int): Int =
+ (pixels[index].toInt() and 0xFF) or ((pixels[index + 1].toInt() and 0xFF) shl 8)
+
/** Expands RGB565 to 8-bit channels by bit replication (the canonical expansion; plain scaling floors). */
@Suppress("MagicNumber")
internal fun rgb565ToColor(v: Int): Color {
@@ -114,7 +120,46 @@ internal fun MirrorPalette.resolveRegions(): List = regions.map
)
}
-private fun renderFrame(frame: MirrorFrame, palette: MirrorPalette?): ImageBitmap {
+private fun renderFrame(frame: MirrorFrame, palette: MirrorPalette?): ImageBitmap = when (frame.format) {
+ MirrorFormat.RGB565 -> renderRgb565Frame(frame)
+ MirrorFormat.MONO_VLSB -> renderMonoFrame(frame, palette)
+}
+
+/** True-color frames (LVGL/MUI devices): little-endian RGB565, drawn as horizontal same-color runs. */
+private fun renderRgb565Frame(frame: MirrorFrame): ImageBitmap {
+ val bitmap = ImageBitmap(frame.width, frame.height)
+ val size = Size(frame.width.toFloat(), frame.height.toFloat())
+ CanvasDrawScope().draw(Density(1f), LayoutDirection.Ltr, Canvas(bitmap), size) {
+ drawRect(color = Color.Black)
+ for (y in 0 until frame.height) {
+ val rowBase = y * frame.width * 2
+ var runStart = 0
+ var runColor: Color? = null
+ fun flush(endExclusive: Int) {
+ val color = runColor
+ if (color != null && color != Color.Black) {
+ drawRect(
+ color = color,
+ topLeft = Offset(runStart.toFloat(), y.toFloat()),
+ size = Size((endExclusive - runStart).toFloat(), 1f),
+ )
+ }
+ }
+ for (x in 0 until frame.width) {
+ val color = rgb565ToColor(leRgb565At(frame.pixels, rowBase + x * 2))
+ if (color != runColor) {
+ flush(x)
+ runStart = x
+ runColor = color
+ }
+ }
+ flush(frame.width)
+ }
+ }
+ return bitmap
+}
+
+private fun renderMonoFrame(frame: MirrorFrame, palette: MirrorPalette?): ImageBitmap {
val defaultOn = palette?.let { rgb565ToColor(it.defaultOnColor) } ?: Color.White
val defaultOff = palette?.let { rgb565ToColor(it.defaultOffColor) } ?: Color.Black
val regions = palette?.resolveRegions().orEmpty()
From c774e474f98feda1cc03bcb251ede442c8c1bff7 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 16:26:15 -0500
Subject: [PATCH 10/34] feat(debug): view-only mirror treatment for MUI devices
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
RGB565 frames identify LVGL/MUI devices, whose UIs read their own input
drivers rather than the InputBroker remote events inject into — so the
mirror hides the D-pad, keyboard, swipe, and touch affordances and says
so, until an input-injection path exists. Utility helpers and the input
codes move to DisplayMirrorUtils.kt.
---
.skills/compose-ui/strings-index.txt | 1 +
.../composeResources/values/strings.xml | 1 +
.../settings/debugging/DisplayMirror.kt | 73 +++++++------------
.../settings/debugging/DisplayMirrorUtils.kt | 67 +++++++++++++++++
4 files changed, 95 insertions(+), 47 deletions(-)
create mode 100644 feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
diff --git a/.skills/compose-ui/strings-index.txt b/.skills/compose-ui/strings-index.txt
index c14d26f9972..8e00682eb3a 100644
--- a/.skills/compose-ui/strings-index.txt
+++ b/.skills/compose-ui/strings-index.txt
@@ -1196,6 +1196,7 @@ mirror_keyboard
mirror_no_frame
mirror_not_connected
mirror_off
+mirror_view_only
modem_preset
module_settings
modules_already_unlocked
diff --git a/core/resources/src/commonMain/composeResources/values/strings.xml b/core/resources/src/commonMain/composeResources/values/strings.xml
index a315669226b..f053696e080 100644
--- a/core/resources/src/commonMain/composeResources/values/strings.xml
+++ b/core/resources/src/commonMain/composeResources/values/strings.xml
@@ -1238,6 +1238,7 @@
No frame received yet — enable mirroring or tap Refresh.
Not connected to a device.
Mirror off
+ Mirror only: remote input is not supported for this device UI yet.
Presets
Module configuration
Modules already unlocked
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index fc57d1a7df4..d5f2a744740 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -55,7 +55,6 @@ import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEventType
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
@@ -67,6 +66,7 @@ import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import org.jetbrains.compose.resources.stringResource
import org.koin.compose.viewmodel.koinViewModel
+import org.meshtastic.core.repository.MirrorFormat
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.core.resources.Res
@@ -81,6 +81,7 @@ import org.meshtastic.core.resources.mirror_keyboard
import org.meshtastic.core.resources.mirror_no_frame
import org.meshtastic.core.resources.mirror_not_connected
import org.meshtastic.core.resources.mirror_off
+import org.meshtastic.core.resources.mirror_view_only
import org.meshtastic.core.resources.refresh
import org.meshtastic.proto.DisplayInfo
@@ -97,17 +98,6 @@ private val SWIPE_THRESHOLD = 48.dp
// Mirror + D-pad fit comfortably side by side above this content width.
private val SIDE_BY_SIDE_MIN_WIDTH = 760.dp
-// Firmware input_broker_event codes (src/input/InputBroker.h). USER_PRESS is
-// what physical touch drivers emit for a tap, with touch coordinates attached.
-internal const val INPUT_SELECT = 10
-internal const val INPUT_SELECT_LONG = 11
-internal const val INPUT_UP = 17
-internal const val INPUT_DOWN = 18
-internal const val INPUT_LEFT = 19
-internal const val INPUT_RIGHT = 20
-internal const val INPUT_BACK = 27
-internal const val INPUT_USER_PRESS = 28
-
/** Live view of the connected device's screen, with remote D-pad, keyboard, and touch control. */
@Composable
fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
@@ -169,6 +159,9 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
currentFrame,
palette,
enabled = connected,
+ // MUI (RGB565) devices read their own input drivers, not the
+ // InputBroker remote events inject into — mirror-only for now.
+ inputSupported = currentFrame.format != MirrorFormat.RGB565,
hasTouch = displayInfo?.has_touch == true,
onEvent = viewModel::sendKey,
onTouch = viewModel::sendTouch,
@@ -184,12 +177,13 @@ private fun MirrorWithControls(
frame: MirrorFrame,
palette: MirrorPalette?,
enabled: Boolean,
+ inputSupported: Boolean,
hasTouch: Boolean,
onEvent: (Int) -> Unit,
onTouch: (Int, Int, Int) -> Unit,
) {
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
- if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH) {
+ if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH && inputSupported) {
Row(
horizontalArrangement = Arrangement.spacedBy(24.dp, Alignment.CenterHorizontally),
verticalAlignment = Alignment.CenterVertically,
@@ -204,13 +198,30 @@ private fun MirrorWithControls(
verticalArrangement = Arrangement.spacedBy(12.dp),
modifier = Modifier.fillMaxWidth(),
) {
- MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
- DpadCluster(enabled = enabled, onEvent = onEvent)
+ if (inputSupported) {
+ MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
+ DpadCluster(enabled = enabled, onEvent = onEvent)
+ } else {
+ ViewOnlyMirror(frame, palette)
+ }
}
}
}
}
+/** Mirror without any input affordances, for device UIs that do not accept remote input yet. */
+@Composable
+private fun ViewOnlyMirror(frame: MirrorFrame, palette: MirrorPalette?, modifier: Modifier = Modifier) {
+ Column(
+ modifier = modifier,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.spacedBy(4.dp),
+ ) {
+ MirrorFrameImage(frame, palette)
+ Text(text = stringResource(Res.string.mirror_view_only), style = MaterialTheme.typography.labelSmall)
+ }
+}
+
/**
* The live mirror plus its direct input affordances: a Keyboard chip toggles key capture (arrows, Enter/Space = OK,
* Esc/Backspace = Back), swiping in a cardinal direction sends one direction event, and on touch-capable devices
@@ -307,34 +318,6 @@ private fun MirrorControlHints(focused: Boolean, hasTouch: Boolean, onToggleKeyb
}
}
-/** Scales a tap position on the scaled-up mirror image back to panel pixel coordinates. */
-private fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
- (x / boxWidthPx * frame.width).toInt().coerceIn(0, frame.width - 1)
-
-private fun Offset.toDeviceY(boxHeightPx: Int, frame: MirrorFrame): Int =
- (y / boxHeightPx * frame.height).toInt().coerceIn(0, frame.height - 1)
-
-private fun keyToInputEvent(key: Key): Int? = when (key) {
- Key.DirectionUp -> INPUT_UP
-
- Key.DirectionDown -> INPUT_DOWN
-
- Key.DirectionLeft -> INPUT_LEFT
-
- Key.DirectionRight -> INPUT_RIGHT
-
- Key.Enter,
- Key.NumPadEnter,
- Key.Spacebar,
- -> INPUT_SELECT
-
- Key.Escape,
- Key.Backspace,
- -> INPUT_BACK
-
- else -> null
-}
-
/** Converts a completed drag into one direction event along its dominant axis, ignoring short accidental swipes. */
private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointerInput(Unit) {
val threshold = SWIPE_THRESHOLD.toPx()
@@ -405,7 +388,3 @@ private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
)
}
}
-
-@Composable
-private fun contentColorFor(enabled: Boolean): Color =
- if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
new file mode 100644
index 00000000000..c23e21b4b60
--- /dev/null
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.key.Key
+import org.meshtastic.core.repository.MirrorFrame
+
+// Firmware input_broker_event codes (src/input/InputBroker.h). USER_PRESS is
+// what physical touch drivers emit for a tap, with touch coordinates attached.
+internal const val INPUT_SELECT = 10
+internal const val INPUT_SELECT_LONG = 11
+internal const val INPUT_UP = 17
+internal const val INPUT_DOWN = 18
+internal const val INPUT_LEFT = 19
+internal const val INPUT_RIGHT = 20
+internal const val INPUT_BACK = 27
+internal const val INPUT_USER_PRESS = 28
+
+/** Scales a tap position on the scaled-up mirror image back to panel pixel coordinates. */
+internal fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
+ (x / boxWidthPx * frame.width).toInt().coerceIn(0, frame.width - 1)
+
+internal fun Offset.toDeviceY(boxHeightPx: Int, frame: MirrorFrame): Int =
+ (y / boxHeightPx * frame.height).toInt().coerceIn(0, frame.height - 1)
+
+internal fun keyToInputEvent(key: Key): Int? = when (key) {
+ Key.DirectionUp -> INPUT_UP
+
+ Key.DirectionDown -> INPUT_DOWN
+
+ Key.DirectionLeft -> INPUT_LEFT
+
+ Key.DirectionRight -> INPUT_RIGHT
+
+ Key.Enter,
+ Key.NumPadEnter,
+ Key.Spacebar,
+ -> INPUT_SELECT
+
+ Key.Escape,
+ Key.Backspace,
+ -> INPUT_BACK
+
+ else -> null
+}
+
+@Composable
+internal fun contentColorFor(enabled: Boolean): Color =
+ if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
From bd2fbd99d0707fc8c57f6e6ac607cb3c2268453e Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 16:37:11 -0500
Subject: [PATCH 11/34] feat(debug): re-enable remote controls for MUI mirrors
device-ui now accepts injected input (virtual LVGL pointer + group-attached
keypad bridged from the InputBroker), so the view-only treatment goes away:
the D-pad navigates MUI widgets, taps forward panel coordinates, and the
keyboard types. The mirror_view_only string stays for the future
capability-flag path.
---
.../settings/debugging/DisplayMirror.kt | 29 ++-----------------
1 file changed, 3 insertions(+), 26 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index d5f2a744740..2cdbcb5a6f3 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -66,7 +66,6 @@ import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import org.jetbrains.compose.resources.stringResource
import org.koin.compose.viewmodel.koinViewModel
-import org.meshtastic.core.repository.MirrorFormat
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.core.resources.Res
@@ -81,7 +80,6 @@ import org.meshtastic.core.resources.mirror_keyboard
import org.meshtastic.core.resources.mirror_no_frame
import org.meshtastic.core.resources.mirror_not_connected
import org.meshtastic.core.resources.mirror_off
-import org.meshtastic.core.resources.mirror_view_only
import org.meshtastic.core.resources.refresh
import org.meshtastic.proto.DisplayInfo
@@ -159,9 +157,6 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
currentFrame,
palette,
enabled = connected,
- // MUI (RGB565) devices read their own input drivers, not the
- // InputBroker remote events inject into — mirror-only for now.
- inputSupported = currentFrame.format != MirrorFormat.RGB565,
hasTouch = displayInfo?.has_touch == true,
onEvent = viewModel::sendKey,
onTouch = viewModel::sendTouch,
@@ -177,13 +172,12 @@ private fun MirrorWithControls(
frame: MirrorFrame,
palette: MirrorPalette?,
enabled: Boolean,
- inputSupported: Boolean,
hasTouch: Boolean,
onEvent: (Int) -> Unit,
onTouch: (Int, Int, Int) -> Unit,
) {
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
- if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH && inputSupported) {
+ if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH) {
Row(
horizontalArrangement = Arrangement.spacedBy(24.dp, Alignment.CenterHorizontally),
verticalAlignment = Alignment.CenterVertically,
@@ -198,30 +192,13 @@ private fun MirrorWithControls(
verticalArrangement = Arrangement.spacedBy(12.dp),
modifier = Modifier.fillMaxWidth(),
) {
- if (inputSupported) {
- MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
- DpadCluster(enabled = enabled, onEvent = onEvent)
- } else {
- ViewOnlyMirror(frame, palette)
- }
+ MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
+ DpadCluster(enabled = enabled, onEvent = onEvent)
}
}
}
}
-/** Mirror without any input affordances, for device UIs that do not accept remote input yet. */
-@Composable
-private fun ViewOnlyMirror(frame: MirrorFrame, palette: MirrorPalette?, modifier: Modifier = Modifier) {
- Column(
- modifier = modifier,
- horizontalAlignment = Alignment.CenterHorizontally,
- verticalArrangement = Arrangement.spacedBy(4.dp),
- ) {
- MirrorFrameImage(frame, palette)
- Text(text = stringResource(Res.string.mirror_view_only), style = MaterialTheme.typography.labelSmall)
- }
-}
-
/**
* The live mirror plus its direct input affordances: a Keyboard chip toggles key capture (arrows, Enter/Space = OK,
* Esc/Backspace = Back), swiping in a cardinal direction sends one direction event, and on touch-capable devices
From f15f4390d58fe1054b5b98f74397f02637183e16 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:58:28 -0500
Subject: [PATCH 12/34] fix(debug): send typed characters to the mirrored
device
The mirror's keyboard capture only mapped navigation keys and silently
dropped everything else, so text entry did nothing: printable characters
never left the client even though the firmware already injects kb_char.
Characters now go out as ANYKEY with the code point, Backspace goes as a
character (so text fields delete rather than navigating back, which stays
Esc's job), and the handling moves into a Modifier.remoteKeyInput
extension.
---
.../settings/debugging/DisplayMirror.kt | 53 ++++++++++++++++---
.../settings/debugging/DisplayMirrorUtils.kt | 14 +++--
.../debugging/DisplayMirrorViewModel.kt | 3 ++
3 files changed, 59 insertions(+), 11 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 2cdbcb5a6f3..be49f3f9383 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -55,10 +55,12 @@ import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEventType
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.key.utf16CodePoint
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalHapticFeedback
@@ -160,6 +162,7 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
hasTouch = displayInfo?.has_touch == true,
onEvent = viewModel::sendKey,
onTouch = viewModel::sendTouch,
+ onChar = viewModel::sendChar,
)
}
}
@@ -175,6 +178,7 @@ private fun MirrorWithControls(
hasTouch: Boolean,
onEvent: (Int) -> Unit,
onTouch: (Int, Int, Int) -> Unit,
+ onChar: (Int) -> Unit,
) {
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
if (maxWidth >= SIDE_BY_SIDE_MIN_WIDTH) {
@@ -183,7 +187,15 @@ private fun MirrorWithControls(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.fillMaxWidth(),
) {
- MirrorSurface(frame, palette, hasTouch, onEvent, onTouch, modifier = Modifier.weight(1f, fill = false))
+ MirrorSurface(
+ frame,
+ palette,
+ hasTouch,
+ onEvent,
+ onTouch,
+ onChar,
+ modifier = Modifier.weight(1f, fill = false),
+ )
DpadCluster(enabled = enabled, onEvent = onEvent)
}
} else {
@@ -192,7 +204,7 @@ private fun MirrorWithControls(
verticalArrangement = Arrangement.spacedBy(12.dp),
modifier = Modifier.fillMaxWidth(),
) {
- MirrorSurface(frame, palette, hasTouch, onEvent, onTouch)
+ MirrorSurface(frame, palette, hasTouch, onEvent, onTouch, onChar)
DpadCluster(enabled = enabled, onEvent = onEvent)
}
}
@@ -212,6 +224,7 @@ private fun MirrorSurface(
hasTouch: Boolean,
onEvent: (Int) -> Unit,
onTouch: (Int, Int, Int) -> Unit,
+ onChar: (Int) -> Unit,
modifier: Modifier = Modifier,
) {
val focusRequester = remember { FocusRequester() }
@@ -232,12 +245,7 @@ private fun MirrorSurface(
Modifier.focusRequester(focusRequester)
.onFocusChanged { focused = it.isFocused }
.focusable()
- .onPreviewKeyEvent { event ->
- val mapped = keyToInputEvent(event.key) ?: return@onPreviewKeyEvent false
- // Consume KeyUp of mapped keys too, or Space/arrows leak to the scroll container.
- if (event.type == KeyEventType.KeyDown) onEvent(mapped)
- true
- }
+ .remoteKeyInput(onEvent, onChar)
.pointerInput(hasTouch) {
detectTapGestures(
onTap = { offset ->
@@ -295,6 +303,35 @@ private fun MirrorControlHints(focused: Boolean, hasTouch: Boolean, onToggleKeyb
}
}
+/**
+ * Sends captured key presses to the device: mapped navigation keys as input events, Backspace and printable characters
+ * as typed characters. Handled keys are consumed on both down and up so nothing leaks into the surrounding scroll
+ * container.
+ */
+private fun Modifier.remoteKeyInput(onEvent: (Int) -> Unit, onChar: (Int) -> Unit): Modifier =
+ onPreviewKeyEvent { event ->
+ val down = event.type == KeyEventType.KeyDown
+ val mapped = keyToInputEvent(event.key)
+ when {
+ mapped != null -> {
+ if (down) onEvent(mapped)
+ true
+ }
+
+ event.key == Key.Backspace -> {
+ if (down) onChar(CHAR_BACKSPACE)
+ true
+ }
+
+ event.utf16CodePoint >= FIRST_PRINTABLE_CHAR -> {
+ if (down) onChar(event.utf16CodePoint)
+ true
+ }
+
+ else -> false
+ }
+ }
+
/** Converts a completed drag into one direction event along its dominant axis, ignoring short accidental swipes. */
private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointerInput(Unit) {
val threshold = SWIPE_THRESHOLD.toPx()
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
index c23e21b4b60..11098aa140a 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -34,6 +34,16 @@ internal const val INPUT_RIGHT = 20
internal const val INPUT_BACK = 27
internal const val INPUT_USER_PRESS = 28
+// ANYKEY carries a character in kb_char rather than a navigation code.
+internal const val INPUT_ANYKEY = 0xFF
+
+// LVGL's backspace key value; typed as a character so text fields delete
+// rather than navigating back (which is what Esc is for).
+internal const val CHAR_BACKSPACE = 8
+
+// Below this, key events are control codes rather than typable text.
+internal const val FIRST_PRINTABLE_CHAR = 32
+
/** Scales a tap position on the scaled-up mirror image back to panel pixel coordinates. */
internal fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
(x / boxWidthPx * frame.width).toInt().coerceIn(0, frame.width - 1)
@@ -55,9 +65,7 @@ internal fun keyToInputEvent(key: Key): Int? = when (key) {
Key.Spacebar,
-> INPUT_SELECT
- Key.Escape,
- Key.Backspace,
- -> INPUT_BACK
+ Key.Escape -> INPUT_BACK
else -> null
}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
index cc1e72c8465..699adc37fd5 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
@@ -83,6 +83,9 @@ class DisplayMirrorViewModel(
fun sendKey(eventCode: Int) = adminController.sendInputEvent(eventCode)
+ /** Forwards a typed character; the device UI receives it as a key press rather than a navigation event. */
+ fun sendChar(codePoint: Int) = adminController.sendInputEvent(INPUT_ANYKEY, kbChar = codePoint)
+
/** Forwards a tap/long-press on the mirrored image as a device touch event with panel coordinates. */
fun sendTouch(eventCode: Int, x: Int, y: Int) = adminController.sendInputEvent(eventCode, touchX = x, touchY = y)
From 33d93cd987f1d9f754625e4d904ae71befab8f8f Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Mon, 31 Aug 2026 19:05:54 -0500
Subject: [PATCH 13/34] refactor(mirror): harden rect reassembly and extract
the compositor
Third adversarial review pass over the client side.
Rect reassembly moves out of DisplayMirrorManagerImpl into
MirrorRectCompositor: the manager was carrying two unrelated state
machines and 14 methods. Every rect field is now validated before
anything is allocated (total_size is device-controlled), geometry is
latched from the chunk at offset 0 so a later chunk cannot transpose
the blit, continuations must match the buffer that was actually
allocated rather than their own claim, and bounds use the subtraction
form because rect_x + rect_width overflows for hostile values. A rect
that omits width or height covers the full panel in that axis.
remoteKeyInput no longer swallows modified keys, so Cmd+Q, Ctrl+C and
Alt+Tab stay with the desktop instead of being forwarded to the device.
MirrorFrameRenderer tracks colorized runs as a raw Int with a sentinel
rather than a boxed Color?, and MirrorFrame.hashCode includes the
format so a mono and an RGB565 frame of the same size cannot collide.
Drops mirror_view_only, orphaned since MUI gained remote input.
---
.skills/compose-ui/strings-index.txt | 1 -
.../data/manager/DisplayMirrorManagerImpl.kt | 92 ++----------
.../core/data/manager/MirrorRectCompositor.kt | 140 ++++++++++++++++++
.../manager/DisplayMirrorManagerImplTest.kt | 77 ++++++++++
.../core/repository/DisplayMirrorManager.kt | 1 +
.../composeResources/values/strings.xml | 1 -
.../settings/debugging/DisplayMirror.kt | 8 +-
.../settings/debugging/DisplayMirrorUtils.kt | 2 +-
.../settings/debugging/MirrorFrameRenderer.kt | 23 +--
9 files changed, 251 insertions(+), 94 deletions(-)
create mode 100644 core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/MirrorRectCompositor.kt
diff --git a/.skills/compose-ui/strings-index.txt b/.skills/compose-ui/strings-index.txt
index 8e00682eb3a..c14d26f9972 100644
--- a/.skills/compose-ui/strings-index.txt
+++ b/.skills/compose-ui/strings-index.txt
@@ -1196,7 +1196,6 @@ mirror_keyboard
mirror_no_frame
mirror_not_connected
mirror_off
-mirror_view_only
modem_preset
module_settings
modules_already_unlocked
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index 7a5e4bdbd64..2c6d29cdf97 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -50,6 +50,8 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private var frameWidth = 0
private var frameHeight = 0
+ private val rects = MirrorRectCompositor()
+
private var paletteRegions = mutableListOf()
private var paletteSignature = 0
private var paletteReceived = 0
@@ -57,8 +59,8 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private var paletteDefaultOff = 0
override fun handleIncomingFrame(chunk: DisplayFrame) {
- if (chunk.format == DisplayFrame.Format.RGB565 && chunk.rect_width > 0) {
- handleRectChunk(chunk)
+ if (chunk.format == DisplayFrame.Format.RGB565) {
+ if (rects.handle(chunk)) emitRectFrame(chunk)
} else {
handleMonoChunk(chunk)
}
@@ -173,82 +175,15 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
return acceptable
}
- // ── RGB565 dirty-rect stream (LVGL/MUI devices) ─────────────────────────
- // Rects composite into a persistent little-endian RGB565 canvas; frames
- // are emitted coalesced so a burst of rects costs one canvas copy.
-
- private var canvas: ByteArray? = null
- private var canvasWidth = 0
- private var canvasHeight = 0
- private var rectBuffer: ByteArray? = null
- private var rectReceived = 0
- private var rectFrameId = 0
-
- private fun handleRectChunk(chunk: DisplayFrame) {
- val data = chunk.data_.toByteArray()
- if (chunk.offset == 0) {
- rectBuffer = ByteArray(chunk.total_size)
- rectFrameId = chunk.frame_id
- rectReceived = 0
- }
- if (!isAcceptableRectChunk(chunk, data.size)) {
- rectBuffer = null
- return
- }
- val buf = rectBuffer ?: return
- data.copyInto(buf, chunk.offset)
- rectReceived += data.size
- if (rectReceived == chunk.total_size) {
- compositeRect(chunk, buf)
- rectBuffer = null
- }
- }
-
- private fun isAcceptableRectChunk(chunk: DisplayFrame, dataSize: Int): Boolean {
- val bytes = chunk.rect_width * chunk.rect_height * 2
- val withinPanel =
- chunk.width in 1..MAX_PANEL_EDGE &&
- chunk.height in 1..MAX_PANEL_EDGE &&
- chunk.rect_x + chunk.rect_width <= chunk.width &&
- chunk.rect_y + chunk.rect_height <= chunk.height
- val inSequence = rectBuffer != null && chunk.frame_id == rectFrameId && chunk.offset == rectReceived
- val acceptable =
- withinPanel && inSequence && bytes == chunk.total_size && chunk.offset + dataSize <= chunk.total_size
- if (!acceptable) {
- Logger.w {
- "DisplayMirror: dropping bad rect ${chunk.rect_width}x${chunk.rect_height} total=${chunk.total_size}"
- }
- }
- return acceptable
- }
-
- private fun compositeRect(chunk: DisplayFrame, rect: ByteArray) {
- if (canvas == null || canvasWidth != chunk.width || canvasHeight != chunk.height) {
- canvas = ByteArray(chunk.width * chunk.height * 2)
- canvasWidth = chunk.width
- canvasHeight = chunk.height
- }
- val target = canvas ?: return
- val rowBytes = chunk.rect_width * 2
- for (row in 0 until chunk.rect_height) {
- val src = row * rowBytes
- val dst = ((chunk.rect_y + row) * canvasWidth + chunk.rect_x) * 2
- rect.copyInto(target, dst, src, src + rowBytes)
- }
- // One emission per completed rect: rects are already flush-coalesced
- // device-side, and StateFlow conflates under a slow collector.
- emitCanvas(chunk.frame_id)
- }
-
- private fun emitCanvas(frameId: Int) {
- val target = canvas ?: return
+ private fun emitRectFrame(chunk: DisplayFrame) {
+ val pixels = rects.snapshot() ?: return
_frame.value =
MirrorFrame(
- width = canvasWidth,
- height = canvasHeight,
- frameId = frameId,
+ width = rects.width,
+ height = rects.height,
+ frameId = chunk.frame_id,
paletteSignature = 0,
- pixels = target.copyOf(),
+ pixels = pixels,
format = MirrorFormat.RGB565,
)
}
@@ -256,9 +191,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
override fun reset() {
buffer = null
received = 0
- canvas = null
- rectBuffer = null
- rectReceived = 0
+ rects.reset()
paletteRegions = mutableListOf()
paletteReceived = 0
paletteSignature = 0
@@ -273,9 +206,6 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
// The firmware's region table caps at 48; anything past this is a bug or an attack.
const val MAX_PALETTE_REGIONS = 512
- // Sanity bound for RGB565 panels (largest realistic is 800x480).
- const val MAX_PANEL_EDGE = 1024
-
// MONO_VLSB packs 8 vertically adjacent pixels per byte (one "page" row).
const val PIXELS_PER_PAGE = 8
}
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/MirrorRectCompositor.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/MirrorRectCompositor.kt
new file mode 100644
index 00000000000..af3d9f77e0f
--- /dev/null
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/MirrorRectCompositor.kt
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.data.manager
+
+import co.touchlab.kermit.Logger
+import org.meshtastic.proto.DisplayFrame
+
+private data class RectArea(val x: Int, val y: Int, val width: Int, val height: Int)
+
+/**
+ * Reassembles RGB565 dirty-rect chunks (LVGL-based device UIs) and composites them into a persistent little-endian
+ * RGB565 canvas. Rect geometry is latched from the chunk at offset 0 so a later chunk cannot transpose the blit, and
+ * every field is validated before anything is allocated — `total_size` is device-controlled.
+ */
+internal class MirrorRectCompositor {
+
+ var width = 0
+ private set
+
+ var height = 0
+ private set
+
+ private var canvas: ByteArray? = null
+ private var buffer: ByteArray? = null
+ private var received = 0
+ private var frameId = 0
+ private var area: RectArea? = null
+
+ /** Feeds one chunk; returns true when it completed a rect and the canvas changed. */
+ fun handle(chunk: DisplayFrame): Boolean {
+ val data = chunk.data_.toByteArray()
+ if (!isAcceptable(chunk, data.size)) {
+ buffer = null
+ return false
+ }
+ if (chunk.offset == 0) {
+ buffer = ByteArray(chunk.total_size)
+ frameId = chunk.frame_id
+ received = 0
+ area = RectArea(chunk.rect_x, chunk.rect_y, rectWidth(chunk), rectHeight(chunk))
+ }
+ return accumulate(chunk, data)
+ }
+
+ private fun accumulate(chunk: DisplayFrame, data: ByteArray): Boolean {
+ val buf = buffer ?: return false
+ data.copyInto(buf, chunk.offset)
+ received += data.size
+ val complete = received >= buf.size
+ if (complete) {
+ composite(chunk, buf)
+ buffer = null
+ }
+ return complete
+ }
+
+ /** Snapshot of the composited canvas, or null before the first completed rect. */
+ fun snapshot(): ByteArray? = canvas?.copyOf()
+
+ fun reset() {
+ canvas = null
+ buffer = null
+ received = 0
+ frameId = 0
+ width = 0
+ height = 0
+ area = null
+ }
+
+ /** A rect that omits width or height covers the full panel in that axis. */
+ private fun rectWidth(chunk: DisplayFrame) = if (chunk.rect_width > 0) chunk.rect_width else chunk.width
+
+ private fun rectHeight(chunk: DisplayFrame) = if (chunk.rect_height > 0) chunk.rect_height else chunk.height
+
+ private fun isAcceptable(chunk: DisplayFrame, dataSize: Int): Boolean {
+ val expected = if (withinPanel(chunk)) rectWidth(chunk) * rectHeight(chunk) * 2 else -1
+ val sized = expected == chunk.total_size && chunk.total_size in 1..MAX_RECT_BYTES
+ // Continuations must match the buffer allocated at offset 0, not merely their own claim.
+ val inSequence =
+ chunk.offset == 0 ||
+ (buffer?.size == chunk.total_size && chunk.frame_id == frameId && chunk.offset == received)
+ val acceptable = sized && inSequence && chunk.offset + dataSize <= chunk.total_size
+ if (!acceptable) {
+ Logger.w {
+ "DisplayMirror: dropping bad rect ${chunk.rect_width}x${chunk.rect_height} total=${chunk.total_size}"
+ }
+ }
+ return acceptable
+ }
+
+ /** Subtraction form throughout: `rect_x + rect_width` overflows for hostile values. */
+ private fun withinPanel(chunk: DisplayFrame): Boolean {
+ val w = rectWidth(chunk)
+ val h = rectHeight(chunk)
+ return chunk.width in 1..MAX_PANEL_EDGE &&
+ chunk.height in 1..MAX_PANEL_EDGE &&
+ w in 1..chunk.width &&
+ h in 1..chunk.height &&
+ chunk.rect_x in 0..(chunk.width - w) &&
+ chunk.rect_y in 0..(chunk.height - h)
+ }
+
+ private fun composite(chunk: DisplayFrame, rect: ByteArray) {
+ if (canvas == null || width != chunk.width || height != chunk.height) {
+ canvas = ByteArray(chunk.width * chunk.height * 2)
+ width = chunk.width
+ height = chunk.height
+ }
+ val target = canvas ?: return
+ val blit = area ?: return
+ val rowBytes = blit.width * 2
+ for (row in 0 until blit.height) {
+ val src = row * rowBytes
+ val dst = ((blit.y + row) * width + blit.x) * 2
+ rect.copyInto(target, dst, src, src + rowBytes)
+ }
+ }
+
+ private companion object {
+ // Sanity bound for RGB565 panels (largest realistic is 800x480).
+ const val MAX_PANEL_EDGE = 1024
+
+ // A single rect can at most cover the largest panel we accept.
+ const val MAX_RECT_BYTES = MAX_PANEL_EDGE * MAX_PANEL_EDGE * 2
+ }
+}
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
index 652b89a4424..cf01109776e 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -17,6 +17,7 @@
package org.meshtastic.core.data.manager
import okio.ByteString.Companion.toByteString
+import org.meshtastic.core.repository.MirrorFormat
import org.meshtastic.proto.DisplayFrame
import org.meshtastic.proto.DisplayPalette
import kotlin.test.Test
@@ -204,6 +205,82 @@ class DisplayMirrorManagerImplTest {
assertNull(manager.frame.value)
}
+ // ── RGB565 dirty-rect path ──────────────────────────────────────────────
+
+ private fun rectChunk(
+ frameId: Int = 1,
+ offset: Int = 0,
+ data: ByteArray,
+ total: Int = 200,
+ width: Int = WIDTH,
+ height: Int = HEIGHT,
+ rectX: Int = 0,
+ rectY: Int = 0,
+ rectW: Int = 10,
+ rectH: Int = 10,
+ ) = DisplayFrame(
+ width = width,
+ height = height,
+ format = DisplayFrame.Format.RGB565,
+ frame_id = frameId,
+ offset = offset,
+ total_size = total,
+ rect_x = rectX,
+ rect_y = rectY,
+ rect_width = rectW,
+ rect_height = rectH,
+ data_ = data.toByteString(),
+ )
+
+ @Test
+ fun `composites a completed rect into an RGB565 frame`() {
+ manager.handleIncomingFrame(rectChunk(data = bytes(200, 0x11)))
+
+ val frame = manager.frame.value!!
+ assertEquals(MirrorFormat.RGB565, frame.format)
+ assertEquals(WIDTH * HEIGHT * 2, frame.pixels.size)
+ }
+
+ @Test
+ fun `rejects a rect whose total size does not match its geometry`() {
+ manager.handleIncomingFrame(rectChunk(total = 999, data = bytes(200, 1)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects a rect that would overflow the panel`() {
+ manager.handleIncomingFrame(rectChunk(rectX = WIDTH - 2, data = bytes(200, 1)))
+ manager.handleIncomingFrame(rectChunk(rectY = Int.MAX_VALUE, data = bytes(200, 1)))
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `rejects an oversized rect without allocating`() {
+ manager.handleIncomingFrame(
+ rectChunk(
+ width = 4000,
+ height = 4000,
+ rectW = 4000,
+ rectH = 4000,
+ total = Int.MAX_VALUE,
+ data = bytes(8, 1),
+ ),
+ )
+
+ assertNull(manager.frame.value)
+ }
+
+ @Test
+ fun `continuation chunk cannot grow the rect buffer`() {
+ manager.handleIncomingFrame(rectChunk(offset = 0, total = 200, data = bytes(100, 1)))
+ // Same geometry claim, larger total: must not write past the allocation.
+ manager.handleIncomingFrame(rectChunk(offset = 100, total = 800, rectW = 20, rectH = 20, data = bytes(100, 2)))
+
+ assertNull(manager.frame.value)
+ }
+
private companion object {
const val WIDTH = 128
const val HEIGHT = 64
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
index cdfd971b718..ba9bb59bb10 100644
--- a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DisplayMirrorManager.kt
@@ -89,6 +89,7 @@ data class MirrorFrame(
result = 31 * result + height
result = 31 * result + frameId
result = 31 * result + paletteSignature
+ result = 31 * result + format.ordinal
result = 31 * result + pixels.contentHashCode()
return result
}
diff --git a/core/resources/src/commonMain/composeResources/values/strings.xml b/core/resources/src/commonMain/composeResources/values/strings.xml
index f053696e080..a315669226b 100644
--- a/core/resources/src/commonMain/composeResources/values/strings.xml
+++ b/core/resources/src/commonMain/composeResources/values/strings.xml
@@ -1238,7 +1238,6 @@
No frame received yet — enable mirroring or tap Refresh.
Not connected to a device.
Mirror off
- Mirror only: remote input is not supported for this device UI yet.
Presets
Module configuration
Modules already unlocked
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index be49f3f9383..42b3f949388 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -57,6 +57,9 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.hapticfeedback.HapticFeedbackType
import androidx.compose.ui.input.key.Key
import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.isAltPressed
+import androidx.compose.ui.input.key.isCtrlPressed
+import androidx.compose.ui.input.key.isMetaPressed
import androidx.compose.ui.input.key.key
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.input.key.type
@@ -310,6 +313,9 @@ private fun MirrorControlHints(focused: Boolean, hasTouch: Boolean, onToggleKeyb
*/
private fun Modifier.remoteKeyInput(onEvent: (Int) -> Unit, onChar: (Int) -> Unit): Modifier =
onPreviewKeyEvent { event ->
+ // Never swallow host shortcuts (Cmd+Q, Ctrl+C, Alt+Tab): those belong to
+ // the desktop, not the mirrored device.
+ if (event.isCtrlPressed || event.isMetaPressed || event.isAltPressed) return@onPreviewKeyEvent false
val down = event.type == KeyEventType.KeyDown
val mapped = keyToInputEvent(event.key)
when {
@@ -398,7 +404,7 @@ private fun BackKey(enabled: Boolean, onBack: () -> Unit) {
Text(
text = stringResource(Res.string.mirror_back),
style = MaterialTheme.typography.labelMedium,
- color = contentColorFor(enabled),
+ color = dpadContentColor(enabled),
)
}
}
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
index 11098aa140a..1616dd83a66 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -71,5 +71,5 @@ internal fun keyToInputEvent(key: Key): Int? = when (key) {
}
@Composable
-internal fun contentColorFor(enabled: Boolean): Color =
+internal fun dpadContentColor(enabled: Boolean): Color =
if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
index 0c69d608f1d..4260ebec363 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/MirrorFrameRenderer.kt
@@ -47,8 +47,9 @@ private val MAX_CANVAS_WIDTH = 512.dp
private const val PIXELS_PER_PAGE = 8
/**
- * Renders a MONO_VLSB 1bpp framebuffer once per frame into a 1:1 [ImageBitmap] and scales it up with nearest-neighbor
- * filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per recomposition.
+ * Renders a device frame — 1bpp MONO_VLSB or RGB565 — once per frame into a 1:1 [ImageBitmap] and scales it up with
+ * nearest-neighbor filtering — crisp device pixels, no fractional-scale seams, one pixel walk per frame instead of per
+ * recomposition.
*/
@Composable
internal fun MirrorFrameImage(frame: MirrorFrame, palette: MirrorPalette?, modifier: Modifier = Modifier) {
@@ -77,6 +78,9 @@ internal class ResolvedRegion(
val off: Color,
)
+// Sentinel for "no run started"; 0 is black, which is the skipped background.
+private const val NO_RUN = -1
+
/** Reads one little-endian RGB565 value from a packed pixel row. */
@Suppress("MagicNumber")
private fun leRgb565At(pixels: ByteArray, index: Int): Int =
@@ -134,23 +138,24 @@ private fun renderRgb565Frame(frame: MirrorFrame): ImageBitmap {
for (y in 0 until frame.height) {
val rowBase = y * frame.width * 2
var runStart = 0
- var runColor: Color? = null
+ // Track the raw RGB565 value: Color is a value class, so a nullable
+ // one would box on every pixel comparison.
+ var runValue = NO_RUN
fun flush(endExclusive: Int) {
- val color = runColor
- if (color != null && color != Color.Black) {
+ if (runValue > 0) {
drawRect(
- color = color,
+ color = rgb565ToColor(runValue),
topLeft = Offset(runStart.toFloat(), y.toFloat()),
size = Size((endExclusive - runStart).toFloat(), 1f),
)
}
}
for (x in 0 until frame.width) {
- val color = rgb565ToColor(leRgb565At(frame.pixels, rowBase + x * 2))
- if (color != runColor) {
+ val value = leRgb565At(frame.pixels, rowBase + x * 2)
+ if (value != runValue) {
flush(x)
runStart = x
- runColor = color
+ runValue = value
}
}
flush(frame.width)
From a84ec27d9e0d0d2ce64711ce4ebd109f5e7e3696 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Tue, 8 Sep 2026 17:42:34 -0500
Subject: [PATCH 14/34] fix(mirror): honour managed mode on the Debug Panel
route
The Debug Panel is the one Settings route deliberately exempt from the
`connected && !isManaged` gate every sibling carries, justified by a comment
saying it "reads app-local logs only". The Mirror tab put an admin write
(set_display_mirror) and arbitrary input injection on that route, so managed
mode - which exists to lock a device out of configuration - was bypassed
entirely.
Enforced in the ViewModel, because the route will not do it: arming,
one-shot frame requests, key, character and touch sends are all refused while
managed. Disarming still goes through, so a stream already running is torn
down when managed mode arrives mid-session.
The UI gates on `active = connected && !managed` rather than offering controls
that silently do nothing, and the RadioConfig comment now says what the route
actually guarantees, since its old wording is what let this through.
MirrorHeaderRow is split out of DisplayMirrorContent, which was at detekt's
LongMethod limit and could not absorb another line.
---
.../settings/debugging/DisplayMirror.kt | 59 +++++++++++--------
.../debugging/DisplayMirrorViewModel.kt | 36 +++++++++--
.../feature/settings/radio/RadioConfig.kt | 4 +-
3 files changed, 69 insertions(+), 30 deletions(-)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 42b3f949388..322fa8639a5 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -101,6 +101,31 @@ private val SWIPE_THRESHOLD = 48.dp
// Mirror + D-pad fit comfortably side by side above this content width.
private val SIDE_BY_SIDE_MIN_WIDTH = 760.dp
+/** Toggle, one-shot refresh, and the live frame's geometry. Split out to keep [DisplayMirrorContent] readable. */
+@Composable
+private fun MirrorHeaderRow(
+ mirroring: Boolean,
+ active: Boolean,
+ frame: MirrorFrame?,
+ onToggle: (Boolean) -> Unit,
+ onRefresh: () -> Unit,
+) {
+ Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ Switch(checked = mirroring, onCheckedChange = onToggle, enabled = active)
+ Text(
+ text = stringResource(if (mirroring) Res.string.mirror_active else Res.string.mirror_off),
+ style = MaterialTheme.typography.titleMedium,
+ )
+ OutlinedButton(onClick = onRefresh, enabled = active) { Text(stringResource(Res.string.refresh)) }
+ if (frame != null) {
+ Text(
+ text = stringResource(Res.string.mirror_frame_info, frame.width, frame.height, frame.frameId),
+ style = MaterialTheme.typography.labelSmall,
+ )
+ }
+ }
+}
+
/** Live view of the connected device's screen, with remote D-pad, keyboard, and touch control. */
@Composable
fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirrorViewModel = koinViewModel()) {
@@ -109,6 +134,7 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
val mirroring by viewModel.mirroring.collectAsStateWithLifecycle()
val connected by viewModel.connected.collectAsStateWithLifecycle()
val displayInfo by viewModel.displayInfo.collectAsStateWithLifecycle()
+ val active = connected && !viewModel.managed.collectAsStateWithLifecycle().value
// Don't leave the device streaming to a hidden tab or abandoned screen.
DisposableEffect(Unit) { onDispose { viewModel.stopMirroring() } }
@@ -119,28 +145,13 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
val currentFrame = frame
- Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- Switch(checked = mirroring, onCheckedChange = viewModel::setMirror, enabled = connected)
- Text(
- text = stringResource(if (mirroring) Res.string.mirror_active else Res.string.mirror_off),
- style = MaterialTheme.typography.titleMedium,
- )
- OutlinedButton(onClick = viewModel::requestFrame, enabled = connected) {
- Text(stringResource(Res.string.refresh))
- }
- if (currentFrame != null) {
- Text(
- text =
- stringResource(
- Res.string.mirror_frame_info,
- currentFrame.width,
- currentFrame.height,
- currentFrame.frameId,
- ),
- style = MaterialTheme.typography.labelSmall,
- )
- }
- }
+ MirrorHeaderRow(
+ mirroring = mirroring,
+ active = active,
+ frame = currentFrame,
+ onToggle = viewModel::setMirror,
+ onRefresh = viewModel::requestFrame,
+ )
if (displayInfo?.panel_class == DisplayInfo.PanelClass.EINK) {
Text(text = stringResource(Res.string.mirror_eink_hint), style = MaterialTheme.typography.labelSmall)
@@ -154,14 +165,14 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
currentFrame == null -> {
Text(text = stringResource(Res.string.mirror_no_frame))
- DpadCluster(enabled = connected, onEvent = viewModel::sendKey)
+ DpadCluster(enabled = active, onEvent = viewModel::sendKey)
}
else ->
MirrorWithControls(
currentFrame,
palette,
- enabled = connected,
+ enabled = active,
hasTouch = displayInfo?.has_touch == true,
onEvent = viewModel::sendKey,
onTouch = viewModel::sendTouch,
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
index 699adc37fd5..b3ae14090b6 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorViewModel.kt
@@ -33,6 +33,7 @@ import org.meshtastic.core.repository.DisplayMirrorManager
import org.meshtastic.core.repository.MirrorFrame
import org.meshtastic.core.repository.MirrorPalette
import org.meshtastic.core.repository.NodeRepository
+import org.meshtastic.core.repository.RadioConfigRepository
import org.meshtastic.proto.DisplayInfo
@KoinViewModel
@@ -41,6 +42,7 @@ class DisplayMirrorViewModel(
connectionStateProvider: ConnectionStateProvider,
nodeRepository: NodeRepository,
private val adminController: AdminController,
+ radioConfigRepository: RadioConfigRepository,
) : ViewModel() {
val frame: StateFlow = displayMirrorManager.frame
@@ -56,6 +58,16 @@ class DisplayMirrorViewModel(
val displayInfo: StateFlow =
nodeRepository.ourNodeInfo.map { it?.metadata?.display }.stateIn(viewModelScope, SharingStarted.Eagerly, null)
+ /**
+ * Managed mode locks the device out of configuration, and the mirror is not a read-only view: arming it is an admin
+ * write and the controls inject input. The Debug Panel route it lives on is deliberately exempt from the gate every
+ * other settings route carries, so the restriction has to be enforced here.
+ */
+ val managed: StateFlow =
+ radioConfigRepository.localConfigFlow
+ .map { it.security?.is_managed == true }
+ .stateIn(viewModelScope, SharingStarted.Eagerly, false)
+
private val _mirroring = MutableStateFlow(false)
val mirroring: StateFlow = _mirroring.asStateFlow()
@@ -72,22 +84,38 @@ class DisplayMirrorViewModel(
}
}
}
+ // Managed mode can arrive mid-session with a stream already live; tear it down when it does.
+ viewModelScope.launch { managed.collect { if (it && _mirroring.value) setMirror(false) } }
}
fun setMirror(enabled: Boolean) {
+ // Disarming is always allowed - it is how a live stream is torn down when managed mode arrives.
+ if (enabled && managed.value) return
adminController.setDisplayMirror(enabled)
_mirroring.value = enabled
}
- fun requestFrame() = adminController.requestDisplayFrame()
+ fun requestFrame() {
+ if (managed.value) return
+ adminController.requestDisplayFrame()
+ }
- fun sendKey(eventCode: Int) = adminController.sendInputEvent(eventCode)
+ fun sendKey(eventCode: Int) {
+ if (managed.value) return
+ adminController.sendInputEvent(eventCode)
+ }
/** Forwards a typed character; the device UI receives it as a key press rather than a navigation event. */
- fun sendChar(codePoint: Int) = adminController.sendInputEvent(INPUT_ANYKEY, kbChar = codePoint)
+ fun sendChar(codePoint: Int) {
+ if (managed.value) return
+ adminController.sendInputEvent(INPUT_ANYKEY, kbChar = codePoint)
+ }
/** Forwards a tap/long-press on the mirrored image as a device touch event with panel coordinates. */
- fun sendTouch(eventCode: Int, x: Int, y: Int) = adminController.sendInputEvent(eventCode, touchX = x, touchY = y)
+ fun sendTouch(eventCode: Int, x: Int, y: Int) {
+ if (managed.value) return
+ adminController.sendInputEvent(eventCode, touchX = x, touchY = y)
+ }
/** Stops a live stream when the mirror UI goes away; safe to call redundantly. */
fun stopMirroring() {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/radio/RadioConfig.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/radio/RadioConfig.kt
index b0036a16917..6550f061be6 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/radio/RadioConfig.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/radio/RadioConfig.kt
@@ -274,8 +274,8 @@ private fun AdvancedSection(isManaged: Boolean, isOtaCapable: Boolean, enabled:
onClick = { onNavigate(DiscoveryRoute.DiscoveryGraph) },
)
- // Always enabled: the Debug Panel reads app-local logs only — no radio connection,
- // pending config response, or managed-mode restriction applies to it.
+ // Always enabled so logs stay reachable with no radio attached. Anything on this route that
+ // is NOT read-only must gate itself: it does not inherit `enabled` (see DisplayMirrorViewModel).
ListItem(
text = stringResource(Res.string.debug_panel),
leadingIcon = MeshtasticIcons.BugReport,
From 484a5cc61378203a4213138170e23fec09345344 Mon Sep 17 00:00:00 2001
From: James Rich
Date: Sat, 19 Sep 2026 17:03:00 -0500
Subject: [PATCH 15/34] fix(mirror): follow main after merge
---
.../manager/DisplayMirrorManagerImplTest.kt | 119 ++++++++++++------
.../core/service/AdminControllerImpl.kt | 27 ++--
2 files changed, 96 insertions(+), 50 deletions(-)
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
index cf01109776e..3ed9bdc1dc1 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -38,18 +38,30 @@ class DisplayMirrorManagerImplTest {
width: Int = WIDTH,
height: Int = HEIGHT,
format: DisplayFrame.Format = DisplayFrame.Format.MONO_VLSB,
- ) = DisplayFrame(
- width = width,
- height = height,
- format = format,
- frame_id = frameId,
- offset = offset,
- total_size = total,
- data_ = data.toByteString(),
- )
+ ) = DisplayFrame.Builder()
+ .also { wb ->
+ wb.width = width
+ wb.height = height
+ wb.format = format
+ wb.frame_id = frameId
+ wb.offset = offset
+ wb.total_size = total
+ wb.data_ = data.toByteString()
+ }
+ .build()
private fun bytes(size: Int, fill: Int) = ByteArray(size) { fill.toByte() }
+ private fun palette(signature: Int, regionOffset: Int, regionTotal: Int, regions: List) =
+ DisplayPalette.Builder()
+ .also { wb ->
+ wb.signature = signature
+ wb.region_offset = regionOffset
+ wb.region_total = regionTotal
+ wb.regions = regions
+ }
+ .build()
+
@Test
fun `reassembles a three-chunk frame in order`() {
manager.handleIncomingFrame(chunk(offset = 0, data = bytes(384, 1)))
@@ -131,21 +143,32 @@ class DisplayMirrorManagerImplTest {
@Test
fun `reassembles a two-chunk palette and tags frames with its signature`() {
val region =
- DisplayPalette.ColorRegion(x = 0, y = 0, width = 128, height = 16, on_color = 0xF800, off_color = 0)
+ DisplayPalette.ColorRegion.Builder()
+ .also { wb ->
+ wb.x = 0
+ wb.y = 0
+ wb.width = 128
+ wb.height = 16
+ wb.on_color = 0xF800
+ wb.off_color = 0
+ }
+ .build()
manager.handleIncomingPalette(
- DisplayPalette(
- signature = 42,
- default_on_color = 0xFFFF,
- default_off_color = 0,
- region_offset = 0,
- region_total = 3,
- regions = listOf(region, region),
- ),
+ DisplayPalette.Builder()
+ .also { wb ->
+ wb.signature = 42
+ wb.default_on_color = 0xFFFF
+ wb.default_off_color = 0
+ wb.region_offset = 0
+ wb.region_total = 3
+ wb.regions = listOf(region, region)
+ }
+ .build(),
)
assertNull(manager.palette.value)
manager.handleIncomingPalette(
- DisplayPalette(signature = 42, region_offset = 2, region_total = 3, regions = listOf(region)),
+ palette(signature = 42, regionOffset = 2, regionTotal = 3, regions = listOf(region)),
)
val palette = manager.palette.value!!
@@ -156,18 +179,26 @@ class DisplayMirrorManagerImplTest {
@Test
fun `out-of-sequence palette chunk is dropped until a restart`() {
- val region = DisplayPalette.ColorRegion(x = 0, y = 0, width = 8, height = 8)
+ val region =
+ DisplayPalette.ColorRegion.Builder()
+ .also { wb ->
+ wb.x = 0
+ wb.y = 0
+ wb.width = 8
+ wb.height = 8
+ }
+ .build()
manager.handleIncomingPalette(
- DisplayPalette(signature = 7, region_offset = 0, region_total = 2, regions = listOf(region)),
+ palette(signature = 7, regionOffset = 0, regionTotal = 2, regions = listOf(region)),
)
manager.handleIncomingPalette(
- DisplayPalette(signature = 7, region_offset = 5, region_total = 2, regions = listOf(region)),
+ palette(signature = 7, regionOffset = 5, regionTotal = 2, regions = listOf(region)),
)
assertNull(manager.palette.value)
// A fresh offset-0 chunk recovers
manager.handleIncomingPalette(
- DisplayPalette(signature = 8, region_offset = 0, region_total = 1, regions = listOf(region)),
+ palette(signature = 8, regionOffset = 0, regionTotal = 1, regions = listOf(region)),
)
assertEquals(8, manager.palette.value?.signature)
}
@@ -176,7 +207,7 @@ class DisplayMirrorManagerImplTest {
fun `reset clears frames palettes and partial state`() {
manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
manager.handleIncomingPalette(
- DisplayPalette(signature = 9, region_offset = 0, region_total = 0, regions = emptyList()),
+ palette(signature = 9, regionOffset = 0, regionTotal = 0, regions = emptyList()),
)
manager.reset()
@@ -187,9 +218,17 @@ class DisplayMirrorManagerImplTest {
@Test
fun `rejects palettes past the region cap`() {
- val region = DisplayPalette.ColorRegion(x = 0, y = 0, width = 8, height = 8)
+ val region =
+ DisplayPalette.ColorRegion.Builder()
+ .also { wb ->
+ wb.x = 0
+ wb.y = 0
+ wb.width = 8
+ wb.height = 8
+ }
+ .build()
manager.handleIncomingPalette(
- DisplayPalette(signature = 3, region_offset = 0, region_total = 100_000, regions = listOf(region)),
+ palette(signature = 3, regionOffset = 0, regionTotal = 100_000, regions = listOf(region)),
)
assertNull(manager.palette.value)
@@ -218,19 +257,21 @@ class DisplayMirrorManagerImplTest {
rectY: Int = 0,
rectW: Int = 10,
rectH: Int = 10,
- ) = DisplayFrame(
- width = width,
- height = height,
- format = DisplayFrame.Format.RGB565,
- frame_id = frameId,
- offset = offset,
- total_size = total,
- rect_x = rectX,
- rect_y = rectY,
- rect_width = rectW,
- rect_height = rectH,
- data_ = data.toByteString(),
- )
+ ) = DisplayFrame.Builder()
+ .also { wb ->
+ wb.width = width
+ wb.height = height
+ wb.format = DisplayFrame.Format.RGB565
+ wb.frame_id = frameId
+ wb.offset = offset
+ wb.total_size = total
+ wb.rect_x = rectX
+ wb.rect_y = rectY
+ wb.rect_width = rectW
+ wb.rect_height = rectH
+ wb.data_ = data.toByteString()
+ }
+ .build()
@Test
fun `composites a completed rect into an RGB565 frame`() {
diff --git a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
index c35fa077260..883d0d76ce7 100644
--- a/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
+++ b/core/service/src/commonMain/kotlin/org/meshtastic/core/service/AdminControllerImpl.kt
@@ -140,24 +140,29 @@ internal class AdminControllerImpl(
}
override fun setDisplayMirror(enabled: Boolean) {
- commandSender.sendAdminImmediate(myNodeNum) { AdminMessage(set_display_mirror = enabled) }
+ commandSender.sendAdminImmediate(myNodeNum) {
+ AdminMessage.Builder().also { wb -> wb.set_display_mirror = enabled }.build()
+ }
}
override fun requestDisplayFrame() {
- commandSender.sendAdminImmediate(myNodeNum) { AdminMessage(get_display_frame_request = true) }
+ commandSender.sendAdminImmediate(myNodeNum) {
+ AdminMessage.Builder().also { wb -> wb.get_display_frame_request = true }.build()
+ }
}
override fun sendInputEvent(eventCode: Int, kbChar: Int, touchX: Int, touchY: Int) {
+ val inputEvent =
+ AdminMessage.InputEvent.Builder()
+ .also { wb ->
+ wb.event_code = eventCode
+ wb.kb_char = kbChar
+ wb.touch_x = touchX
+ wb.touch_y = touchY
+ }
+ .build()
commandSender.sendAdminImmediate(myNodeNum) {
- AdminMessage(
- send_input_event =
- AdminMessage.InputEvent(
- event_code = eventCode,
- kb_char = kbChar,
- touch_x = touchX,
- touch_y = touchY,
- ),
- )
+ AdminMessage.Builder().also { wb -> wb.send_input_event = inputEvent }.build()
}
}
From 78b020cdd789f1b13ae41a4eaba8b0615c7aa93f Mon Sep 17 00:00:00 2001
From: James Rich
Date: Fri, 2 Oct 2026 13:16:06 -0500
Subject: [PATCH 16/34] style(mirror): apply spotless to the mirror manager
test
---
.../manager/DisplayMirrorManagerImplTest.kt | 26 ++++++++++---------
1 file changed, 14 insertions(+), 12 deletions(-)
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
index 3ed9bdc1dc1..3275a82e9da 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImplTest.kt
@@ -52,15 +52,19 @@ class DisplayMirrorManagerImplTest {
private fun bytes(size: Int, fill: Int) = ByteArray(size) { fill.toByte() }
- private fun palette(signature: Int, regionOffset: Int, regionTotal: Int, regions: List) =
- DisplayPalette.Builder()
- .also { wb ->
- wb.signature = signature
- wb.region_offset = regionOffset
- wb.region_total = regionTotal
- wb.regions = regions
- }
- .build()
+ private fun palette(
+ signature: Int,
+ regionOffset: Int,
+ regionTotal: Int,
+ regions: List,
+ ) = DisplayPalette.Builder()
+ .also { wb ->
+ wb.signature = signature
+ wb.region_offset = regionOffset
+ wb.region_total = regionTotal
+ wb.regions = regions
+ }
+ .build()
@Test
fun `reassembles a three-chunk frame in order`() {
@@ -206,9 +210,7 @@ class DisplayMirrorManagerImplTest {
@Test
fun `reset clears frames palettes and partial state`() {
manager.handleIncomingFrame(chunk(width = 64, height = 32, total = 256, data = bytes(256, 7)))
- manager.handleIncomingPalette(
- palette(signature = 9, regionOffset = 0, regionTotal = 0, regions = emptyList()),
- )
+ manager.handleIncomingPalette(palette(signature = 9, regionOffset = 0, regionTotal = 0, regions = emptyList()))
manager.reset()
From f10b7b940478105f3cac37b69a355de7b8348f21 Mon Sep 17 00:00:00 2001
From: James Rich
Date: Fri, 2 Oct 2026 19:16:09 -0500
Subject: [PATCH 17/34] feat(mirror): type on the device through the shared
keyboard sink
The mirror's key capture was a focusable box, so it could never raise the soft
keyboard. It now uses core/ui's RemoteKeyboardSink: the Keyboard chip raises
the IME, typed text reaches the device one code point per kb_char (emoji
included), Enter is OK, Esc is Back, Backspace and Tab are typed characters,
and Ctrl/Alt chords stay with the host. The scroll column pads for the IME so
the D-pad stays visible. Space now types a space instead of meaning OK.
---
.../settings/debugging/DisplayMirror.kt | 75 +++++++------------
.../settings/debugging/DisplayMirrorUtils.kt | 50 ++++++++-----
.../debugging/DisplayMirrorInputTest.kt | 61 +++++++++++++++
3 files changed, 119 insertions(+), 67 deletions(-)
create mode 100644 feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorInputTest.kt
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index 322fa8639a5..a6dcc4be76b 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -19,7 +19,6 @@ package org.meshtastic.feature.settings.debugging
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.focusable
import androidx.compose.foundation.gestures.detectDragGestures
import androidx.compose.foundation.gestures.detectTapGestures
import androidx.compose.foundation.layout.Arrangement
@@ -28,6 +27,7 @@ import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
@@ -50,20 +50,10 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.focus.onFocusChanged
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.key.Key
-import androidx.compose.ui.input.key.KeyEventType
-import androidx.compose.ui.input.key.isAltPressed
-import androidx.compose.ui.input.key.isCtrlPressed
-import androidx.compose.ui.input.key.isMetaPressed
-import androidx.compose.ui.input.key.key
-import androidx.compose.ui.input.key.onPreviewKeyEvent
-import androidx.compose.ui.input.key.type
-import androidx.compose.ui.input.key.utf16CodePoint
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalHapticFeedback
@@ -86,6 +76,9 @@ import org.meshtastic.core.resources.mirror_no_frame
import org.meshtastic.core.resources.mirror_not_connected
import org.meshtastic.core.resources.mirror_off
import org.meshtastic.core.resources.refresh
+import org.meshtastic.core.ui.input.RemoteKey
+import org.meshtastic.core.ui.input.RemoteKeyHandler
+import org.meshtastic.core.ui.input.RemoteKeyboardSink
import org.meshtastic.proto.DisplayInfo
// M3 comfortable target for remote-control keys (48dp minimum + breathing room).
@@ -140,7 +133,7 @@ fun DisplayMirrorContent(modifier: Modifier = Modifier, viewModel: DisplayMirror
DisposableEffect(Unit) { onDispose { viewModel.stopMirroring() } }
Column(
- modifier = modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp),
+ modifier = modifier.fillMaxSize().imePadding().verticalScroll(rememberScrollState()).padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
@@ -226,9 +219,10 @@ private fun MirrorWithControls(
}
/**
- * The live mirror plus its direct input affordances: a Keyboard chip toggles key capture (arrows, Enter/Space = OK,
- * Esc/Backspace = Back), swiping in a cardinal direction sends one direction event, and on touch-capable devices
- * tapping or long-pressing the image forwards real touch coordinates; elsewhere a tap toggles capture.
+ * The live mirror plus its direct input affordances: a Keyboard chip toggles key capture, which raises the soft
+ * keyboard (arrows navigate, Enter = OK, Esc = Back, typed text reaches the device as characters), swiping in a
+ * cardinal direction sends one direction event, and on touch-capable devices tapping or long-pressing the image
+ * forwards real touch coordinates; elsewhere a tap toggles capture.
*/
@Composable
@Suppress("LongParameterList")
@@ -256,11 +250,7 @@ private fun MirrorSurface(
) {
Box(
modifier =
- Modifier.focusRequester(focusRequester)
- .onFocusChanged { focused = it.isFocused }
- .focusable()
- .remoteKeyInput(onEvent, onChar)
- .pointerInput(hasTouch) {
+ Modifier.pointerInput(hasTouch) {
detectTapGestures(
onTap = { offset ->
if (hasTouch) {
@@ -290,6 +280,11 @@ private fun MirrorSurface(
.border(width = 2.dp, color = if (focused) focusColor else Color.Transparent),
) {
MirrorFrameImage(frame, palette)
+ RemoteKeyboardSink(
+ focusRequester = focusRequester,
+ handler = mirrorKeyHandler(onEvent, onChar),
+ modifier = Modifier.onFocusChanged { focused = it.isFocused },
+ )
}
MirrorControlHints(focused = focused, hasTouch = hasTouch, onToggleKeyboard = { toggleKeyboard() })
}
@@ -318,36 +313,20 @@ private fun MirrorControlHints(focused: Boolean, hasTouch: Boolean, onToggleKeyb
}
/**
- * Sends captured key presses to the device: mapped navigation keys as input events, Backspace and printable characters
- * as typed characters. Handled keys are consumed on both down and up so nothing leaks into the surrounding scroll
- * container.
+ * Maps the keyboard sink onto device input: navigation keys become input events, typed text and Backspace/Tab become
+ * characters. Ctrl/Alt chords are left to the host, so desktop shortcuts never reach the device.
*/
-private fun Modifier.remoteKeyInput(onEvent: (Int) -> Unit, onChar: (Int) -> Unit): Modifier =
- onPreviewKeyEvent { event ->
- // Never swallow host shortcuts (Cmd+Q, Ctrl+C, Alt+Tab): those belong to
- // the desktop, not the mirrored device.
- if (event.isCtrlPressed || event.isMetaPressed || event.isAltPressed) return@onPreviewKeyEvent false
- val down = event.type == KeyEventType.KeyDown
- val mapped = keyToInputEvent(event.key)
- when {
- mapped != null -> {
- if (down) onEvent(mapped)
- true
- }
-
- event.key == Key.Backspace -> {
- if (down) onChar(CHAR_BACKSPACE)
- true
- }
-
- event.utf16CodePoint >= FIRST_PRINTABLE_CHAR -> {
- if (down) onChar(event.utf16CodePoint)
- true
- }
-
- else -> false
+private fun mirrorKeyHandler(onEvent: (Int) -> Unit, onChar: (Int) -> Unit) = RemoteKeyHandler(
+ onText = { text -> forEachCodePoint(text, onChar) },
+ onEnter = { onEvent(INPUT_SELECT) },
+ onBackspace = { onChar(CHAR_BACKSPACE) },
+ onKey = { key ->
+ when (key) {
+ RemoteKey.TAB -> onChar(CHAR_TAB)
+ else -> key.toInputEvent()?.let(onEvent)
}
- }
+ },
+)
/** Converts a completed drag into one direction event along its dominant axis, ignoring short accidental swipes. */
private fun Modifier.swipeToDirection(onEvent: (Int) -> Unit): Modifier = pointerInput(Unit) {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
index 1616dd83a66..c0f67ebb7b6 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -20,8 +20,8 @@ import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.key.Key
import org.meshtastic.core.repository.MirrorFrame
+import org.meshtastic.core.ui.input.RemoteKey
// Firmware input_broker_event codes (src/input/InputBroker.h). USER_PRESS is
// what physical touch drivers emit for a tap, with touch coordinates attached.
@@ -41,8 +41,8 @@ internal const val INPUT_ANYKEY = 0xFF
// rather than navigating back (which is what Esc is for).
internal const val CHAR_BACKSPACE = 8
-// Below this, key events are control codes rather than typable text.
-internal const val FIRST_PRINTABLE_CHAR = 32
+// LVGL's next-focus key value, typed as a character like Backspace.
+internal const val CHAR_TAB = 9
/** Scales a tap position on the scaled-up mirror image back to panel pixel coordinates. */
internal fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
@@ -51,25 +51,37 @@ internal fun Offset.toDeviceX(boxWidthPx: Int, frame: MirrorFrame): Int =
internal fun Offset.toDeviceY(boxHeightPx: Int, frame: MirrorFrame): Int =
(y / boxHeightPx * frame.height).toInt().coerceIn(0, frame.height - 1)
-internal fun keyToInputEvent(key: Key): Int? = when (key) {
- Key.DirectionUp -> INPUT_UP
-
- Key.DirectionDown -> INPUT_DOWN
-
- Key.DirectionLeft -> INPUT_LEFT
-
- Key.DirectionRight -> INPUT_RIGHT
-
- Key.Enter,
- Key.NumPadEnter,
- Key.Spacebar,
- -> INPUT_SELECT
-
- Key.Escape -> INPUT_BACK
-
+/** The device navigation event for a key the mirror forwards; null for keys a device UI has no use for. */
+internal fun RemoteKey.toInputEvent(): Int? = when (this) {
+ RemoteKey.UP -> INPUT_UP
+ RemoteKey.DOWN -> INPUT_DOWN
+ RemoteKey.LEFT -> INPUT_LEFT
+ RemoteKey.RIGHT -> INPUT_RIGHT
+ RemoteKey.ESCAPE -> INPUT_BACK
else -> null
}
+/** Calls [action] with each Unicode code point of [text], joining surrogate pairs so one character is one kb_char. */
+internal fun forEachCodePoint(text: String, action: (Int) -> Unit) {
+ var i = 0
+ while (i < text.length) {
+ val c = text[i]
+ val next = text.getOrNull(i + 1)
+ if (c.isHighSurrogate() && next != null && next.isLowSurrogate()) {
+ action(SUPPLEMENTARY_BASE + ((c.code - HIGH_SURROGATE_BASE) shl SURROGATE_SHIFT) + (next.code - LOW_SURROGATE_BASE))
+ i += 2
+ } else {
+ action(c.code)
+ i++
+ }
+ }
+}
+
+private const val SUPPLEMENTARY_BASE = 0x10000
+private const val HIGH_SURROGATE_BASE = 0xD800
+private const val LOW_SURROGATE_BASE = 0xDC00
+private const val SURROGATE_SHIFT = 10
+
@Composable
internal fun dpadContentColor(enabled: Boolean): Color =
if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
diff --git a/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorInputTest.kt b/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorInputTest.kt
new file mode 100644
index 00000000000..70d71b76fa0
--- /dev/null
+++ b/feature/settings/src/commonTest/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorInputTest.kt
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.feature.settings.debugging
+
+import org.meshtastic.core.ui.input.RemoteKey
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class DisplayMirrorInputTest {
+
+ private fun codePoints(text: String): List = mutableListOf().also { out ->
+ forEachCodePoint(text) { out += it }
+ }
+
+ @Test
+ fun plainTextIsOneCodePointPerCharacter() {
+ assertEquals(listOf('h'.code, 'i'.code, ' '.code), codePoints("hi "))
+ }
+
+ @Test
+ fun aSurrogatePairIsOneCodePoint() {
+ assertEquals(listOf(0x1F600), codePoints("😀"))
+ assertEquals(listOf('a'.code, 0x1F600, 'b'.code), codePoints("a😀b"))
+ }
+
+ @Test
+ fun aLoneSurrogatePassesThroughUnchanged() {
+ assertEquals(listOf(0xD83D, 'x'.code), codePoints("\uD83Dx"))
+ }
+
+ @Test
+ fun navigationKeysMapToDeviceEvents() {
+ assertEquals(INPUT_UP, RemoteKey.UP.toInputEvent())
+ assertEquals(INPUT_DOWN, RemoteKey.DOWN.toInputEvent())
+ assertEquals(INPUT_LEFT, RemoteKey.LEFT.toInputEvent())
+ assertEquals(INPUT_RIGHT, RemoteKey.RIGHT.toInputEvent())
+ assertEquals(INPUT_BACK, RemoteKey.ESCAPE.toInputEvent())
+ }
+
+ @Test
+ fun terminalOnlyKeysMapToNothing() {
+ assertNull(RemoteKey.HOME.toInputEvent())
+ assertNull(RemoteKey.PAGE_DOWN.toInputEvent())
+ assertNull(RemoteKey.DELETE.toInputEvent())
+ }
+}
From 55cf8a7d968e23797b320abc0daa084c5f72db59 Mon Sep 17 00:00:00 2001
From: James Rich
Date: Fri, 2 Oct 2026 19:25:23 -0500
Subject: [PATCH 18/34] fix(mirror): keep the palette region list a val for
type-resolved detekt
---
.../data/manager/DisplayMirrorManagerImpl.kt | 6 +--
.../settings/debugging/DisplayMirror.kt | 52 +++++++++----------
.../settings/debugging/DisplayMirrorUtils.kt | 6 ++-
3 files changed, 34 insertions(+), 30 deletions(-)
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
index 2c6d29cdf97..46bb27e5df3 100644
--- a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/manager/DisplayMirrorManagerImpl.kt
@@ -52,7 +52,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
private val rects = MirrorRectCompositor()
- private var paletteRegions = mutableListOf()
+ private val paletteRegions = mutableListOf()
private var paletteSignature = 0
private var paletteReceived = 0
private var paletteDefaultOn = 0
@@ -106,7 +106,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
override fun handleIncomingPalette(chunk: DisplayPalette) {
if (chunk.region_offset == 0) {
- paletteRegions = mutableListOf()
+ paletteRegions.clear()
paletteSignature = chunk.signature
paletteReceived = 0
// Defaults are authoritative on the first chunk; later chunks may omit them.
@@ -192,7 +192,7 @@ class DisplayMirrorManagerImpl : DisplayMirrorManager {
buffer = null
received = 0
rects.reset()
- paletteRegions = mutableListOf()
+ paletteRegions.clear()
paletteReceived = 0
paletteSignature = 0
_frame.value = null
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
index a6dcc4be76b..2006bbaafb8 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirror.kt
@@ -27,8 +27,8 @@ import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState
@@ -251,31 +251,31 @@ private fun MirrorSurface(
Box(
modifier =
Modifier.pointerInput(hasTouch) {
- detectTapGestures(
- onTap = { offset ->
- if (hasTouch) {
- onTouch(
- INPUT_USER_PRESS,
- offset.toDeviceX(size.width, currentFrame),
- offset.toDeviceY(size.height, currentFrame),
- )
- } else {
- // Tap toggles keyboard control so there is always a way out of capture.
- toggleKeyboard()
- }
- },
- onLongPress = { offset ->
- // Physical touch drivers map a long-press to SELECT with coordinates.
- if (hasTouch) {
- onTouch(
- INPUT_SELECT,
- offset.toDeviceX(size.width, currentFrame),
- offset.toDeviceY(size.height, currentFrame),
- )
- }
- },
- )
- }
+ detectTapGestures(
+ onTap = { offset ->
+ if (hasTouch) {
+ onTouch(
+ INPUT_USER_PRESS,
+ offset.toDeviceX(size.width, currentFrame),
+ offset.toDeviceY(size.height, currentFrame),
+ )
+ } else {
+ // Tap toggles keyboard control so there is always a way out of capture.
+ toggleKeyboard()
+ }
+ },
+ onLongPress = { offset ->
+ // Physical touch drivers map a long-press to SELECT with coordinates.
+ if (hasTouch) {
+ onTouch(
+ INPUT_SELECT,
+ offset.toDeviceX(size.width, currentFrame),
+ offset.toDeviceY(size.height, currentFrame),
+ )
+ }
+ },
+ )
+ }
.swipeToDirection(onEvent)
.border(width = 2.dp, color = if (focused) focusColor else Color.Transparent),
) {
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
index c0f67ebb7b6..b03f88ea663 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -68,7 +68,11 @@ internal fun forEachCodePoint(text: String, action: (Int) -> Unit) {
val c = text[i]
val next = text.getOrNull(i + 1)
if (c.isHighSurrogate() && next != null && next.isLowSurrogate()) {
- action(SUPPLEMENTARY_BASE + ((c.code - HIGH_SURROGATE_BASE) shl SURROGATE_SHIFT) + (next.code - LOW_SURROGATE_BASE))
+ action(
+ SUPPLEMENTARY_BASE +
+ ((c.code - HIGH_SURROGATE_BASE) shl SURROGATE_SHIFT) +
+ (next.code - LOW_SURROGATE_BASE),
+ )
i += 2
} else {
action(c.code)
From c898e0494d4d50641dc6b543315f79af9dc7fbf8 Mon Sep 17 00:00:00 2001
From: James Rich
Date: Fri, 2 Oct 2026 19:45:12 -0500
Subject: [PATCH 19/34] fix(mirror): mark the D-pad colour helper
ReadOnlyComposable
---
.../meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt | 2 ++
1 file changed, 2 insertions(+)
diff --git a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
index b03f88ea663..bcfa1e1b700 100644
--- a/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
+++ b/feature/settings/src/commonMain/kotlin/org/meshtastic/feature/settings/debugging/DisplayMirrorUtils.kt
@@ -18,6 +18,7 @@ package org.meshtastic.feature.settings.debugging
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ReadOnlyComposable
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import org.meshtastic.core.repository.MirrorFrame
@@ -87,5 +88,6 @@ private const val LOW_SURROGATE_BASE = 0xDC00
private const val SURROGATE_SHIFT = 10
@Composable
+@ReadOnlyComposable
internal fun dpadContentColor(enabled: Boolean): Color =
if (enabled) MaterialTheme.colorScheme.onSecondaryContainer else MaterialTheme.colorScheme.onSurfaceVariant
From 14b2f58aadaefc9ae04a4924b81c28089dbda363 Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Wed, 7 Oct 2026 12:29:50 -0500
Subject: [PATCH 20/34] refactor(mirror): build display protos through Builder
---
.../manager/FromRadioPacketHandlerImplTest.kt | 35 +++++++++++++++----
1 file changed, 29 insertions(+), 6 deletions(-)
diff --git a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
index 2eb779d3482..8ae93b41e0a 100644
--- a/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
+++ b/core/data/src/commonTest/kotlin/org/meshtastic/core/data/manager/FromRadioPacketHandlerImplTest.kt
@@ -221,12 +221,21 @@ class FromRadioPacketHandlerImplTest {
val xmodemPacket = XModem.Builder().build()
val lockdownStatus = LockdownStatus.Builder().also { wb -> wb.state = LockdownStatus.State.LOCKED }.build()
+ val displayFrame =
+ DisplayFrame.Builder()
+ .also { wb ->
+ wb.width = 128
+ wb.height = 64
+ }
+ .build()
+ val displayPalette = DisplayPalette.Builder().also { wb -> wb.signature = 1 }.build()
+
handle(FromRadio.Builder().also { wb -> wb.mqttClientProxyMessage = proxyMessage }.build())
handle(FromRadio.Builder().also { wb -> wb.queueStatus = queueStatus }.build())
handle(FromRadio.Builder().also { wb -> wb.xmodemPacket = xmodemPacket }.build())
handle(FromRadio.Builder().also { wb -> wb.lockdown_status = lockdownStatus }.build())
- handle(FromRadio(display_frame = DisplayFrame(width = 128, height = 64)))
- handle(FromRadio(display_palette = DisplayPalette(signature = 1)))
+ handle(FromRadio.Builder().also { wb -> wb.display_frame = displayFrame }.build())
+ handle(FromRadio.Builder().also { wb -> wb.display_palette = displayPalette }.build())
verify(mode = VerifyMode.exactly(0)) { mqttManager.handleMqttProxyMessage(any()) }
verify(mode = VerifyMode.exactly(0)) { packetHandler.handleQueueStatus(any()) }
@@ -238,18 +247,32 @@ class FromRadioPacketHandlerImplTest {
@Test
fun `handleFromRadio routes DISPLAY_FRAME to displayMirrorManager`() {
- val frame = DisplayFrame(width = 128, height = 64, frame_id = 1, total_size = 1024)
+ val frame =
+ DisplayFrame.Builder()
+ .also { wb ->
+ wb.width = 128
+ wb.height = 64
+ wb.frame_id = 1
+ wb.total_size = 1024
+ }
+ .build()
- handle(FromRadio(display_frame = frame))
+ handle(FromRadio.Builder().also { wb -> wb.display_frame = frame }.build())
verify { displayMirrorManager.handleIncomingFrame(frame) }
}
@Test
fun `handleFromRadio routes DISPLAY_PALETTE to displayMirrorManager`() {
- val palette = DisplayPalette(signature = 7, region_total = 0)
+ val palette =
+ DisplayPalette.Builder()
+ .also { wb ->
+ wb.signature = 7
+ wb.region_total = 0
+ }
+ .build()
- handle(FromRadio(display_palette = palette))
+ handle(FromRadio.Builder().also { wb -> wb.display_palette = palette }.build())
verify { displayMirrorManager.handleIncomingPalette(palette) }
}
From 05411f4abe9821e9e725dfdb433e816ab0688f2c Mon Sep 17 00:00:00 2001
From: James Rich <2199651+jamesarich@users.noreply.github.com>
Date: Thu, 15 Oct 2026 12:04:51 -0500
Subject: [PATCH 21/34] feat(node): view a device's 3D model, and place it in
AR on the google flavor
The flasher serves a real-size GLB beside each device illustration that has
one. Node detail's hero avatar shows a 3D badge when the model exists and opens
it full screen, orbitable and lit by a bundled CC0 studio light probe over the
theme background, with the illustration as the fallback. On the google flavor
an AR action places the model on a real surface at real size through ARCore;
the fdroid flavor and desktop have no AR and never show it.
---
.skills/compose-ui/strings-index.txt | 3 +
androidApp/build.gradle.kts | 4 +
.../app/node/DeviceModelArViewer.kt | 22 ++
.../app/node/DeviceModelArViewer.kt | 268 ++++++++++++++++++
androidApp/src/main/AndroidManifest.xml | 12 +
.../kotlin/org/meshtastic/app/MainActivity.kt | 3 +
.../meshtastic/app/SceneViewManifestTest.kt | 64 +++++
.../repository/DeviceModelRepositoryImpl.kt | 45 +++
.../meshtastic/core/model/DeviceHardware.kt | 7 +
.../network/DeviceModelRemoteDataSource.kt | 62 ++++
.../core/network/HttpClientDefaults.kt | 3 +
.../DeviceModelRemoteDataSourceTest.kt | 79 ++++++
.../core/repository/DeviceModelRepository.kt | 29 ++
.../drawable/ic_view_in_ar.xml | 10 +
.../files/environments/studio_small_09.hdr | Bin 0 -> 1615248 bytes
.../composeResources/values/strings.xml | 3 +
.../org/meshtastic/core/ui/icon/Hardware.kt | 5 +
.../core/ui/util/LocalDeviceModelArViewer.kt | 33 +++
feature/node/build.gradle.kts | 16 +-
.../component/SceneViewerPlatform.android.kt | 87 ++++++
.../node/component/DeviceDetailsSection.kt | 56 +++-
.../node/component/DeviceModelDialog.kt | 146 ++++++++++
.../node/component/DeviceModelViewModel.kt | 75 +++++
.../node/component/NodeDetailsSection.kt | 4 +
.../node/component/SceneViewerPlatform.kt | 87 ++++++
.../feature/node/detail/NodeDetailContent.kt | 2 +
.../feature/node/detail/NodeDetailScreens.kt | 9 +
.../usecase/CommonGetNodeDetailsUseCase.kt | 17 +-
.../feature/node/model/GlbBounds.kt | 114 ++++++++
.../feature/node/model/MetricsState.kt | 2 +
.../feature/node/model/NodeDetailAction.kt | 4 +
.../feature/node/model/GlbBoundsTest.kt | 90 ++++++
.../node/component/SceneViewerPlatform.ios.kt | 25 ++
.../node/component/SceneViewerPlatform.jvm.kt | 25 ++
gradle/libs.versions.toml | 1 +
35 files changed, 1394 insertions(+), 18 deletions(-)
create mode 100644 androidApp/src/fdroid/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
create mode 100644 androidApp/src/google/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
create mode 100644 androidApp/src/test/kotlin/org/meshtastic/app/SceneViewManifestTest.kt
create mode 100644 core/data/src/commonMain/kotlin/org/meshtastic/core/data/repository/DeviceModelRepositoryImpl.kt
create mode 100644 core/network/src/commonMain/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSource.kt
create mode 100644 core/network/src/commonTest/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSourceTest.kt
create mode 100644 core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DeviceModelRepository.kt
create mode 100644 core/resources/src/commonMain/composeResources/drawable/ic_view_in_ar.xml
create mode 100644 core/resources/src/commonMain/composeResources/files/environments/studio_small_09.hdr
create mode 100644 core/ui/src/commonMain/kotlin/org/meshtastic/core/ui/util/LocalDeviceModelArViewer.kt
create mode 100644 feature/node/src/androidMain/kotlin/org/meshtastic/feature/node/component/SceneViewerPlatform.android.kt
create mode 100644 feature/node/src/commonMain/kotlin/org/meshtastic/feature/node/component/DeviceModelDialog.kt
create mode 100644 feature/node/src/commonMain/kotlin/org/meshtastic/feature/node/component/DeviceModelViewModel.kt
create mode 100644 feature/node/src/commonMain/kotlin/org/meshtastic/feature/node/component/SceneViewerPlatform.kt
create mode 100644 feature/node/src/commonMain/kotlin/org/meshtastic/feature/node/model/GlbBounds.kt
create mode 100644 feature/node/src/commonTest/kotlin/org/meshtastic/feature/node/model/GlbBoundsTest.kt
create mode 100644 feature/node/src/iosMain/kotlin/org/meshtastic/feature/node/component/SceneViewerPlatform.ios.kt
create mode 100644 feature/node/src/jvmMain/kotlin/org/meshtastic/feature/node/component/SceneViewerPlatform.jvm.kt
diff --git a/.skills/compose-ui/strings-index.txt b/.skills/compose-ui/strings-index.txt
index ed13dd5a814..c747f1ede91 100644
--- a/.skills/compose-ui/strings-index.txt
+++ b/.skills/compose-ui/strings-index.txt
@@ -391,6 +391,9 @@ device_metrics_log
device_metrics_numeric_value
device_metrics_percent_value
device_metrics_voltage_value
+device_model_load_failed
+device_model_view
+device_model_view_in_space
device_sleeping
device_storage_ui_title
device_theme_language
diff --git a/androidApp/build.gradle.kts b/androidApp/build.gradle.kts
index 0e4ed76cf46..f6f1bce6bed 100644
--- a/androidApp/build.gradle.kts
+++ b/androidApp/build.gradle.kts
@@ -270,6 +270,10 @@ dependencies {
googleImplementation(libs.location.services)
googleImplementation(libs.play.services.maps)
+ // ARCore for the device model viewer; proprietary, so google only. Same exclusions as feature/node's sceneview.
+ googleImplementation("io.github.sceneview:arsceneview:${libs.versions.sceneview.get()}") {
+ exclude(group = "org.jetbrains.kotlin", module = "kotlin-android-extensions-runtime")
+ }
googleImplementation(libs.maps.compose)
googleImplementation(libs.maps.compose.utils)
googleImplementation(libs.maps.compose.widgets)
diff --git a/androidApp/src/fdroid/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt b/androidApp/src/fdroid/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
new file mode 100644
index 00000000000..f89456e2a5f
--- /dev/null
+++ b/androidApp/src/fdroid/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.app.node
+
+import org.meshtastic.core.ui.util.DeviceModelArViewer
+
+/** ARCore is proprietary, so the fdroid flavor has no AR viewer and the action never shows. */
+val deviceModelArViewer: DeviceModelArViewer? = null
diff --git a/androidApp/src/google/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt b/androidApp/src/google/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
new file mode 100644
index 00000000000..55092bb4afb
--- /dev/null
+++ b/androidApp/src/google/kotlin/org/meshtastic/app/node/DeviceModelArViewer.kt
@@ -0,0 +1,268 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.app.node
+
+import android.Manifest
+import android.content.pm.PackageManager
+import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import com.google.ar.core.Anchor
+import com.google.ar.core.ArCoreApk
+import com.google.ar.core.Config
+import com.google.ar.core.Frame
+import com.google.ar.core.Plane
+import com.google.ar.core.Session
+import com.google.ar.core.TrackingFailureReason
+import com.google.ar.core.TrackingState
+import io.github.sceneview.ar.ARCoachingOverlay
+import io.github.sceneview.ar.ARSceneView
+import io.github.sceneview.ar.PlacementReticleVisual
+import io.github.sceneview.ar.ReticlePhase
+import io.github.sceneview.ar.arcore.rememberDetectedPlanes
+import io.github.sceneview.ar.placementHit
+import io.github.sceneview.ar.rememberArGuidanceState
+import io.github.sceneview.ar.reticlePhaseFor
+import io.github.sceneview.ar.scene.SceneUnderstanding
+import io.github.sceneview.model.model
+import io.github.sceneview.rememberEngine
+import io.github.sceneview.rememberMaterialLoader
+import io.github.sceneview.rememberModelLoader
+import io.github.sceneview.rememberOnGestureListener
+import org.jetbrains.compose.resources.stringResource
+import org.meshtastic.core.resources.Res
+import org.meshtastic.core.resources.close
+import org.meshtastic.core.ui.icon.Close
+import org.meshtastic.core.ui.icon.MeshtasticIcons
+import org.meshtastic.core.ui.util.DeviceModelArViewer
+import java.nio.ByteBuffer
+
+private const val SCRIM_ALPHA = 0.4f
+
+val deviceModelArViewer: DeviceModelArViewer? = GoogleDeviceModelArViewer
+
+/**
+ * The google flavor's AR viewer. A phone ARCore is still checking, or that only lacks the ARCore app, counts as
+ * available: the viewer's own overlay offers the install.
+ */
+private object GoogleDeviceModelArViewer : DeviceModelArViewer {
+ @Composable
+ override fun isAvailable(): Boolean {
+ val context = LocalContext.current
+ return remember(context) { !ArCoreApk.getInstance().checkAvailability(context).isUnsupported }
+ }
+
+ @Composable
+ override fun Content(glb: ByteArray, title: String, notice: String?, onDismiss: () -> Unit) =
+ DeviceModelAr(glb, title, notice, onDismiss)
+}
+
+/**
+ * Tap a surface to stand the device on it at real size: the models are in meters and ARCore works in meters, so nothing
+ * is scaled. A later tap moves it rather than adding another, and a twist turns it.
+ */
+@Composable
+private fun DeviceModelAr(glb: ByteArray, title: String, notice: String?, onDismiss: () -> Unit) {
+ BackHandler(onBack = onDismiss)
+ // Asked here rather than left to the AR view, whose own request never appears from inside a dialog.
+ val context = LocalContext.current
+ var cameraGranted by remember {
+ mutableStateOf(
+ ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED,
+ )
+ }
+ val requestCamera =
+ rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
+ if (granted) cameraGranted = true else onDismiss()
+ }
+ var asked by rememberSaveable { mutableStateOf(false) }
+ SideEffect {
+ if (!cameraGranted && !asked) {
+ asked = true
+ requestCamera.launch(Manifest.permission.CAMERA)
+ }
+ }
+ Box(modifier = Modifier.fillMaxSize()) {
+ if (cameraGranted) DeviceModelArScene(glb)
+ ArHeader(title, notice, onDismiss)
+ }
+}
+
+/**
+ * ARSceneView rather than SceneView's PlacementScene, which as of 4.56.0 does not pass depth occlusion through. This
+ * keeps its tap-to-place, reticle, coaching and single-shadow-receiver behavior, built from the same public pieces.
+ */
+@Composable
+@Suppress("LongMethod")
+private fun DeviceModelArScene(glb: ByteArray) {
+ val engine = rememberEngine()
+ val modelLoader = rememberModelLoader(engine)
+ val materialLoader = rememberMaterialLoader(engine)
+ val haptic = LocalHapticFeedback.current
+ var anchor by remember { mutableStateOf(null) }
+ var latestFrame by remember { mutableStateOf(null) }
+ var session by remember { mutableStateOf(null) }
+ var viewport by remember { mutableStateOf(IntSize.Zero) }
+ var reticlePhase by remember { mutableStateOf(ReticlePhase.SEARCHING) }
+ var cameraReady by remember { mutableStateOf(false) }
+ var isTracking by remember { mutableStateOf(false) }
+ var surfaceFound by remember { mutableStateOf(false) }
+ var trackingFailure by remember { mutableStateOf(null) }
+ val placed = anchor != null
+ Box(modifier = Modifier.fillMaxSize()) {
+ ARSceneView(
+ modifier = Modifier.fillMaxSize().onSizeChanged { viewport = it },
+ engine = engine,
+ modelLoader = modelLoader,
+ materialLoader = materialLoader,
+ instantPlacementMode = Config.InstantPlacementMode.LOCAL_Y_UP,
+ sessionConfiguration = { arSession, config ->
+ // Real objects in front of the model hide it; phones without depth just skip it.
+ if (arSession.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {
+ config.depthMode = Config.DepthMode.AUTOMATIC
+ }
+ },
+ // The grid shows surfaces until the device stands on one, then gets out of the way.
+ sceneUnderstanding = SceneUnderstanding(occlusion = true, planeVisualization = !placed),
+ onSessionUpdated = { updated, frame ->
+ latestFrame = frame
+ if (session !== updated) session = updated
+ cameraReady = true
+ isTracking = frame.camera.trackingState == TrackingState.TRACKING
+ if (!surfaceFound) {
+ surfaceFound =
+ updated.getAllTrackables(Plane::class.java).any { it.trackingState == TrackingState.TRACKING }
+ }
+ },
+ onTrackingFailureChanged = { trackingFailure = it },
+ onGestureListener =
+ rememberOnGestureListener(
+ onSingleTapConfirmed = { event, node ->
+ // A tap on the model is a gesture on it, not a new placement.
+ val frame = latestFrame
+ if (node == null && frame != null) {
+ placementHit(frame, event.x, event.y, instantPlacement = true)?.let { hit ->
+ anchor?.detach()
+ anchor = hit.createAnchor()
+ haptic.performHapticFeedback(HapticFeedbackType.LongPress)
+ }
+ }
+ },
+ ),
+ ) {
+ if (!placed && isTracking && viewport != IntSize.Zero) {
+ PlacementReticle(
+ xPx = viewport.width / 2f,
+ yPx = viewport.height / 2f,
+ onHitResultChanged = { hit -> reticlePhase = reticlePhaseFor(hasHit = hit != null) },
+ ) {
+ PlacementReticleVisual(materialLoader = materialLoader, phase = reticlePhase)
+ }
+ }
+ // The plane grid carries its own shadow receiver while it shows; one per plane once it is hidden.
+ if (placed) {
+ val planes by rememberDetectedPlanes(session)
+ planes.forEach { plane -> key(plane) { ShadowReceiverPlane(plane = plane) } }
+ }
+ anchor?.let { placedAnchor ->
+ key(placedAnchor) {
+ val instance = remember(modelLoader) { modelLoader.createModelInstance(ByteBuffer.wrap(glb)) }
+ DisposableEffect(instance) { onDispose { modelLoader.destroyModel(instance.model) } }
+ AnchorNode(anchor = placedAnchor) {
+ ModelNode(
+ modelInstance = instance,
+ isEditable = true,
+ apply = {
+ // Turn only: moving is a new tap, and scaling would break real size.
+ isPositionEditable = false
+ isScaleEditable = false
+ isRotationEditable = true
+ },
+ )
+ }
+ }
+ }
+ }
+ val guidance =
+ rememberArGuidanceState(
+ cameraReady = cameraReady,
+ isTracking = isTracking,
+ surfaceFound = surfaceFound,
+ trackingFailureReason = trackingFailure,
+ )
+ ARCoachingOverlay(guidance)
+ }
+}
+
+@Composable
+private fun ArHeader(title: String, notice: String?, onDismiss: () -> Unit) {
+ Column(
+ modifier =
+ Modifier.fillMaxWidth().background(Color.Black.copy(alpha = SCRIM_ALPHA)).safeDrawingPadding().padding(4.dp),
+ ) {
+ Row(verticalAlignment = Alignment.CenterVertically) {
+ IconButton(onClick = onDismiss) {
+ Icon(MeshtasticIcons.Close, contentDescription = stringResource(Res.string.close), tint = Color.White)
+ }
+ Text(
+ text = title,
+ style = MaterialTheme.typography.titleLarge,
+ color = Color.White,
+ modifier = Modifier.padding(start = 8.dp),
+ )
+ }
+ notice?.let {
+ Text(
+ text = it,
+ style = MaterialTheme.typography.labelSmall,
+ color = Color.White.copy(alpha = 0.8f),
+ modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp),
+ )
+ }
+ }
+}
diff --git a/androidApp/src/main/AndroidManifest.xml b/androidApp/src/main/AndroidManifest.xml
index 11fcb5165a2..97af8afea68 100644
--- a/androidApp/src/main/AndroidManifest.xml
+++ b/androidApp/src/main/AndroidManifest.xml
@@ -28,6 +28,18 @@
android:name="android.hardware.location.gps"
android:required="false" />
+
+
+
+
diff --git a/androidApp/src/main/kotlin/org/meshtastic/app/MainActivity.kt b/androidApp/src/main/kotlin/org/meshtastic/app/MainActivity.kt
index 827e1125935..b2e77b4f15e 100644
--- a/androidApp/src/main/kotlin/org/meshtastic/app/MainActivity.kt
+++ b/androidApp/src/main/kotlin/org/meshtastic/app/MainActivity.kt
@@ -57,6 +57,7 @@ import org.koin.compose.viewmodel.koinViewModel
import org.meshtastic.app.intro.AnalyticsIntro
import org.meshtastic.app.map.getMapViewProvider
import org.meshtastic.app.node.component.InlineMap
+import org.meshtastic.app.node.deviceModelArViewer
import org.meshtastic.app.node.metrics.getTracerouteMapOverlayInsets
import org.meshtastic.app.ui.MainScreen
import org.meshtastic.core.barcode.rememberBarcodeScanner
@@ -86,6 +87,7 @@ import org.meshtastic.core.ui.theme.MODE_DYNAMIC
import org.meshtastic.core.ui.util.LocalAnalyticsIntroProvider
import org.meshtastic.core.ui.util.LocalBarcodeScannerProvider
import org.meshtastic.core.ui.util.LocalBarcodeScannerSupported
+import org.meshtastic.core.ui.util.LocalDeviceModelArViewer
import org.meshtastic.core.ui.util.LocalDiscoveryMapProvider
import org.meshtastic.core.ui.util.LocalEventBranding
import org.meshtastic.core.ui.util.LocalInlineMapProvider
@@ -268,6 +270,7 @@ class MainActivity : AppCompatActivity() {
packageManager.hasSystemFeature(PackageManager.FEATURE_NFC_HOST_CARD_EMULATION),
LocalAnalyticsIntroProvider provides { AnalyticsIntro() },
LocalMapViewProvider provides getMapViewProvider(),
+ LocalDeviceModelArViewer provides deviceModelArViewer,
LocalSitePlannerAvailable provides true,
LocalInlineMapProvider provides { node, modifier -> InlineMap(node, modifier) },
LocalNodeTrackMapProvider provides
diff --git a/androidApp/src/test/kotlin/org/meshtastic/app/SceneViewManifestTest.kt b/androidApp/src/test/kotlin/org/meshtastic/app/SceneViewManifestTest.kt
new file mode 100644
index 00000000000..18d24a22f98
--- /dev/null
+++ b/androidApp/src/test/kotlin/org/meshtastic/app/SceneViewManifestTest.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.app
+
+import android.app.Application
+import android.content.Context
+import android.content.pm.FeatureInfo
+import android.content.pm.PackageManager
+import androidx.test.core.app.ApplicationProvider
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+
+/**
+ * The SceneView AAR's manifest marks GLES 3.0 as a required feature and requests VIBRATE. The 3D viewer is optional, so
+ * the app manifest neutralizes both; these assertions read the merged manifest and fail if either override is dropped.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(application = Application::class, sdk = [34])
+class SceneViewManifestTest {
+
+ private val context: Context = ApplicationProvider.getApplicationContext()
+
+ @Test
+ fun `gles 3 is declared but not required`() {
+ val features =
+ context.packageManager.getPackageInfo(context.packageName, PackageManager.GET_CONFIGURATIONS).reqFeatures
+ val gles = assertNotNull(features?.firstOrNull { it.reqGlEsVersion == GLES_3_0 }, "no GLES 3.0 uses-feature")
+ assertFalse(
+ gles.flags and FeatureInfo.FLAG_REQUIRED != 0,
+ "GLES 3.0 is required; the viewer must stay optional",
+ )
+ }
+
+ @Test
+ fun `vibrate is not requested`() {
+ val permissions =
+ context.packageManager
+ .getPackageInfo(context.packageName, PackageManager.GET_PERMISSIONS)
+ .requestedPermissions
+ assertFalse(permissions.orEmpty().contains(android.Manifest.permission.VIBRATE))
+ }
+
+ private companion object {
+ const val GLES_3_0 = 0x00030000
+ }
+}
diff --git a/core/data/src/commonMain/kotlin/org/meshtastic/core/data/repository/DeviceModelRepositoryImpl.kt b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/repository/DeviceModelRepositoryImpl.kt
new file mode 100644
index 00000000000..f735bb00cee
--- /dev/null
+++ b/core/data/src/commonMain/kotlin/org/meshtastic/core/data/repository/DeviceModelRepositoryImpl.kt
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.data.repository
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import org.koin.core.annotation.Single
+import org.meshtastic.core.network.DeviceModelRemoteDataSource
+import org.meshtastic.core.repository.DeviceModelRepository
+
+/**
+ * Memoizes per image name for the process lifetime: a model is a few hundred KB to a few MB and the hero re-asks on
+ * every node detail open. A failed fetch is not cached, so a later open retries.
+ */
+@Single
+class DeviceModelRepositoryImpl(private val remote: DeviceModelRemoteDataSource) : DeviceModelRepository {
+ private val lock = Mutex()
+ private val existing = mutableSetOf()
+ private val models = mutableMapOf()
+
+ override suspend fun hasModel(imageFile: String): Boolean = lock.withLock { imageFile in existing } ||
+ remote.exists(imageFile).also { exists -> if (exists) lock.withLock { existing += imageFile } }
+
+ override suspend fun getModel(imageFile: String): ByteArray? = lock.withLock { models[imageFile] }
+ ?: remote.fetch(imageFile)?.also { bytes ->
+ lock.withLock {
+ models[imageFile] = bytes
+ existing += imageFile
+ }
+ }
+}
diff --git a/core/model/src/commonMain/kotlin/org/meshtastic/core/model/DeviceHardware.kt b/core/model/src/commonMain/kotlin/org/meshtastic/core/model/DeviceHardware.kt
index a3877e277c4..94d7dd79e3b 100644
--- a/core/model/src/commonMain/kotlin/org/meshtastic/core/model/DeviceHardware.kt
+++ b/core/model/src/commonMain/kotlin/org/meshtastic/core/model/DeviceHardware.kt
@@ -70,3 +70,10 @@ data class DeviceHardware(
val isDiy: Boolean
get() = tags.orEmpty().contains("DIY")
}
+
+/**
+ * The illustration the apps show for this hardware: the cased variant when the registry lists one (index 1), else the
+ * bare board. The flasher's 3D model, when there is one, is named after the same file.
+ */
+val DeviceHardware.heroImageFile: String?
+ get() = images?.getOrNull(1) ?: images?.getOrNull(0)
diff --git a/core/network/src/commonMain/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSource.kt b/core/network/src/commonMain/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSource.kt
new file mode 100644
index 00000000000..d673e563261
--- /dev/null
+++ b/core/network/src/commonMain/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSource.kt
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.network
+
+import io.ktor.client.HttpClient
+import io.ktor.client.request.get
+import io.ktor.client.request.head
+import io.ktor.client.statement.HttpResponse
+import io.ktor.client.statement.readRawBytes
+import io.ktor.http.ContentType
+import io.ktor.http.contentType
+import io.ktor.http.isSuccess
+import kotlinx.coroutines.withContext
+import org.koin.core.annotation.Single
+import org.meshtastic.core.common.util.safeCatching
+import org.meshtastic.core.di.CoroutineDispatchers
+
+/** Fetches the flasher's GLB device models; the URL is the illustration's with the extension swapped. */
+@Single
+class DeviceModelRemoteDataSource(private val client: HttpClient, private val dispatchers: CoroutineDispatchers) {
+
+ /**
+ * True when the model is served. The flasher is a single-page app that answers a missing path with 200 and its HTML
+ * shell, so only the GLB content type counts.
+ */
+ suspend fun exists(imageFile: String): Boolean = withContext(dispatchers.io) {
+ safeCatching { client.head(modelUrl(imageFile)).isGlb() }.getOrDefault(false)
+ }
+
+ /** The model bytes, or null when absent or the fetch failed. */
+ suspend fun fetch(imageFile: String): ByteArray? = withContext(dispatchers.io) {
+ safeCatching {
+ val response = client.get(modelUrl(imageFile))
+ if (response.isGlb()) response.readRawBytes() else null
+ }
+ .getOrNull()
+ }
+
+ private fun HttpResponse.isGlb(): Boolean =
+ status.isSuccess() && contentType()?.withoutParameters() == GLB_CONTENT_TYPE
+
+ companion object {
+ private val GLB_CONTENT_TYPE = ContentType("model", "gltf-binary")
+
+ fun modelUrl(imageFile: String): String =
+ "${HttpClientDefaults.DEVICE_MODEL_BASE_URL}/${imageFile.substringBeforeLast('.')}.glb"
+ }
+}
diff --git a/core/network/src/commonMain/kotlin/org/meshtastic/core/network/HttpClientDefaults.kt b/core/network/src/commonMain/kotlin/org/meshtastic/core/network/HttpClientDefaults.kt
index 6e1e2a0bb90..38790a5f4e4 100644
--- a/core/network/src/commonMain/kotlin/org/meshtastic/core/network/HttpClientDefaults.kt
+++ b/core/network/src/commonMain/kotlin/org/meshtastic/core/network/HttpClientDefaults.kt
@@ -66,6 +66,9 @@ object HttpClientDefaults {
* those fall back to the release zip named by the API's `zip_url`, which is a GitHub release asset and unaffected.
*/
const val RELEASE_BASE_URL = "https://release.meshtastic.org"
+
+ /** The flasher's device models, `.glb` beside the `img/devices/.svg` illustrations the apps show. */
+ const val DEVICE_MODEL_BASE_URL = "https://flasher.meshtastic.org/models/devices"
}
/**
diff --git a/core/network/src/commonTest/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSourceTest.kt b/core/network/src/commonTest/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSourceTest.kt
new file mode 100644
index 00000000000..b15cafd5725
--- /dev/null
+++ b/core/network/src/commonTest/kotlin/org/meshtastic/core/network/DeviceModelRemoteDataSourceTest.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.network
+
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.mock.MockEngine
+import io.ktor.client.engine.mock.respond
+import io.ktor.http.HttpHeaders
+import io.ktor.http.headersOf
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.test.runTest
+import org.meshtastic.core.di.CoroutineDispatchers
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class DeviceModelRemoteDataSourceTest {
+ private val dispatchers =
+ CoroutineDispatchers(io = Dispatchers.Default, main = Dispatchers.Default, default = Dispatchers.Default)
+
+ @Test
+ fun modelUrlSwapsTheIllustrationExtension() {
+ assertEquals(
+ "https://flasher.meshtastic.org/models/devices/rak4631_case.glb",
+ DeviceModelRemoteDataSource.modelUrl("rak4631_case.svg"),
+ )
+ }
+
+ @Test
+ fun aServedGlbExistsAndIsFetched() = runTest {
+ val glb = byteArrayOf(0x67, 0x6C, 0x54, 0x46)
+ withSource(respondWith = glb, contentType = "model/gltf-binary") { source ->
+ assertTrue(source.exists("tracker-t1000-e.svg"))
+ assertContentEquals(glb, source.fetch("tracker-t1000-e.svg"))
+ }
+ }
+
+ @Test
+ fun theFlashersHtmlShellForAMissingModelIsNotAModel() = runTest {
+ withSource(
+ respondWith = "".encodeToByteArray(),
+ contentType = "text/html;charset=utf-8",
+ ) { source ->
+ assertFalse(source.exists("t-deck.svg"))
+ assertNull(source.fetch("t-deck.svg"))
+ }
+ }
+
+ private suspend fun withSource(
+ respondWith: ByteArray,
+ contentType: String,
+ block: suspend (DeviceModelRemoteDataSource) -> Unit,
+ ) {
+ val client =
+ HttpClient(MockEngine { respond(respondWith, headers = headersOf(HttpHeaders.ContentType, contentType)) })
+ try {
+ block(DeviceModelRemoteDataSource(client, dispatchers))
+ } finally {
+ client.close()
+ }
+ }
+}
diff --git a/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DeviceModelRepository.kt b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DeviceModelRepository.kt
new file mode 100644
index 00000000000..219f293b57e
--- /dev/null
+++ b/core/repository/src/commonMain/kotlin/org/meshtastic/core/repository/DeviceModelRepository.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2026 Meshtastic LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package org.meshtastic.core.repository
+
+/**
+ * The flasher's real-size 3D device models (`/models/devices/.glb`), one per device illustration. A hardware
+ * entry's image file names its model by extension swap, and only some illustrations have one.
+ */
+interface DeviceModelRepository {
+ /** Whether a model exists for [imageFile] (an entry of `DeviceHardware.images`). False on any network failure. */
+ suspend fun hasModel(imageFile: String): Boolean
+
+ /** The GLB bytes for [imageFile], or null when there is no model or it could not be fetched. */
+ suspend fun getModel(imageFile: String): ByteArray?
+}
diff --git a/core/resources/src/commonMain/composeResources/drawable/ic_view_in_ar.xml b/core/resources/src/commonMain/composeResources/drawable/ic_view_in_ar.xml
new file mode 100644
index 00000000000..d2d37ed3317
--- /dev/null
+++ b/core/resources/src/commonMain/composeResources/drawable/ic_view_in_ar.xml
@@ -0,0 +1,10 @@
+
+
+
+
diff --git a/core/resources/src/commonMain/composeResources/files/environments/studio_small_09.hdr b/core/resources/src/commonMain/composeResources/files/environments/studio_small_09.hdr
new file mode 100644
index 0000000000000000000000000000000000000000..e9a2d2272ceee33041dbfefaff72f510d86a164c
GIT binary patch
literal 1615248
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�}(EopQq7C2^Z*lg8_mtL2{ErQC
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