1use ailloli_ui_core::event::keyboard::{Key, KeyState, NamedKey};
7use ailloli_ui_core::event::pointer::{MouseButton, PointerEvent};
8use ailloli_ui_core::{Color, Constraints, ElementId, Event, Rect};
9use ailloli_ui_devtools_core::{
10 collect_debug_snapshot_with_state, debug_draw_cmds, pick_element_at, DebugDrawCmd,
11 DebugSnapshot, DevToolsClientMessage, DevToolsMode, DevToolsServerMessage,
12};
13use ailloli_ui_devtools_ui::{
14 build_devtools_overlay, DevToolsAction, DevToolsState, DEVTOOLS_PANEL_KEY,
15};
16use ailloli_ui_runtime::app::{Runtime, RuntimeHandle, UiWake, UiWakeError};
17use ailloli_ui_runtime::element::ElementTree;
18use ailloli_ui_runtime::input::{absolute_paint_bounds, InputRouter};
19use ailloli_ui_runtime::scene::{ClipStackSnapshot, DrawCmd, DrawRect, Layer, Scene};
20use ailloli_ui_text::TextSystem;
21
22use std::io::{Read, Write};
23use std::net::{SocketAddr, TcpListener, TcpStream};
24use std::sync::atomic::{AtomicUsize, Ordering};
25use std::sync::mpsc::{self, Receiver, Sender};
26use std::sync::{Arc, Mutex};
27use std::thread;
28use std::time::Duration;
29
30const MAX_DEVTOOLS_CLIENTS: usize = 8;
32const MAX_DEVTOOLS_MESSAGE_BYTES: usize = 64 * 1024;
34
35pub struct DevToolsWindowState {
51 pub enabled: bool,
53 pub mode: DevToolsMode,
55 pub picker_active: bool,
57 pub selected: Option<u64>,
59 pub hovered: Option<u64>,
61 runtime: Runtime<DevToolsAction>,
63 input: InputRouter,
65 frame_index: u64,
67 last_snapshot: Option<DebugSnapshot>,
69 last_panel_bounds: Option<Rect>,
71 remote: Option<DevToolsRemote>,
73 host_wake: Option<Arc<dyn UiWake>>,
75}
76
77impl DevToolsWindowState {
79 pub fn new() -> Self {
92 let remote = DevToolsRemote::from_env();
93 Self {
94 enabled: remote.is_some(),
95 mode: DevToolsMode::Overlay,
96 picker_active: false,
97 selected: None,
98 hovered: None,
99 runtime: Runtime::new(RuntimeHandle::new()),
100 input: InputRouter::default(),
101 frame_index: 0,
102 last_snapshot: None,
103 last_panel_bounds: None,
104 remote,
105 host_wake: None,
106 }
107 }
108
109 pub fn set_remote_addr(&mut self, addr: Option<SocketAddr>) {
124 self.remote = addr.and_then(DevToolsRemote::start);
125 if let Some(remote) = self.remote.as_ref() {
126 if let Some(wake) = self.host_wake.as_ref() {
127 let _ = remote.install_wake(wake.clone());
128 }
129 self.enabled = true;
130 }
131 }
132
133 pub(crate) fn install_host_wake(&mut self, wake: Arc<dyn UiWake>) -> Result<(), UiWakeError> {
147 self.host_wake = Some(wake.clone());
148 self.remote
149 .as_ref()
150 .map_or(Ok(()), |remote| remote.install_wake(wake))
151 }
152
153 pub(crate) fn begin_host_service(&self) -> bool {
163 self.remote
164 .as_ref()
165 .is_some_and(DevToolsRemote::begin_host_service)
166 }
167
168 pub(crate) fn take_wake_error(&self) -> Option<UiWakeError> {
178 self.remote
179 .as_ref()
180 .and_then(DevToolsRemote::take_wake_error)
181 }
182
183 pub fn handle_event(&mut self, event: &Event) -> bool {
199 self.apply_remote_commands();
200 match event {
201 Event::Keyboard(key) if key.state == KeyState::Pressed => {
202 if key.modifiers.ctrl
203 && key.modifiers.shift
204 && matches!(&key.key, Key::Character(c) if c.eq_ignore_ascii_case("i"))
205 {
206 self.enabled = !self.enabled;
207 if self.enabled && matches!(self.mode, DevToolsMode::Hidden) {
208 self.mode = DevToolsMode::Overlay;
209 }
210 return true;
211 }
212 if key.modifiers.ctrl
213 && key.modifiers.shift
214 && matches!(&key.key, Key::Character(c) if c.eq_ignore_ascii_case("c"))
215 {
216 self.enabled = true;
217 self.picker_active = !self.picker_active;
218 return true;
219 }
220 if matches!(&key.key, Key::Named(NamedKey::Escape)) {
221 if self.picker_active {
222 self.picker_active = false;
223 } else if self.enabled {
224 self.enabled = false;
225 } else {
226 return false;
227 }
228 return true;
229 }
230 }
231 Event::Pointer(PointerEvent::Moved { pos, .. })
232 | Event::Pointer(PointerEvent::Button { pos, .. })
233 | Event::Pointer(PointerEvent::Wheel { pos, .. })
234 if self.enabled && self.panel_contains(*pos) =>
235 {
236 self.input
237 .route_event(&self.runtime.tree, self.runtime.runtime.clone(), event);
238 self.apply_runtime_actions();
239 return true;
240 }
241 Event::Pointer(PointerEvent::Moved { pos, .. }) if self.picker_active => {
242 self.hovered = self
243 .last_snapshot
244 .as_ref()
245 .and_then(|snapshot| pick_element_at(snapshot, *pos));
246 return true;
247 }
248 Event::Pointer(PointerEvent::Button {
249 pos,
250 button: MouseButton::Left,
251 pressed: false,
252 ..
253 }) if self.picker_active => {
254 self.selected = self
255 .last_snapshot
256 .as_ref()
257 .and_then(|snapshot| pick_element_at(snapshot, *pos));
258 self.picker_active = false;
259 return true;
260 }
261 _ => {}
262 }
263 false
264 }
265
266 pub fn build_scene<A: 'static>(
288 &mut self,
289 tree: &ElementTree<A>,
290 root: ElementId,
291 viewport: Rect,
292 scale: ailloli_ui_core::math::Scale,
293 text_system: &mut TextSystem,
294 ) -> Option<Scene> {
295 self.apply_remote_commands();
296 if !self.enabled && self.remote.is_none() {
297 return None;
298 }
299
300 self.frame_index = self.frame_index.saturating_add(1);
301 let snapshot = collect_debug_snapshot_with_state(
302 tree,
303 root,
304 viewport,
305 self.selected.map(ElementId),
306 self.hovered.map(ElementId),
307 self.frame_index,
308 );
309 if let Some(remote) = &self.remote {
310 remote.publish_snapshot(snapshot.clone());
311 }
312 self.last_snapshot = Some(snapshot.clone());
313
314 if !self.enabled || matches!(self.mode, DevToolsMode::Hidden) {
315 return None;
316 }
317
318 let ui_state = DevToolsState {
319 enabled: self.enabled,
320 mode: self.mode,
321 picker_active: self.picker_active,
322 selected: self.selected,
323 hovered: self.hovered,
324 filter: String::new(),
325 };
326 let overlay = build_devtools_overlay(&snapshot, &ui_state);
327 self.runtime.reconcile(overlay);
328 self.runtime.layout(
329 Constraints::tight(viewport.w, viewport.h),
330 scale,
331 text_system,
332 );
333 self.last_panel_bounds = self.resolve_panel_bounds();
334 self.apply_runtime_actions();
335 let mut scene = self.runtime.paint(text_system);
336 let draw_cmds = debug_draw_cmds(&snapshot)
337 .into_iter()
338 .flat_map(debug_draw_to_runtime)
339 .collect::<Vec<_>>();
340 if !draw_cmds.is_empty() {
341 let mut layer = Layer::overlay(ClipStackSnapshot::empty());
342 layer.cmds = draw_cmds;
343 scene.layers.insert(0, layer);
344 }
345 Some(scene)
346 }
347
348 fn panel_contains(&self, pos: ailloli_ui_core::Point) -> bool {
350 self.last_panel_bounds
351 .is_some_and(|bounds| bounds.contains(pos.x, pos.y))
352 }
353
354 fn resolve_panel_bounds(&self) -> Option<Rect> {
356 let id = self
357 .runtime
358 .tree
359 .resolve_element_by_view_key(DEVTOOLS_PANEL_KEY)
360 .ok()?;
361 absolute_paint_bounds(&self.runtime.tree, id)
362 }
363
364 fn apply_runtime_actions(&mut self) {
366 for action in self.runtime.runtime.take_actions() {
367 self.apply_action(action);
368 }
369 }
370
371 fn apply_action(&mut self, action: DevToolsAction) {
373 match action {
374 DevToolsAction::Select(id) => {
375 self.selected = id;
376 self.enabled = true;
377 }
378 DevToolsAction::Hover(id) => {
379 self.hovered = id;
380 }
381 DevToolsAction::SetMode(mode) => {
382 self.mode = mode;
383 self.enabled = !matches!(mode, DevToolsMode::Hidden);
384 }
385 DevToolsAction::TogglePicker => {
386 self.enabled = true;
387 self.picker_active = !self.picker_active;
388 }
389 DevToolsAction::SetFilter(filter) => {
390 let _ = filter;
391 }
392 }
393 }
394
395 fn apply_remote_commands(&mut self) {
397 let Some(remote) = &self.remote else {
398 return;
399 };
400 for cmd in remote.drain_commands() {
401 match cmd {
402 DevToolsClientMessage::Select { id } => {
403 self.apply_action(DevToolsAction::Select(id));
404 }
405 DevToolsClientMessage::Hover { id } => {
406 self.apply_action(DevToolsAction::Hover(id));
407 }
408 DevToolsClientMessage::SetMode { mode } => {
409 self.apply_action(DevToolsAction::SetMode(mode));
410 }
411 DevToolsClientMessage::Ping => {}
412 }
413 }
414 }
415}
416
417impl Default for DevToolsWindowState {
419 fn default() -> Self {
421 Self::new()
422 }
423}
424
425fn debug_draw_to_runtime(cmd: DebugDrawCmd) -> Vec<DrawCmd> {
427 match cmd {
428 DebugDrawCmd::RectOutline {
429 rect,
430 color,
431 thickness,
432 } => outline_rect(
433 Rect::new(rect.x, rect.y, rect.w, rect.h),
434 Color::f32(color.r, color.g, color.b, color.a),
435 thickness,
436 ),
437 DebugDrawCmd::RectFill { rect, color } => vec![DrawCmd::Rect(DrawRect {
438 rect: Rect::new(rect.x, rect.y, rect.w, rect.h),
439 color: Color::f32(color.r, color.g, color.b, color.a),
440 })],
441 DebugDrawCmd::TextLabel { .. } => Vec::new(),
442 }
443}
444
445fn outline_rect(rect: Rect, color: Color, thickness: f32) -> Vec<DrawCmd> {
447 let t = thickness.max(1.0);
448 vec![
449 DrawCmd::Rect(DrawRect {
450 rect: Rect::new(rect.x, rect.y, rect.w, t),
451 color,
452 }),
453 DrawCmd::Rect(DrawRect {
454 rect: Rect::new(rect.x, rect.bottom() - t, rect.w, t),
455 color,
456 }),
457 DrawCmd::Rect(DrawRect {
458 rect: Rect::new(rect.x, rect.y, t, rect.h),
459 color,
460 }),
461 DrawCmd::Rect(DrawRect {
462 rect: Rect::new(rect.right() - t, rect.y, t, rect.h),
463 color,
464 }),
465 ]
466}
467
468pub struct DevToolsRemote {
483 events: Sender<RemoteEvent>,
485 commands: Receiver<DevToolsClientMessage>,
487 command_wake: Arc<DevToolsCommandWake>,
489}
490
491impl DevToolsRemote {
493 pub fn from_env() -> Option<Self> {
507 let addr =
508 crate::framework_env_var_os("AILLOLI_UI_DEVTOOLS_REMOTE", "OCTAVUI_DEVTOOLS_REMOTE")?;
509 let addr = addr.to_string_lossy().parse::<SocketAddr>().ok()?;
510 Self::start(addr)
511 }
512
513 pub fn start(addr: SocketAddr) -> Option<Self> {
528 if !addr.ip().is_loopback() {
529 eprintln!("ailloli_ui devtools remote refused non-loopback addr {addr}");
530 return None;
531 }
532 let listener = TcpListener::bind(addr).ok()?;
533 listener.set_nonblocking(true).ok()?;
534 let (events_tx, events_rx) = mpsc::channel();
535 let (commands_tx, commands_rx) = mpsc::channel();
536 let command_wake = Arc::new(DevToolsCommandWake::default());
537 let command_sender = DevToolsCommandSender {
538 commands: commands_tx,
539 wake: command_wake.clone(),
540 };
541 thread::spawn(move || run_remote_server(listener, events_rx, command_sender));
542 Some(Self {
543 events: events_tx,
544 commands: commands_rx,
545 command_wake,
546 })
547 }
548
549 pub fn publish_snapshot(&self, snapshot: DebugSnapshot) {
563 let _ = self.events.send(RemoteEvent::Snapshot(snapshot));
564 }
565
566 pub fn drain_commands(&self) -> Vec<DevToolsClientMessage> {
581 let mut out = Vec::new();
582 while let Ok(cmd) = self.commands.try_recv() {
583 self.command_wake.command_drained();
584 out.push(cmd);
585 }
586 out
587 }
588
589 fn install_wake(&self, wake: Arc<dyn UiWake>) -> Result<(), UiWakeError> {
596 self.command_wake.install(wake)
597 }
598
599 fn begin_host_service(&self) -> bool {
601 self.command_wake.begin_host_service()
602 }
603
604 fn take_wake_error(&self) -> Option<UiWakeError> {
606 self.command_wake.take_error()
607 }
608}
609
610#[derive(Default)]
611struct DevToolsCommandWakeState {
613 wake: Option<Arc<dyn UiWake>>,
615 signaled: bool,
617 error: Option<UiWakeError>,
619}
620
621#[derive(Default)]
622struct DevToolsCommandWake {
624 state: Mutex<DevToolsCommandWakeState>,
626 pending_commands: AtomicUsize,
628}
629
630impl DevToolsCommandWake {
632 fn reserve_command(&self) {
637 self.pending_commands.fetch_add(1, Ordering::Release);
638 }
639
640 fn cancel_command(&self) {
642 self.command_drained();
643 }
644
645 fn command_drained(&self) {
647 let _ =
648 self.pending_commands
649 .fetch_update(Ordering::AcqRel, Ordering::Acquire, |pending| {
650 Some(pending.saturating_sub(1))
651 });
652 }
653
654 fn signal(&self) -> Result<(), UiWakeError> {
667 let wake = {
668 let mut state = self.state.lock().expect("devtools wake lock poisoned");
669 if state.signaled {
670 None
671 } else {
672 let wake = state.wake.clone();
673 state.signaled = wake.is_some();
674 wake
675 }
676 };
677 self.invoke(wake)
678 }
679
680 fn install(&self, wake: Arc<dyn UiWake>) -> Result<(), UiWakeError> {
691 let wake = {
692 let mut state = self.state.lock().expect("devtools wake lock poisoned");
693 state.wake = Some(wake.clone());
694 state.signaled = self.pending_commands.load(Ordering::Acquire) > 0;
695 state.signaled.then_some(wake)
696 };
697 self.invoke(wake)
698 }
699
700 fn begin_host_service(&self) -> bool {
702 if let Ok(mut state) = self.state.lock() {
703 state.signaled = false;
704 }
705 self.pending_commands.load(Ordering::Acquire) > 0
706 }
707
708 fn take_error(&self) -> Option<UiWakeError> {
710 self.state
711 .lock()
712 .ok()
713 .and_then(|mut state| state.error.take())
714 }
715
716 fn invoke(&self, wake: Option<Arc<dyn UiWake>>) -> Result<(), UiWakeError> {
723 let Some(wake) = wake else {
724 return Ok(());
725 };
726 if let Err(error) = wake.wake() {
727 if let Ok(mut state) = self.state.lock() {
728 state.signaled = false;
729 state.error.get_or_insert(error);
730 }
731 return Err(error);
732 }
733 Ok(())
734 }
735}
736
737struct DevToolsCommandSender {
739 commands: Sender<DevToolsClientMessage>,
741 wake: Arc<DevToolsCommandWake>,
743}
744
745impl DevToolsCommandSender {
747 fn send(&self, command: DevToolsClientMessage) {
749 self.wake.reserve_command();
750 if self.commands.send(command).is_err() {
751 self.wake.cancel_command();
752 return;
753 }
754 let _ = self.wake.signal();
755 }
756}
757
758enum RemoteEvent {
760 Snapshot(DebugSnapshot),
762}
763
764struct Client {
766 stream: TcpStream,
768 read_buf: String,
770}
771
772fn run_remote_server(
778 listener: TcpListener,
779 events: Receiver<RemoteEvent>,
780 commands: DevToolsCommandSender,
781) {
782 let mut clients = Vec::<Client>::new();
783 loop {
784 loop {
785 match listener.accept() {
786 Ok((mut stream, _)) if clients.len() < MAX_DEVTOOLS_CLIENTS => {
787 let _ = stream.set_nonblocking(true);
788 let hello = DevToolsServerMessage::Hello { protocol: 1 };
789 let _ = write_jsonl(&mut stream, &hello);
790 clients.push(Client {
791 stream,
792 read_buf: String::new(),
793 });
794 }
795 Ok((_stream, _)) => {}
796 Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => break,
797 Err(_) => break,
798 }
799 }
800
801 while let Ok(event) = events.try_recv() {
802 match event {
803 RemoteEvent::Snapshot(snapshot) => {
804 let message = DevToolsServerMessage::Snapshot { snapshot };
805 clients.retain_mut(|client| write_jsonl(&mut client.stream, &message).is_ok());
806 }
807 }
808 }
809
810 clients.retain_mut(|client| read_client_commands(client, &commands));
811 thread::sleep(Duration::from_millis(16));
812 }
813}
814
815fn write_jsonl(stream: &mut TcpStream, message: &DevToolsServerMessage) -> std::io::Result<()> {
822 let mut line = serde_json::to_vec(message)
823 .map_err(|err| std::io::Error::new(std::io::ErrorKind::InvalidData, err))?;
824 line.push(b'\n');
825 stream.write_all(&line)
826}
827
828fn read_client_commands(client: &mut Client, commands: &DevToolsCommandSender) -> bool {
835 let mut buf = [0u8; 4096];
836 loop {
837 match client.stream.read(&mut buf) {
838 Ok(0) => return false,
839 Ok(n) => {
840 client
841 .read_buf
842 .push_str(&String::from_utf8_lossy(&buf[..n]));
843 if client.read_buf.len() > MAX_DEVTOOLS_MESSAGE_BYTES
844 && !client.read_buf[..MAX_DEVTOOLS_MESSAGE_BYTES].contains('\n')
845 {
846 let message = DevToolsServerMessage::Error {
847 message: "devtools message exceeds the 65536-byte limit".to_string(),
848 };
849 let _ = write_jsonl(&mut client.stream, &message);
850 return false;
851 }
852 while let Some(pos) = client.read_buf.find('\n') {
853 if pos > MAX_DEVTOOLS_MESSAGE_BYTES {
854 let message = DevToolsServerMessage::Error {
855 message: "devtools message exceeds the 65536-byte limit".to_string(),
856 };
857 let _ = write_jsonl(&mut client.stream, &message);
858 return false;
859 }
860 let line = client.read_buf[..pos].trim().to_string();
861 client.read_buf = client.read_buf[pos + 1..].to_string();
862 if line.is_empty() {
863 continue;
864 }
865 match serde_json::from_str::<DevToolsClientMessage>(&line) {
866 Ok(DevToolsClientMessage::Ping) => {
867 if write_jsonl(&mut client.stream, &DevToolsServerMessage::Pong)
868 .is_err()
869 {
870 return false;
871 }
872 }
873 Ok(cmd) => {
874 commands.send(cmd);
875 }
876 Err(err) => {
877 let message = DevToolsServerMessage::Error {
878 message: format!("invalid devtools message: {err}"),
879 };
880 if write_jsonl(&mut client.stream, &message).is_err() {
881 return false;
882 }
883 }
884 }
885 }
886 }
887 Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => return true,
888 Err(_) => return false,
889 }
890 }
891}
892
893#[cfg(test)]
894mod tests {
896 use super::*;
897 use std::io::{BufRead, BufReader};
898 use std::sync::atomic::AtomicUsize;
899
900 use ailloli_ui_core::event::keyboard::Modifiers;
901 use ailloli_ui_core::math::Scale;
902 use ailloli_ui_core::Point;
903 use ailloli_ui_devtools_ui::DEVTOOLS_MODE_BOTTOM_KEY;
904 use ailloli_ui_runtime::component::IntoView;
905 use ailloli_ui_runtime::scene::DrawCmd;
906 use ailloli_ui_widgets::layout::Container;
907 use ailloli_ui_widgets::text::Text;
908
909 #[derive(Default)]
910 struct CountingWake(AtomicUsize);
912
913 impl UiWake for CountingWake {
915 fn wake(&self) -> Result<(), UiWakeError> {
921 self.0.fetch_add(1, Ordering::Relaxed);
922 Ok(())
923 }
924 }
925
926 struct FailingWake;
928
929 impl UiWake for FailingWake {
931 fn wake(&self) -> Result<(), UiWakeError> {
937 Err(UiWakeError::TargetClosed)
938 }
939 }
940
941 fn command_channel() -> (
943 DevToolsCommandSender,
944 Receiver<DevToolsClientMessage>,
945 Arc<DevToolsCommandWake>,
946 ) {
947 let (commands, receiver) = mpsc::channel();
948 let wake = Arc::new(DevToolsCommandWake::default());
949 (
950 DevToolsCommandSender {
951 commands,
952 wake: wake.clone(),
953 },
954 receiver,
955 wake,
956 )
957 }
958
959 fn app_runtime() -> (Runtime<()>, TextSystem) {
961 let mut runtime = Runtime::new(RuntimeHandle::new());
962 runtime.reconcile(
963 Container::new()
964 .fill()
965 .child(Text::new("application text"))
966 .into_view(),
967 );
968 let mut text_system = TextSystem::new();
969 runtime.layout(
970 Constraints::tight(800.0, 600.0),
971 Scale::new(1.0),
972 &mut text_system,
973 );
974 (runtime, text_system)
975 }
976
977 fn text_cmd_count(scene: &Scene) -> usize {
979 scene
980 .layers
981 .iter()
982 .flat_map(|layer| layer.cmds.iter())
983 .filter(|cmd| matches!(cmd, DrawCmd::Text(_)))
984 .count()
985 }
986
987 fn pointer_button(pos: Point, pressed: bool) -> Event {
989 Event::Pointer(PointerEvent::Button {
990 pos,
991 button: MouseButton::Left,
992 pressed,
993 modifiers: Modifiers::default(),
994 })
995 }
996
997 fn center_of_key(state: &DevToolsWindowState, key: &str) -> Point {
999 let id = state
1000 .runtime
1001 .tree
1002 .resolve_element_by_view_key(key)
1003 .expect("keyed devtools element");
1004 let bounds = absolute_paint_bounds(&state.runtime.tree, id).expect("element bounds");
1005 Point::new(bounds.x + bounds.w / 2.0, bounds.y + bounds.h / 2.0)
1006 }
1007
1008 fn connected_client() -> (Client, TcpStream) {
1010 let listener = TcpListener::bind("127.0.0.1:0").expect("bind test listener");
1011 let addr = listener.local_addr().expect("read listener addr");
1012 let client_stream = TcpStream::connect(addr).expect("connect client");
1013 let (server_stream, _) = listener.accept().expect("accept client");
1014 server_stream
1015 .set_nonblocking(true)
1016 .expect("server stream nonblocking");
1017 client_stream
1018 .set_read_timeout(Some(Duration::from_secs(1)))
1019 .expect("client read timeout");
1020 (
1021 Client {
1022 stream: server_stream,
1023 read_buf: String::new(),
1024 },
1025 client_stream,
1026 )
1027 }
1028
1029 #[test]
1030 fn remote_reader_accepts_select_command() {
1031 let (mut server_client, mut client_stream) = connected_client();
1032 let (commands_tx, commands_rx, command_wake) = command_channel();
1033 let wake = Arc::new(CountingWake::default());
1034 command_wake.install(wake.clone()).unwrap();
1035
1036 client_stream
1037 .write_all(br#"{"type":"select","id":42}"#)
1038 .expect("write command");
1039 client_stream.write_all(b"\n").expect("write newline");
1040
1041 assert!(read_client_commands(&mut server_client, &commands_tx));
1042 assert_eq!(
1043 commands_rx.try_recv().expect("command queued"),
1044 DevToolsClientMessage::Select { id: Some(42) }
1045 );
1046 assert_eq!(wake.0.load(Ordering::Relaxed), 1);
1047 }
1048
1049 #[test]
1050 fn remote_reader_replies_to_ping() {
1051 let (mut server_client, mut client_stream) = connected_client();
1052 let (commands_tx, commands_rx, _) = command_channel();
1053
1054 client_stream
1055 .write_all(br#"{"type":"ping"}"#)
1056 .expect("write ping");
1057 client_stream.write_all(b"\n").expect("write newline");
1058
1059 assert!(read_client_commands(&mut server_client, &commands_tx));
1060
1061 let mut line = String::new();
1062 let mut reader = BufReader::new(client_stream);
1063 reader.read_line(&mut line).expect("read pong");
1064 let message: DevToolsServerMessage = serde_json::from_str(line.trim()).expect("parse pong");
1065 assert_eq!(message, DevToolsServerMessage::Pong);
1066 assert!(commands_rx.try_recv().is_err());
1067 }
1068
1069 #[test]
1070 fn remote_reader_reports_unknown_message() {
1071 let (mut server_client, mut client_stream) = connected_client();
1072 let (commands_tx, commands_rx, _) = command_channel();
1073
1074 client_stream
1075 .write_all(br#"{"type":"unknown"}"#)
1076 .expect("write unknown command");
1077 client_stream.write_all(b"\n").expect("write newline");
1078
1079 assert!(read_client_commands(&mut server_client, &commands_tx));
1080
1081 let mut line = String::new();
1082 let mut reader = BufReader::new(client_stream);
1083 reader.read_line(&mut line).expect("read error");
1084 let message: DevToolsServerMessage =
1085 serde_json::from_str(line.trim()).expect("parse error");
1086 assert!(matches!(message, DevToolsServerMessage::Error { .. }));
1087 assert!(commands_rx.try_recv().is_err());
1088 }
1089
1090 #[test]
1091 fn remote_reader_disconnects_when_input_exceeds_limit() {
1092 let (mut server_client, mut client_stream) = connected_client();
1093 let (commands_tx, commands_rx, _) = command_channel();
1094 server_client.read_buf = "x".repeat(MAX_DEVTOOLS_MESSAGE_BYTES + 1);
1095 client_stream.write_all(b"x").expect("write trigger byte");
1096
1097 assert!(!read_client_commands(&mut server_client, &commands_tx));
1098 assert!(commands_rx.try_recv().is_err());
1099
1100 let mut line = String::new();
1101 let mut reader = BufReader::new(client_stream);
1102 reader.read_line(&mut line).expect("read size error");
1103 let message: DevToolsServerMessage =
1104 serde_json::from_str(line.trim()).expect("parse size error");
1105 assert!(matches!(message, DevToolsServerMessage::Error { .. }));
1106 }
1107
1108 #[test]
1109 fn remote_server_refuses_non_loopback_address() {
1110 let addr = "192.0.2.1:0"
1111 .parse()
1112 .expect("reserved documentation address");
1113 assert!(DevToolsRemote::start(addr).is_none());
1114 }
1115
1116 #[test]
1117 fn remote_command_queued_before_host_wake_is_late_bound_and_drained_once() {
1118 let (commands, receiver, command_wake) = command_channel();
1119 commands.send(DevToolsClientMessage::Select { id: Some(7) });
1120 assert_eq!(command_wake.pending_commands.load(Ordering::Acquire), 1);
1121
1122 let wake = Arc::new(CountingWake::default());
1123 command_wake.install(wake.clone()).unwrap();
1124 assert_eq!(wake.0.load(Ordering::Relaxed), 1);
1125 assert!(command_wake.begin_host_service());
1126
1127 let (events, _) = mpsc::channel();
1128 let remote = DevToolsRemote {
1129 events,
1130 commands: receiver,
1131 command_wake: command_wake.clone(),
1132 };
1133 assert_eq!(
1134 remote.drain_commands(),
1135 vec![DevToolsClientMessage::Select { id: Some(7) }]
1136 );
1137 assert!(!remote.begin_host_service());
1138 assert_eq!(command_wake.pending_commands.load(Ordering::Acquire), 0);
1139 }
1140
1141 #[test]
1142 fn failed_devtools_wake_is_diagnosable_and_replacement_retries_pending_work() {
1143 let (commands, _receiver, command_wake) = command_channel();
1144 commands.send(DevToolsClientMessage::Hover { id: Some(9) });
1145
1146 assert_eq!(
1147 command_wake.install(Arc::new(FailingWake)),
1148 Err(UiWakeError::TargetClosed)
1149 );
1150 assert_eq!(command_wake.take_error(), Some(UiWakeError::TargetClosed));
1151
1152 let wake = Arc::new(CountingWake::default());
1153 command_wake.install(wake.clone()).unwrap();
1154 assert_eq!(wake.0.load(Ordering::Relaxed), 1);
1155 assert!(command_wake.begin_host_service());
1156 }
1157
1158 #[test]
1159 fn devtools_scene_uses_shared_text_system_and_emits_text() {
1160 let (app, mut text_system) = app_runtime();
1161 let mut devtools = DevToolsWindowState::new();
1162 devtools.enabled = true;
1163
1164 let scene = devtools
1165 .build_scene(
1166 &app.tree,
1167 app.root.expect("app root"),
1168 Rect::new(0.0, 0.0, 800.0, 600.0),
1169 Scale::new(1.0),
1170 &mut text_system,
1171 )
1172 .expect("devtools scene");
1173
1174 assert!(
1175 text_cmd_count(&scene) > 0,
1176 "devtools scene should include text draw commands"
1177 );
1178 assert!(
1179 !text_system.face_blobs_snapshot().is_empty(),
1180 "shared text system should contain font blobs for renderer upload"
1181 );
1182 }
1183
1184 #[test]
1185 fn devtools_panel_click_changes_mode() {
1186 let (app, mut text_system) = app_runtime();
1187 let mut devtools = DevToolsWindowState::new();
1188 devtools.enabled = true;
1189 devtools
1190 .build_scene(
1191 &app.tree,
1192 app.root.expect("app root"),
1193 Rect::new(0.0, 0.0, 800.0, 600.0),
1194 Scale::new(1.0),
1195 &mut text_system,
1196 )
1197 .expect("devtools scene");
1198
1199 let pos = center_of_key(&devtools, DEVTOOLS_MODE_BOTTOM_KEY);
1200 assert!(devtools.handle_event(&pointer_button(pos, true)));
1201 assert!(devtools.handle_event(&pointer_button(pos, false)));
1202
1203 assert_eq!(devtools.mode, DevToolsMode::DockBottom);
1204 }
1205
1206 #[test]
1207 fn devtools_click_outside_panel_is_not_consumed() {
1208 let (app, mut text_system) = app_runtime();
1209 let mut devtools = DevToolsWindowState::new();
1210 devtools.enabled = true;
1211 devtools
1212 .build_scene(
1213 &app.tree,
1214 app.root.expect("app root"),
1215 Rect::new(0.0, 0.0, 800.0, 600.0),
1216 Scale::new(1.0),
1217 &mut text_system,
1218 )
1219 .expect("devtools scene");
1220
1221 assert!(!devtools.handle_event(&pointer_button(Point::new(10.0, 580.0), true)));
1222 }
1223}