1#![allow(clippy::missing_safety_doc)]
12
13#[cfg(target_os = "android")]
14pub use imp::*;
15
16#[cfg(target_os = "android")]
21mod controls;
22
23#[cfg(test)]
24mod bridge_kinds_parity {
25 #[test]
26 fn java_constants_match_the_rust_enum() {
27 use day_spec::bridge::BridgeKind;
28 let java = include_str!("../java/dev/daybrite/day/bridge/DayBridge.java");
29 let mut found = std::collections::BTreeMap::new();
30 for line in java.lines() {
31 let line = line.trim();
32 if let Some(rest) = line.strip_prefix("public static final int K_")
33 && let Some((name, value)) = rest.split_once(" = ")
34 {
35 let value: i32 = value
36 .trim_end_matches(';')
37 .parse()
38 .unwrap_or_else(|_| panic!("unparsable K_{name} line: {line}"));
39 assert!(
40 found.insert(format!("K_{name}"), value).is_none(),
41 "duplicate Java constant K_{name}"
42 );
43 }
44 }
45 let expect = [
46 ("K_PRESSED", BridgeKind::Pressed),
47 ("K_REFRESH_REQUESTED", BridgeKind::RefreshRequested),
48 ("K_TEXT_CHANGED", BridgeKind::TextChanged),
49 ("K_TOGGLE_CHANGED", BridgeKind::ToggleChanged),
50 ("K_VALUE_CHANGED", BridgeKind::ValueChanged),
51 ("K_VALUE_COMMITTED", BridgeKind::ValueCommitted),
52 ("K_SEARCH_CHANGED", BridgeKind::SearchChanged),
53 ("K_NAV_PRESENTATION", BridgeKind::NavPresentation),
54 ("K_SELECTION_CHANGED", BridgeKind::SelectionChanged),
55 ("K_LIST_ACTIVATED", BridgeKind::ListActivated),
56 ("K_NAV_BACK", BridgeKind::NavBack),
57 ("K_FRAME_CHANGED", BridgeKind::FrameChanged),
58 ("K_DEEPLINK", BridgeKind::Deeplink),
59 ("K_DOCUMENT_OPENED", BridgeKind::DocumentOpened),
60 ("K_SHARED_TEXT", BridgeKind::SharedText),
61 ("K_PRESENT_BUTTON", BridgeKind::PresentButton),
62 ("K_PRESENT_TEXT", BridgeKind::PresentText),
63 ("K_PRESENT_DISMISSED", BridgeKind::PresentDismissed),
64 ("K_GESTURE", BridgeKind::Gesture),
65 ("K_CUSTOM", BridgeKind::Custom),
66 ("K_MENU_ACTION", BridgeKind::MenuAction),
67 ("K_LIFECYCLE", BridgeKind::Lifecycle),
68 ("K_PRESENT_FILE", BridgeKind::PresentFile),
69 ("K_FOCUS_CHANGED", BridgeKind::FocusChanged),
70 ("K_SUBMITTED", BridgeKind::Submitted),
71 ("K_WINDOW_RESIZED", BridgeKind::WindowResized),
72 ("K_SAFE_AREA", BridgeKind::SafeArea),
73 ("K_WINDOW_CLOSED", BridgeKind::WindowClosed),
76 ("K_WINDOW_FOCUSED", BridgeKind::WindowFocused),
77 ("K_APPEARANCE_CHANGED", BridgeKind::AppearanceChanged),
79 ("K_REDUCE_MOTION_CHANGED", BridgeKind::ReduceMotionChanged),
80 ("K_COVER_HIDDEN", BridgeKind::CoverHidden),
81 ("K_LINK_ACTIVATED", BridgeKind::LinkActivated),
82 ("K_TOOLBAR_CHANGED", BridgeKind::ToolbarChanged),
83 ("K_KEY", BridgeKind::Key),
84 ("K_TEXT", BridgeKind::Text),
85 ("K_WINDOW_STATE_CHANGED", BridgeKind::WindowStateChanged),
86 ];
87 assert_eq!(
88 found.len(),
89 expect.len(),
90 "Java K_* count differs from the enum: {found:?}"
91 );
92 for (name, kind) in expect {
93 assert_eq!(
94 found.get(name).copied(),
95 Some(kind as i32),
96 "{name} drifted from BridgeKind::{kind:?}"
97 );
98 }
99 }
100}
101
102#[cfg(target_os = "android")]
103mod picker;
104#[cfg(target_os = "android")]
105mod textarea;
106
107#[cfg(any(target_os = "android", test))]
109fn argb_u32(c: day_spec::Color) -> u32 {
110 let ch = |x: f64| (x.clamp(0.0, 1.0) * 255.0).round() as u32;
111 (ch(c.a) << 24) | (ch(c.r) << 16) | (ch(c.g) << 8) | ch(c.b)
112}
113
114#[cfg(any(target_os = "android", test))]
118fn is_styled_surface(p: &day_spec::props::ContainerProps) -> bool {
119 p.fill
120 .as_ref()
121 .is_some_and(|f| !matches!(f, day_spec::Paint::Solid(_)))
122 || p.border.is_some()
123 || p.shadow.is_some()
124 || (p.corner_radius > 0.0 && p.corners != day_spec::Corners::ALL)
125}
126
127#[cfg(any(target_os = "android", test))]
129const SURFACE_HEADER: usize = 18;
130
131#[cfg(any(target_os = "android", test))]
138fn surface_spec(p: &day_spec::props::ContainerProps, density: f64) -> Vec<f64> {
139 let color = |c: day_spec::Ink| f64::from(argb_u32(c.resolved()));
140 let background = solid_fill(p.fill.as_ref());
141 let radii = p.corners.radii(p.corner_radius.max(0.0) * density);
142 let mut spec = vec![
143 f64::from(u8::from(background.is_some())),
144 background.map_or(0.0, |c| f64::from(argb_u32(c))),
145 radii.top_left,
146 radii.top_right,
147 radii.bottom_right,
148 radii.bottom_left,
149 ];
150 let border = p.border.filter(|b| b.width > 0.0);
152 spec.extend([
153 border.map_or(0.0, |b| color(b.color)),
154 border.map_or(0.0, |b| b.width * density),
155 ]);
156 let shadow = p.shadow;
157 spec.extend([
158 shadow.map_or(0.0, |s| color(s.color)),
159 shadow.map_or(0.0, |s| s.blur.max(0.0) * density),
160 shadow.map_or(0.0, |s| s.dx * density),
161 shadow.map_or(0.0, |s| s.dy * density),
162 ]);
163 spec.extend(gradient_spec(p.fill.as_ref()));
164 spec
165}
166
167#[cfg(any(target_os = "android", test))]
173fn gradient_spec(fill: Option<&day_spec::Paint>) -> Vec<f64> {
174 use day_spec::Paint;
175 let (kind, geometry, stops) = match fill {
176 Some(Paint::Linear(g)) => (0.0, [g.start.x, g.start.y, g.end.x, g.end.y], &g.stops),
177 Some(Paint::Radial(g)) => (1.0, [g.center.x, g.center.y, g.radius, 0.0], &g.stops),
178 Some(Paint::Conic(g)) => (
179 2.0,
180 [g.center.x, g.center.y, g.start.degrees(), 0.0],
181 &g.stops,
182 ),
183 Some(Paint::Solid(_)) | None => return vec![0.0; SURFACE_HEADER - 12],
184 };
185 if stops.is_empty() {
186 return vec![0.0; SURFACE_HEADER - 12];
187 }
188 let mut spec = vec![stops.len() as f64, kind];
189 spec.extend(geometry);
190 for (offset, c) in day_spec::resolved_stops(stops) {
191 spec.extend([offset.clamp(0.0, 1.0), f64::from(argb_u32(c))]);
192 }
193 spec
194}
195
196#[cfg(any(target_os = "android", test))]
199fn solid_fill(fill: Option<&day_spec::Paint>) -> Option<day_spec::Color> {
200 match fill {
201 Some(day_spec::Paint::Solid(ink)) => Some(ink.resolved()),
202 _ => None,
203 }
204}
205
206#[cfg(test)]
207mod surface_spec_tests {
208 use super::{is_styled_surface, surface_spec};
209 use day_spec::props::ContainerProps;
210 use day_spec::{
211 Angle, Border, Color, ConicGradient, Corners, LinearGradient, RadialGradient, Shadow,
212 UnitPoint,
213 };
214
215 #[test]
216 fn plain_surfaces_keep_the_drawable_path() {
217 let plain = ContainerProps {
218 fill: Some(Color::rgb(1.0, 0.0, 0.0).into()),
219 corner_radius: 8.0,
220 clips: true,
221 ..Default::default()
222 };
223 assert!(!is_styled_surface(&plain));
224 let square = ContainerProps {
226 corners: Corners::TOP,
227 ..Default::default()
228 };
229 assert!(!is_styled_surface(&square));
230 for styled in [
231 ContainerProps {
232 corner_radius: 8.0,
233 corners: Corners::TOP,
234 ..Default::default()
235 },
236 ContainerProps {
237 border: Some(Border::new(Color::rgb(0.0, 0.0, 0.0), 1.0)),
238 ..Default::default()
239 },
240 ContainerProps {
241 shadow: Some(Shadow::new(Color::rgb(0.0, 0.0, 0.0), 4.0)),
242 ..Default::default()
243 },
244 ContainerProps {
245 fill: Some(
246 LinearGradient::vertical(Color::rgb(1.0, 0.0, 0.0), Color::rgb(0.0, 0.0, 1.0))
247 .into(),
248 ),
249 ..Default::default()
250 },
251 ] {
252 assert!(is_styled_surface(&styled), "{styled:?}");
253 }
254 }
255
256 #[test]
257 fn lengths_scale_and_corners_select() {
258 let p = ContainerProps {
259 fill: Some(Color::rgba(0.0, 0.0, 1.0, 1.0).into()),
260 corner_radius: 10.0,
261 corners: Corners::TOP_LEFT | Corners::BOTTOM_RIGHT,
262 border: Some(Border::new(Color::rgb(1.0, 0.0, 0.0), 2.0)),
263 shadow: Some(Shadow::new(Color::rgba(0.0, 0.0, 0.0, 0.5), 4.0).offset(1.0, -3.0)),
264 ..Default::default()
265 };
266 let spec = surface_spec(&p, 2.0);
267 assert_eq!(spec.len(), super::SURFACE_HEADER);
268 assert_eq!(spec[0], 1.0);
269 assert_eq!(spec[1], f64::from(0xFF00_00FF_u32));
270 assert_eq!(&spec[2..6], &[20.0, 0.0, 20.0, 0.0]);
271 assert_eq!(spec[6], f64::from(0xFFFF_0000_u32));
272 assert_eq!(spec[7], 4.0);
273 assert_eq!(spec[8], f64::from(0x8000_0000_u32));
274 assert_eq!(&spec[9..12], &[8.0, 2.0, -6.0]);
275 assert_eq!(spec[12], 0.0);
276 }
277
278 #[test]
279 fn gradient_stops_follow_the_header() {
280 let p = ContainerProps {
281 fill: Some(
282 LinearGradient::vertical(Color::rgb(1.0, 0.0, 0.0), Color::rgb(0.0, 0.0, 1.0))
283 .into(),
284 ),
285 border: Some(Border::new(Color::rgb(1.0, 0.0, 0.0), 0.0)),
287 ..Default::default()
288 };
289 let spec = surface_spec(&p, 3.0);
290 assert_eq!(spec[0], 0.0);
291 assert_eq!(&spec[6..8], &[0.0, 0.0]);
292 assert_eq!(spec[8], 0.0);
293 assert_eq!(&spec[12..14], &[2.0, 0.0]);
294 assert_eq!(&spec[14..18], &[0.5, 0.0, 0.5, 1.0]);
296 assert_eq!(
297 &spec[18..],
298 &[
299 0.0,
300 f64::from(0xFFFF_0000_u32),
301 1.0,
302 f64::from(0xFF00_00FF_u32)
303 ]
304 );
305 }
306
307 #[test]
308 fn radial_and_conic_fills_carry_their_geometry() {
309 let radial = ContainerProps {
310 fill: Some(
311 RadialGradient::new(
312 UnitPoint::new(0.25, 0.75),
313 0.5,
314 [
315 (0.0, Color::rgb(1.0, 0.0, 0.0)),
316 (1.0, Color::rgb(0.0, 0.0, 1.0)),
317 ],
318 )
319 .into(),
320 ),
321 ..Default::default()
322 };
323 assert!(is_styled_surface(&radial));
324 let spec = surface_spec(&radial, 2.0);
325 assert_eq!(&spec[12..18], &[2.0, 1.0, 0.25, 0.75, 0.5, 0.0]);
326 let conic = ContainerProps {
327 fill: Some(
328 ConicGradient::centered(
329 Angle::rad(std::f64::consts::FRAC_PI_2),
330 [
331 (0.0, Color::rgb(1.0, 0.0, 0.0)),
332 (1.0, Color::rgb(0.0, 0.0, 1.0)),
333 ],
334 )
335 .into(),
336 ),
337 ..Default::default()
338 };
339 assert!(is_styled_surface(&conic));
340 let spec = surface_spec(&conic, 2.0);
341 assert_eq!(&spec[12..14], &[2.0, 2.0]);
342 assert_eq!(&spec[14..16], &[0.5, 0.5]);
343 assert!((spec[16] - 90.0).abs() < 1e-9);
344 assert_eq!(spec.len(), super::SURFACE_HEADER + 4);
345 }
346
347 #[test]
348 fn inks_resolve_against_the_current_palette() {
349 use day_spec::{Ink, Palette};
350 let pair = Ink::adaptive(Color::rgb(1.0, 0.0, 0.0), Color::rgb(0.0, 0.0, 1.0));
351 let p = ContainerProps {
352 fill: Some(pair.into()),
353 border: Some(Border::new(pair, 1.0)),
354 ..Default::default()
355 };
356 Palette::set_current(Palette::fallback(true));
357 let dark = surface_spec(&p, 1.0);
358 Palette::set_current(Palette::fallback(false));
359 let light = surface_spec(&p, 1.0);
360 assert_eq!(dark[1], f64::from(0xFF00_00FF_u32));
361 assert_eq!(dark[6], f64::from(0xFF00_00FF_u32));
362 assert_eq!(light[1], f64::from(0xFFFF_0000_u32));
363 assert_eq!(light[6], f64::from(0xFFFF_0000_u32));
364 }
365}
366
367#[cfg(any(target_os = "android", test))]
372mod gesture_wire {
373 pub const TAP: i32 = 0;
374 pub const DRAG_BEGAN: i32 = 1;
375 pub const DRAG_CHANGED: i32 = 2;
376 pub const DRAG_ENDED: i32 = 3;
377 pub const ROTATE_BEGAN: i32 = 13;
378 pub const ROTATE_CHANGED: i32 = 14;
379 pub const ROTATE_ENDED: i32 = 15;
380 pub const PINCH_BEGAN: i32 = 16;
381 pub const PINCH_CHANGED: i32 = 17;
382 pub const PINCH_ENDED: i32 = 18;
383 pub const PAN: i32 = 19;
384 pub const HOVER_BEGAN: i32 = 20;
385 pub const HOVER_CHANGED: i32 = 21;
386 pub const HOVER_ENDED: i32 = 22;
387}
388
389#[cfg(any(target_os = "android", test))]
394fn gesture_event(code: i32, text: &str, density: f64) -> Option<day_spec::Event> {
395 use day_spec::bridge::gesture as shared;
396 use day_spec::{DragPhase, Event, GestureKind, Point, PointerKind};
397 use gesture_wire as own;
398 match code {
399 shared::POINTER_KIND => return PointerKind::from_name(text).map(Event::PointerKindChanged),
400 shared::TOUCHES => return touches(text, density).map(Event::Touches),
401 _ => {}
402 }
403 let p: Vec<f64> = text
404 .split(',')
405 .filter_map(|s| s.trim().parse().ok())
406 .collect();
407 if p.len() < 2 {
408 return None;
409 }
410 let at = Point::new(p[0] / density, p[1] / density);
411 match code {
412 shared::LONG_PRESS => return Some(Event::LongPress(at)),
413 shared::DOUBLE_TAP => return Some(Event::DoubleTap(at)),
414 shared::PRESS_IN | shared::PRESS_OUT => {
415 return Some(Event::Press {
416 pressed: code == shared::PRESS_IN,
417 location: at,
418 });
419 }
420 shared::DRAG_VELOCITY | shared::PAN_VELOCITY => {
422 let kind = if code == shared::DRAG_VELOCITY {
423 GestureKind::Drag
424 } else {
425 GestureKind::Pan
426 };
427 return Some(Event::GestureVelocity { kind, velocity: at });
428 }
429 _ => {}
430 }
431 if p.len() < 4 {
432 return None;
433 }
434 let tr = Point::new(p[2] / density, p[3] / density);
435 let phase = |began, ended| {
436 if code == began {
437 DragPhase::Began
438 } else if code == ended {
439 DragPhase::Ended
440 } else {
441 DragPhase::Changed
442 }
443 };
444 Some(match code {
445 own::TAP => Event::Tap(at),
446 own::DRAG_BEGAN | own::DRAG_CHANGED | own::DRAG_ENDED => Event::Drag {
449 phase: phase(own::DRAG_BEGAN, own::DRAG_ENDED),
450 location: at,
451 translation: tr,
452 },
453 own::PINCH_BEGAN | own::PINCH_CHANGED | own::PINCH_ENDED => Event::Pinch {
456 phase: phase(own::PINCH_BEGAN, own::PINCH_ENDED),
457 scale: p[2],
458 location: at,
459 },
460 own::ROTATE_BEGAN | own::ROTATE_CHANGED | own::ROTATE_ENDED => Event::Rotate {
463 phase: phase(own::ROTATE_BEGAN, own::ROTATE_ENDED),
464 rotation: p[2],
465 location: at,
466 },
467 own::PAN => Event::Pan {
468 phase: DragPhase::Changed,
469 location: at,
470 delta: tr,
471 },
472 own::HOVER_BEGAN | own::HOVER_CHANGED | own::HOVER_ENDED => Event::Hover {
475 phase: phase(own::HOVER_BEGAN, own::HOVER_ENDED),
476 location: at,
477 },
478 _ => return None,
479 })
480}
481
482#[cfg(any(target_os = "android", test))]
485fn touches(text: &str, density: f64) -> Option<Vec<day_spec::Touch>> {
486 use day_spec::{Point, PointerKind, Touch, TouchPhase};
487 let list: Vec<Touch> = text
488 .split(';')
489 .filter_map(|contact| {
490 let f: Vec<f64> = contact
491 .split(',')
492 .map(|s| s.trim().parse().ok())
493 .collect::<Option<_>>()?;
494 let [id, phase, x, y, pressure, kind] = f[..] else {
495 return None;
496 };
497 let phase = match phase as i32 {
498 0 => TouchPhase::Began,
499 1 => TouchPhase::Moved,
500 2 => TouchPhase::Stationary,
501 3 => TouchPhase::Ended,
502 _ => TouchPhase::Cancelled,
503 };
504 let kind = match kind as i32 {
505 1 => PointerKind::Mouse,
506 2 => PointerKind::Stylus,
507 _ => PointerKind::Touch,
508 };
509 Some(
510 Touch::new(
511 id.max(0.0) as u64,
512 phase,
513 Point::new(x / density, y / density),
514 )
515 .with_pressure(pressure)
516 .with_kind(kind),
517 )
518 })
519 .collect();
520 (!list.is_empty()).then_some(list)
521}
522
523#[cfg(any(target_os = "android", test))]
526fn key_event(typed: bool, name: String, num: f64) -> day_spec::KeyEvent {
527 let mods = ((num as u32) & 0xff) as u8;
528 let event = if typed {
529 day_spec::KeyEvent::typed_text(name, mods)
530 } else {
531 day_spec::KeyEvent::named(name, mods)
532 };
533 event.with_phase(day_spec::KeyPhase::from_wire(num))
534}
535
536#[cfg(test)]
537mod input_wire_tests {
538 use super::{gesture_event, gesture_wire, key_event};
539 use day_spec::bridge::gesture;
540 use day_spec::{
541 DragPhase, Event, GestureKind, Key, KeyPhase, Modifiers, Point, PointerKind, TouchPhase,
542 };
543
544 #[test]
546 fn gesture_codes_parity() {
547 let java = include_str!("../java/dev/daybrite/day/bridge/DayBridge.java");
548 let mut found = std::collections::BTreeMap::new();
549 for line in java.lines() {
550 if let Some(rest) = line.trim().strip_prefix("static final int G_")
551 && let Some((name, value)) = rest.split_once(" = ")
552 {
553 let value: i32 = value.trim_end_matches(';').parse().expect("a number");
554 assert!(
555 found.insert(name.to_owned(), value).is_none(),
556 "G_{name} twice"
557 );
558 }
559 }
560 let expect = [
561 ("TAP", gesture_wire::TAP),
562 ("DRAG_BEGAN", gesture_wire::DRAG_BEGAN),
563 ("DRAG_CHANGED", gesture_wire::DRAG_CHANGED),
564 ("DRAG_ENDED", gesture_wire::DRAG_ENDED),
565 ("LONG_PRESS", gesture::LONG_PRESS),
566 ("DOUBLE_TAP", gesture::DOUBLE_TAP),
567 ("PRESS_IN", gesture::PRESS_IN),
568 ("PRESS_OUT", gesture::PRESS_OUT),
569 ("TOUCHES", gesture::TOUCHES),
570 ("DRAG_VELOCITY", gesture::DRAG_VELOCITY),
571 ("POINTER_KIND", gesture::POINTER_KIND),
572 ("ROTATE_BEGAN", gesture_wire::ROTATE_BEGAN),
573 ("ROTATE_CHANGED", gesture_wire::ROTATE_CHANGED),
574 ("ROTATE_ENDED", gesture_wire::ROTATE_ENDED),
575 ("PINCH_BEGAN", gesture_wire::PINCH_BEGAN),
576 ("PINCH_CHANGED", gesture_wire::PINCH_CHANGED),
577 ("PINCH_ENDED", gesture_wire::PINCH_ENDED),
578 ("PAN", gesture_wire::PAN),
579 ("HOVER_BEGAN", gesture_wire::HOVER_BEGAN),
580 ("HOVER_CHANGED", gesture_wire::HOVER_CHANGED),
581 ("HOVER_ENDED", gesture_wire::HOVER_ENDED),
582 ];
583 assert_eq!(found.len(), expect.len(), "{found:?}");
584 let mut codes = std::collections::BTreeSet::new();
585 for (name, code) in expect {
586 assert_eq!(found.get(name), Some(&code), "G_{name}");
587 assert!(codes.insert(code), "G_{name} collides with another code");
588 }
589 assert!(!codes.contains(&gesture::PAN_VELOCITY));
591 }
592
593 fn p(x: f64, y: f64) -> Point {
594 Point::new(x, y)
595 }
596
597 #[test]
598 fn shared_gestures_decode_in_points() {
599 let d = 2.0;
600 assert_eq!(
601 gesture_event(gesture::LONG_PRESS, "20,40", d),
602 Some(Event::LongPress(p(10.0, 20.0)))
603 );
604 assert_eq!(
605 gesture_event(gesture::DOUBLE_TAP, "2,4", d),
606 Some(Event::DoubleTap(p(1.0, 2.0)))
607 );
608 assert_eq!(
609 gesture_event(gesture::PRESS_IN, "2,4", d),
610 Some(Event::Press {
611 pressed: true,
612 location: p(1.0, 2.0)
613 })
614 );
615 assert_eq!(
616 gesture_event(gesture::PRESS_OUT, "-2,4", d),
617 Some(Event::Press {
618 pressed: false,
619 location: p(-1.0, 2.0)
620 })
621 );
622 assert_eq!(
623 gesture_event(gesture::DRAG_VELOCITY, "1200,-1600", d),
624 Some(Event::GestureVelocity {
625 kind: GestureKind::Drag,
626 velocity: p(600.0, -800.0)
627 })
628 );
629 assert_eq!(
630 gesture_event(gesture::POINTER_KIND, "stylus", d),
631 Some(Event::PointerKindChanged(PointerKind::Stylus))
632 );
633 assert_eq!(gesture_event(gesture::POINTER_KIND, "pen", d), None);
634 assert_eq!(gesture_event(gesture::LONG_PRESS, "2", d), None);
635 }
636
637 #[test]
638 fn own_gestures_keep_their_meaning() {
639 let d = 2.0;
640 assert_eq!(
641 gesture_event(gesture_wire::TAP, "4,6,0,0", d),
642 Some(Event::Tap(p(2.0, 3.0)))
643 );
644 assert_eq!(
646 gesture_event(gesture_wire::DRAG_BEGAN, "30,10,20,2", d),
647 Some(Event::Drag {
648 phase: DragPhase::Began,
649 location: p(15.0, 5.0),
650 translation: p(10.0, 1.0)
651 })
652 );
653 assert!(matches!(
654 gesture_event(gesture_wire::DRAG_CHANGED, "0,0,2,2", d),
655 Some(Event::Drag {
656 phase: DragPhase::Changed,
657 ..
658 })
659 ));
660 assert_eq!(
661 gesture_event(gesture_wire::PINCH_ENDED, "10,10,1.5,0", d),
662 Some(Event::Pinch {
663 phase: DragPhase::Ended,
664 scale: 1.5,
665 location: p(5.0, 5.0)
666 })
667 );
668 assert_eq!(
669 gesture_event(gesture_wire::ROTATE_BEGAN, "10,10,0,0", d),
670 Some(Event::Rotate {
671 phase: DragPhase::Began,
672 rotation: 0.0,
673 location: p(5.0, 5.0)
674 })
675 );
676 assert_eq!(
677 gesture_event(gesture_wire::PAN, "0,0,8,-4", d),
678 Some(Event::Pan {
679 phase: DragPhase::Changed,
680 location: p(0.0, 0.0),
681 delta: p(4.0, -2.0)
682 })
683 );
684 assert_eq!(
685 gesture_event(gesture_wire::HOVER_ENDED, "2,2,0,0", d),
686 Some(Event::Hover {
687 phase: DragPhase::Ended,
688 location: p(1.0, 1.0)
689 })
690 );
691 assert_eq!(gesture_event(12, "0,0,0,0", d), None);
692 }
693
694 #[test]
695 fn touches_list_every_contact() {
696 let Some(Event::Touches(list)) =
697 gesture_event(gesture::TOUCHES, "0,2,10,20,1,0;3,3,40,60,0.5,2", 2.0)
698 else {
699 panic!("a touch list");
700 };
701 assert_eq!(list.len(), 2);
702 assert_eq!((list[0].id, list[0].phase), (0, TouchPhase::Stationary));
703 assert_eq!(list[0].location, p(5.0, 10.0));
704 assert_eq!(list[0].kind, PointerKind::Touch);
705 assert_eq!((list[1].id, list[1].phase), (3, TouchPhase::Ended));
706 assert!(!list[1].is_down());
707 assert!((list[1].pressure - 0.5).abs() < f64::EPSILON);
708 assert_eq!(list[1].kind, PointerKind::Stylus);
709 assert_eq!(gesture_event(gesture::TOUCHES, "", 2.0), None);
710 assert_eq!(gesture_event(gesture::TOUCHES, "1,2,3", 2.0), None);
711 }
712
713 #[test]
714 fn key_phases_ride_above_the_modifiers() {
715 let shift = f64::from(Modifiers::SHIFT.bits());
716 let down = key_event(false, "ArrowRight".into(), shift);
717 assert_eq!(down.key, Key::ArrowRight);
718 assert_eq!(down.phase, KeyPhase::Down);
719 assert!(down.modifiers.shift());
720 let repeat = key_event(true, "a".into(), 256.0 + shift);
721 assert_eq!(repeat.phase, KeyPhase::Repeat);
722 assert_eq!(repeat.text.as_deref(), Some("a"));
723 assert!(repeat.modifiers.shift());
724 let up = key_event(false, "5".into(), 512.0);
725 assert_eq!(up.phase, KeyPhase::Up);
726 assert_eq!(up.modifiers, Modifiers::NONE);
727 assert_eq!(up.text, None);
728 }
729}
730
731#[cfg(any(target_os = "android", test))]
734mod text_wire {
735 use day_spec::props::{TextAlign, Truncation};
736 use day_spec::{Decoration, DecorationStyle, FontSpec, TextRun};
737
738 pub const BOLD: i32 = 1;
740 pub const ITALIC: i32 = 2;
741 pub const MONOSPACE: i32 = 4;
742 pub const STRIKE: i32 = 8;
744 pub const COLOR: i32 = 16;
745 pub const BACKGROUND: i32 = 32;
746 pub const UNDERLINE: i32 = 64;
748 pub const SMALL_CAPS: i32 = 1024;
749 pub const OLDSTYLE: i32 = 2048;
750 pub const TABULAR: i32 = 4096;
751
752 pub const DECO_STRIDE: usize = 5;
755 const DECO_STRIKE: i32 = 1;
756 const DECO_COLORED: i32 = 8;
757
758 pub const SELECTION_PREFIX: &str = "day:text-selected:";
760
761 pub fn run_flags(r: &TextRun) -> i32 {
763 let mut f = 0;
764 if r.font
765 .weight
766 .is_some_and(|w| w >= day_spec::FontWeight::Semibold)
767 {
768 f |= BOLD;
769 }
770 if r.font.italic {
771 f |= ITALIC;
772 }
773 if r.font.monospace {
774 f |= MONOSPACE;
775 }
776 if r.strikethrough.is_some_and(|d| natively_drawn(&d)) {
777 f |= STRIKE;
778 }
779 if r.color.is_some() {
780 f |= COLOR;
781 }
782 if r.background.is_some() {
783 f |= BACKGROUND;
784 }
785 if r.underline.is_some_and(|d| natively_drawn(&d)) {
786 f |= UNDERLINE;
787 }
788 if r.font.small_caps {
789 f |= SMALL_CAPS;
790 }
791 if r.font.oldstyle_figures {
792 f |= OLDSTYLE;
793 }
794 if r.font.tabular {
795 f |= TABULAR;
796 }
797 f
798 }
799
800 fn natively_drawn(d: &Decoration) -> bool {
802 d.style == DecorationStyle::Single && d.color.is_none()
803 }
804
805 pub fn decoration_entries(r: &TextRun, start: i32, end: i32, out: &mut Vec<i32>) {
808 let scale = (r.font.scale * 1000.0).round() as i32;
809 for (deco, strike) in [(r.underline, false), (r.strikethrough, true)] {
810 let Some(d) = deco else { continue };
811 if natively_drawn(&d) {
812 continue;
813 }
814 let style = match d.style {
815 DecorationStyle::Single => 0,
816 DecorationStyle::Double => 1,
817 DecorationStyle::Dotted => 2,
818 DecorationStyle::Wavy => 3,
819 };
820 let color = d.color.or(r.color);
823 let mut info = style << 1;
824 if strike {
825 info |= DECO_STRIKE;
826 }
827 if color.is_some() {
828 info |= DECO_COLORED;
829 }
830 let entry: [i32; DECO_STRIDE] = [
831 start,
832 end,
833 info,
834 color.map_or(0, |c| super::argb_u32(c.resolved()) as i32),
835 scale,
836 ];
837 out.extend_from_slice(&entry);
838 }
839 }
840
841 pub fn features(spec: &FontSpec) -> Option<String> {
843 let tags = spec.feature_tags();
844 (!tags.is_empty()).then(|| tags.join(","))
845 }
846
847 pub fn truncation_code(t: Truncation) -> i32 {
849 match t {
850 Truncation::Tail => 0,
851 Truncation::Head => 1,
852 Truncation::Middle => 2,
853 }
854 }
855
856 pub fn align_code(a: TextAlign) -> i32 {
858 match a {
859 TextAlign::Leading => 0,
860 TextAlign::Center => 1,
861 TextAlign::Trailing => 2,
862 TextAlign::Justified => 3,
863 }
864 }
865
866 pub fn paragraph_args(p: &day_spec::props::LabelParagraph) -> (i32, i32, f32, f32) {
869 let finite = |v: f64, positive: bool| {
870 if !v.is_finite() || (positive && v <= 0.0) {
871 0.0
872 } else {
873 v as f32
874 }
875 };
876 (
877 p.max_lines.min(i32::MAX as u32) as i32,
878 truncation_code(p.truncation),
879 finite(p.letter_spacing, false),
880 finite(p.line_height, true),
881 )
882 }
883
884 pub fn selection(payload: &str) -> Option<(usize, usize)> {
887 let (a, b) = payload.split_once(',')?;
888 let (a, b): (usize, usize) = (a.trim().parse().ok()?, b.trim().parse().ok()?);
889 Some((a.min(b), a.max(b)))
890 }
891}
892
893#[cfg(test)]
894mod text_wire_tests {
895 use super::text_wire::{
896 DECO_STRIDE, OLDSTYLE, SMALL_CAPS, STRIKE, TABULAR, UNDERLINE, align_code,
897 decoration_entries, features, paragraph_args, run_flags, selection,
898 };
899 use day_spec::props::{LabelParagraph, TextAlign, Truncation};
900 use day_spec::{Color, Decoration, DecorationStyle, FontSpec, TextRun};
901
902 fn run(underline: Option<Decoration>, strikethrough: Option<Decoration>) -> TextRun {
903 TextRun {
904 range: 0..3,
905 underline,
906 strikethrough,
907 ..TextRun::default()
908 }
909 }
910
911 #[test]
912 fn plain_lines_stay_native_spans() {
913 let r = run(Some(Decoration::SINGLE), Some(Decoration::SINGLE));
914 assert_eq!(run_flags(&r) & (UNDERLINE | STRIKE), UNDERLINE | STRIKE);
915 let mut out = Vec::new();
916 decoration_entries(&r, 0, 3, &mut out);
917 assert_eq!(out, Vec::<i32>::new());
918 }
919
920 #[test]
923 fn java_side_parity() {
924 let label = include_str!("../java/dev/daybrite/day/bridge/DayLabel.java");
925 assert!(label.contains(&format!("DECO_STRIDE = {DECO_STRIDE};")));
926 assert!(label.contains(&format!("\"{}\"", super::text_wire::SELECTION_PREFIX)));
927 let bridge = include_str!("../java/dev/daybrite/day/bridge/DayBridge.java");
928 for (bit, tag) in [(TABULAR, "tnum"), (SMALL_CAPS, "smcp"), (OLDSTYLE, "onum")] {
929 assert!(
930 bridge.contains(&format!("(f & {bit}) != 0 ? \"{tag},\"")),
931 "{tag} is bit {bit}"
932 );
933 }
934 }
935
936 #[test]
937 fn styled_and_colored_lines_are_drawn() {
938 let red = Color::hex(0x00D0_021B);
939 let r = run(
940 Some(Decoration::wavy().color(red)),
941 Some(Decoration::from(DecorationStyle::Double)),
942 );
943 assert_eq!(run_flags(&r) & (UNDERLINE | STRIKE), 0);
944 let mut out = Vec::new();
945 decoration_entries(&r, 2, 9, &mut out);
946 assert_eq!(out.len(), 2 * DECO_STRIDE);
947 assert_eq!(&out[..3], &[2, 9, (3 << 1) | 8]);
949 assert_eq!(out[3], super::argb_u32(red) as i32);
950 assert_eq!(out[4], 1000);
951 assert_eq!(&out[5..8], &[2, 9, (1 << 1) | 1]);
953 let colored = run(Some(Decoration::SINGLE.color(red)), None);
955 let mut out = Vec::new();
956 decoration_entries(&colored, 0, 3, &mut out);
957 assert_eq!(out[2], 8);
958 }
959
960 #[test]
961 fn features_follow_the_tags() {
962 let mut f = FontSpec::default();
963 assert_eq!(features(&f), None);
964 f.small_caps = true;
965 f.oldstyle_figures = true;
966 f.tabular = true;
967 assert_eq!(features(&f).as_deref(), Some("tnum,smcp,onum"));
968 let r = TextRun {
969 font: f,
970 ..TextRun::default()
971 };
972 assert_eq!(
973 run_flags(&r) & (SMALL_CAPS | OLDSTYLE),
974 SMALL_CAPS | OLDSTYLE
975 );
976 }
977
978 #[test]
979 fn paragraph_and_alignment_codes() {
980 let p = LabelParagraph {
981 max_lines: 2,
982 truncation: Truncation::Middle,
983 letter_spacing: -0.02,
984 line_height: f64::NAN,
985 };
986 assert_eq!(paragraph_args(&p), (2, 2, -0.02, 0.0));
987 let p = LabelParagraph {
988 line_height: -1.0,
989 letter_spacing: f64::INFINITY,
990 ..LabelParagraph::default()
991 };
992 assert_eq!(paragraph_args(&p), (0, 0, 0.0, 0.0));
993 assert_eq!(align_code(TextAlign::Justified), 3);
994 assert_eq!(align_code(TextAlign::Leading), 0);
995 }
996
997 #[test]
998 fn selection_reports_parse() {
999 assert_eq!(selection("3,9"), Some((3, 9)));
1000 assert_eq!(selection("9,3"), Some((3, 9)));
1001 assert_eq!(selection("0,0"), Some((0, 0)));
1002 assert_eq!(selection("x,1"), None);
1003 assert_eq!(selection("4"), None);
1004 }
1005}
1006
1007#[cfg(any(target_os = "android", test))]
1011mod list_wire {
1012 use day_spec::props::ScrollSnap;
1013 use day_spec::props::{KeyboardDismiss, KeyboardTaps, RowDelta, ScrollIndicators, ScrollProps};
1014 use day_spec::{ListViewport, Point, RowAlign, ScrollPhase};
1015
1016 pub const SPLICE_INSERT: i32 = 0;
1019 pub const SPLICE_REMOVE: i32 = 1;
1020 pub const SPLICE_MOVE: i32 = 2;
1021
1022 pub fn splice_ops(deltas: &[RowDelta]) -> Vec<i32> {
1027 let mut ops: Vec<i32> = Vec::with_capacity(deltas.len().min(64) * 3);
1028 for delta in deltas {
1029 let n = ops.len();
1030 let last = (n >= 3).then(|| (ops[n - 3], ops[n - 2], ops[n - 1]));
1031 match *delta {
1032 RowDelta::Insert(at) => {
1033 let at = to_i32(at);
1034 if let Some((SPLICE_INSERT, start, count)) = last
1037 && (start..=start + count).contains(&at)
1038 {
1039 ops[n - 1] += 1;
1040 } else {
1041 ops.extend([SPLICE_INSERT, at, 1]);
1042 }
1043 }
1044 RowDelta::Remove(at) => {
1045 let at = to_i32(at);
1046 match last {
1047 Some((SPLICE_REMOVE, start, _)) if at == start => ops[n - 1] += 1,
1049 Some((SPLICE_REMOVE, start, _)) if at + 1 == start => {
1051 ops[n - 2] = at;
1052 ops[n - 1] += 1;
1053 }
1054 _ => ops.extend([SPLICE_REMOVE, at, 1]),
1055 }
1056 }
1057 RowDelta::Move(from, to) if from != to => {
1058 ops.extend([SPLICE_MOVE, to_i32(from), to_i32(to)]);
1059 }
1060 RowDelta::Move(..) => {}
1061 }
1062 }
1063 ops
1064 }
1065
1066 fn to_i32(n: usize) -> i32 {
1067 i32::try_from(n).unwrap_or(i32::MAX)
1068 }
1069
1070 pub const SCROLL_HIDE_INDICATORS: i32 = 1;
1072 pub const SCROLL_BOUNCE_NEVER: i32 = 2;
1073 pub const SCROLL_BOUNCE_ALWAYS: i32 = 4;
1074 pub const SCROLL_SNAP_PAGE: i32 = 8;
1075 pub const SCROLL_SNAP_INTERVAL: i32 = 16;
1076 pub const SCROLL_KEYBOARD_DRAG: i32 = 32;
1077 pub const SCROLL_KEYBOARD_TAPS: i32 = 64;
1078 pub const SCROLL_TRACK_OFFSET: i32 = 128;
1079 pub const SCROLL_TRACK_PHASE: i32 = 256;
1080
1081 pub fn scroll_flags(p: &ScrollProps, density: f64) -> (i32, f32) {
1084 let mut f = 0;
1085 if p.indicators == ScrollIndicators::Hidden {
1086 f |= SCROLL_HIDE_INDICATORS;
1087 }
1088 match p.bounce {
1089 Some(false) => f |= SCROLL_BOUNCE_NEVER,
1090 Some(true) => f |= SCROLL_BOUNCE_ALWAYS,
1091 None => {}
1092 }
1093 let mut interval = 0.0;
1094 match p.snap {
1095 ScrollSnap::Page => f |= SCROLL_SNAP_PAGE,
1096 ScrollSnap::Interval(points) if points.is_finite() && points > 0.0 => {
1097 let px = points * density;
1098 if px >= 1.0 {
1099 f |= SCROLL_SNAP_INTERVAL;
1100 interval = px.min(f64::from(f32::MAX)) as f32;
1101 }
1102 }
1103 ScrollSnap::Interval(_) | ScrollSnap::None => {}
1104 }
1105 if p.keyboard_dismiss != KeyboardDismiss::Never {
1106 f |= SCROLL_KEYBOARD_DRAG;
1107 }
1108 if p.keyboard_taps == KeyboardTaps::Dismiss {
1109 f |= SCROLL_KEYBOARD_TAPS;
1110 }
1111 if p.track_offset {
1112 f |= SCROLL_TRACK_OFFSET;
1113 }
1114 if p.track_phase {
1115 f |= SCROLL_TRACK_PHASE;
1116 }
1117 (f, interval)
1118 }
1119
1120 pub fn align_code(align: RowAlign) -> i32 {
1122 match align {
1123 RowAlign::Nearest => 0,
1124 RowAlign::Start => 1,
1125 RowAlign::Center => 2,
1126 RowAlign::End => 3,
1127 }
1128 }
1129
1130 pub fn viewport(
1134 first: i32,
1135 last: i32,
1136 end_px: i32,
1137 density: f64,
1138 len: usize,
1139 ) -> Option<ListViewport> {
1140 if len == 0 || first < 0 || density <= 0.0 {
1141 return None;
1142 }
1143 let first = (first as usize).min(len - 1);
1144 let last = usize::try_from(last)
1145 .map_or(first, |l| l.min(len - 1))
1146 .max(first);
1147 Some(ListViewport {
1148 first,
1149 last,
1150 end_distance: f64::from(end_px.max(0)) / density,
1151 })
1152 }
1153
1154 pub const OFFSET_PREFIX: &str = "day:scroll:";
1156 pub const PHASE_PREFIX: &str = "day:scroll-phase:";
1158
1159 pub fn offset(payload: &str, density: f64) -> Option<Point> {
1161 let (x, y) = payload.split_once(',')?;
1162 let (x, y) = (x.trim().parse::<f64>().ok()?, y.trim().parse::<f64>().ok()?);
1163 (density > 0.0).then(|| Point::new(x / density, y / density))
1164 }
1165
1166 pub fn phase(payload: &str) -> Option<ScrollPhase> {
1168 match payload.trim() {
1169 "0" => Some(ScrollPhase::Idle),
1170 "1" => Some(ScrollPhase::Dragging),
1171 "2" => Some(ScrollPhase::Coasting),
1172 _ => None,
1173 }
1174 }
1175}
1176
1177#[cfg(test)]
1178mod list_wire_tests {
1179 use super::list_wire::{
1180 OFFSET_PREFIX, PHASE_PREFIX, SCROLL_BOUNCE_ALWAYS, SCROLL_BOUNCE_NEVER,
1181 SCROLL_HIDE_INDICATORS, SCROLL_KEYBOARD_DRAG, SCROLL_KEYBOARD_TAPS, SCROLL_SNAP_INTERVAL,
1182 SCROLL_SNAP_PAGE, SCROLL_TRACK_OFFSET, SCROLL_TRACK_PHASE, SPLICE_INSERT, SPLICE_MOVE,
1183 SPLICE_REMOVE, align_code, offset, phase, scroll_flags, splice_ops, viewport,
1184 };
1185 use day_spec::props::{
1186 KeyboardDismiss, KeyboardTaps, RowDelta, ScrollIndicators, ScrollProps, ScrollSnap,
1187 };
1188 use day_spec::{Point, RowAlign, ScrollPhase};
1189
1190 fn replay_deltas(rows: &mut Vec<u32>, deltas: &[RowDelta]) {
1192 let mut fresh = 100;
1193 for d in deltas {
1194 match *d {
1195 RowDelta::Insert(at) => {
1196 rows.insert(at, fresh);
1197 fresh += 1;
1198 }
1199 RowDelta::Remove(at) => {
1200 rows.remove(at);
1201 }
1202 RowDelta::Move(from, to) => {
1203 let row = rows.remove(from);
1204 rows.insert(to, row);
1205 }
1206 }
1207 }
1208 }
1209
1210 fn replay_ops(rows: &mut Vec<u32>, ops: &[i32]) {
1213 let mut fresh = 100;
1214 for op in ops.chunks(3) {
1215 let (a, b) = (op[1] as usize, op[2] as usize);
1216 match op[0] {
1217 SPLICE_INSERT => {
1218 for i in 0..b {
1219 rows.insert(a + i, fresh);
1220 fresh += 1;
1221 }
1222 }
1223 SPLICE_REMOVE => {
1224 rows.drain(a..a + b);
1225 }
1226 SPLICE_MOVE => {
1227 let row = rows.remove(a);
1228 rows.insert(b, row);
1229 }
1230 _ => panic!("unknown op"),
1231 }
1232 }
1233 }
1234
1235 fn agree(start: &[u32], deltas: &[RowDelta]) -> Vec<i32> {
1236 let ops = splice_ops(deltas);
1237 let (mut a, mut b) = (start.to_vec(), start.to_vec());
1238 replay_deltas(&mut a, deltas);
1239 replay_ops(&mut b, &ops);
1240 let old = |v: &Vec<u32>| {
1241 v.iter()
1242 .map(|r| if *r >= 100 { 100 } else { *r })
1243 .collect::<Vec<_>>()
1244 };
1245 assert_eq!(old(&a), old(&b), "{deltas:?} -> {ops:?}");
1246 ops
1247 }
1248
1249 #[test]
1250 fn an_append_is_one_range() {
1251 let deltas: Vec<_> = (0..200).map(|_| RowDelta::Insert(3)).collect();
1252 assert_eq!(agree(&[0, 1, 2], &deltas), vec![SPLICE_INSERT, 3, 200]);
1253 }
1254
1255 #[test]
1256 fn a_removed_block_is_one_range() {
1257 let deltas = [
1259 RowDelta::Remove(4),
1260 RowDelta::Remove(3),
1261 RowDelta::Remove(2),
1262 ];
1263 assert_eq!(
1264 agree(&[0, 1, 2, 3, 4, 5], &deltas),
1265 vec![SPLICE_REMOVE, 2, 3]
1266 );
1267 let forward = [RowDelta::Remove(1), RowDelta::Remove(1)];
1268 assert_eq!(agree(&[0, 1, 2, 3], &forward), vec![SPLICE_REMOVE, 1, 2]);
1269 }
1270
1271 #[test]
1272 fn mixed_deltas_keep_their_order() {
1273 let deltas = [
1274 RowDelta::Remove(5),
1275 RowDelta::Remove(1),
1276 RowDelta::Insert(0),
1277 RowDelta::Move(4, 0),
1278 RowDelta::Insert(2),
1279 RowDelta::Insert(2),
1280 RowDelta::Move(1, 1),
1281 ];
1282 let ops = agree(&[0, 1, 2, 3, 4, 5, 6], &deltas);
1283 assert_eq!(ops.len() % 3, 0);
1284 assert_eq!(&ops[ops.len() - 3..], &[SPLICE_INSERT, 2, 2]);
1286 }
1287
1288 #[test]
1289 fn the_keyed_case_lands_in_order() {
1290 agree(&[1, 2, 3], &[RowDelta::Insert(0)]);
1292 assert_eq!(
1293 agree(&[9, 1, 2, 3], &[RowDelta::Move(3, 0)]),
1294 vec![SPLICE_MOVE, 3, 0]
1295 );
1296 }
1297
1298 #[test]
1299 fn scroll_preferences_become_bits() {
1300 let plain = ScrollProps::default();
1301 assert_eq!(scroll_flags(&plain, 2.0), (0, 0.0));
1302 let all = ScrollProps {
1303 indicators: ScrollIndicators::Hidden,
1304 bounce: Some(false),
1305 snap: ScrollSnap::Interval(292.0),
1306 keyboard_dismiss: KeyboardDismiss::Interactive,
1307 keyboard_taps: KeyboardTaps::Dismiss,
1308 track_offset: true,
1309 track_phase: true,
1310 ..Default::default()
1311 };
1312 let (f, px) = scroll_flags(&all, 2.625);
1313 assert!((px - 766.5).abs() < 1e-3);
1314 assert_eq!(
1315 f,
1316 SCROLL_HIDE_INDICATORS
1317 | SCROLL_BOUNCE_NEVER
1318 | SCROLL_SNAP_INTERVAL
1319 | SCROLL_KEYBOARD_DRAG
1320 | SCROLL_KEYBOARD_TAPS
1321 | SCROLL_TRACK_OFFSET
1322 | SCROLL_TRACK_PHASE
1323 );
1324 let paged = ScrollProps {
1325 bounce: Some(true),
1326 snap: ScrollSnap::Page,
1327 ..Default::default()
1328 };
1329 assert_eq!(
1330 scroll_flags(&paged, 1.0),
1331 (SCROLL_BOUNCE_ALWAYS | SCROLL_SNAP_PAGE, 0.0)
1332 );
1333 let nothing = ScrollProps {
1334 snap: ScrollSnap::Interval(-4.0),
1335 ..Default::default()
1336 };
1337 assert_eq!(scroll_flags(¬hing, 1.0), (0, 0.0));
1338 }
1339
1340 #[test]
1341 fn reports_decode_and_clamp() {
1342 assert_eq!(align_code(RowAlign::Nearest), 0);
1343 assert_eq!(align_code(RowAlign::End), 3);
1344 let v = viewport(3, 1, -5, 2.0, 10).map(|v| (v.first, v.last, v.end_distance));
1345 assert_eq!(v, Some((3, 3, 0.0)));
1346 let v = viewport(8, 40, 64, 2.0, 10).map(|v| (v.first, v.last, v.end_distance));
1347 assert_eq!(v, Some((8, 9, 32.0)));
1348 assert!(viewport(0, 0, 0, 2.0, 0).is_none());
1349 assert!(viewport(-1, 0, 0, 2.0, 4).is_none());
1350 assert_eq!(offset("2835,0", 2.625), Some(Point::new(1080.0, 0.0)));
1351 assert_eq!(offset("4", 1.0), None);
1352 assert_eq!(phase("2"), Some(ScrollPhase::Coasting));
1353 assert_eq!(phase("7"), None);
1354 }
1355
1356 #[test]
1357 fn java_side_parity() {
1358 let bridge = include_str!("../java/dev/daybrite/day/bridge/DayBridge.java");
1359 for (name, value) in [
1360 ("SPLICE_INSERT", SPLICE_INSERT),
1361 ("SPLICE_REMOVE", SPLICE_REMOVE),
1362 ("SPLICE_MOVE", SPLICE_MOVE),
1363 ("SCROLL_HIDE_INDICATORS", SCROLL_HIDE_INDICATORS),
1364 ("SCROLL_BOUNCE_NEVER", SCROLL_BOUNCE_NEVER),
1365 ("SCROLL_BOUNCE_ALWAYS", SCROLL_BOUNCE_ALWAYS),
1366 ("SCROLL_SNAP_PAGE", SCROLL_SNAP_PAGE),
1367 ("SCROLL_SNAP_INTERVAL", SCROLL_SNAP_INTERVAL),
1368 ("SCROLL_KEYBOARD_DRAG", SCROLL_KEYBOARD_DRAG),
1369 ("SCROLL_KEYBOARD_TAPS", SCROLL_KEYBOARD_TAPS),
1370 ("SCROLL_TRACK_OFFSET", SCROLL_TRACK_OFFSET),
1371 ("SCROLL_TRACK_PHASE", SCROLL_TRACK_PHASE),
1372 ] {
1373 assert!(
1374 bridge.contains(&format!("static final int {name} = {value};")),
1375 "{name} = {value}"
1376 );
1377 }
1378 for (name, align) in [
1379 ("LIST_ALIGN_NEAREST", RowAlign::Nearest),
1380 ("LIST_ALIGN_START", RowAlign::Start),
1381 ("LIST_ALIGN_CENTER", RowAlign::Center),
1382 ("LIST_ALIGN_END", RowAlign::End),
1383 ] {
1384 let value = align_code(align);
1385 assert!(
1386 bridge.contains(&format!("static final int {name} = {value};")),
1387 "{name} = {value}"
1388 );
1389 }
1390 assert!(bridge.contains(&format!("\"{OFFSET_PREFIX}\"")));
1391 assert!(bridge.contains(&format!("\"{PHASE_PREFIX}\"")));
1392 }
1393}
1394
1395#[cfg(any(target_os = "android", test))]
1400mod motion_wire {
1401 use day_spec::{AnimSpec, Color, Curve, Displayed, Point, Rect};
1402
1403 pub const T_DURATION: usize = 0;
1406 pub const T_DELAY: usize = 1;
1407 pub const T_REPEAT: usize = 2;
1408 pub const T_REVERSE: usize = 3;
1409 pub const T_COUNT: usize = 4;
1410
1411 pub const FOREVER: i32 = -1;
1413
1414 pub fn timing(anim: Option<&AnimSpec>) -> [i32; T_COUNT] {
1418 let mut out = [0; T_COUNT];
1419 let Some(a) = anim else {
1420 return out;
1421 };
1422 let int = |v: u32| i32::try_from(v).unwrap_or(i32::MAX);
1423 out[T_DURATION] = int(a.duration_ms);
1424 out[T_DELAY] = int(a.delay_ms);
1425 out[T_REPEAT] = if a.repeats_forever() {
1426 FOREVER
1427 } else {
1428 int(a.repeat)
1429 };
1430 out[T_REVERSE] = i32::from(a.autoreverse);
1431 out
1432 }
1433
1434 pub fn keys(anim: Option<&AnimSpec>) -> Vec<f32> {
1439 match anim {
1440 Some(a) if !matches!(a.curve, Curve::Linear) && a.duration_ms > 0 => {
1441 a.keyframes().iter().map(|k| k.progress as f32).collect()
1442 }
1443 _ => Vec::new(),
1444 }
1445 }
1446
1447 pub fn displayed(slots: &[f64]) -> Displayed {
1451 let [alpha, tx, ty, has_frame, x, y, w, h, has_fill, fill] = slots else {
1452 return Displayed::default();
1453 };
1454 let channel = |argb: u32, shift: u32| f64::from((argb >> shift) & 0xff) / 255.0;
1455 let argb = fill.clamp(0.0, f64::from(u32::MAX)) as u32;
1457 Displayed {
1458 opacity: Some(*alpha),
1459 frame: (*has_frame != 0.0).then(|| Rect::new(*x, *y, *w, *h)),
1460 translation: Some(Point::new(*tx, *ty)),
1461 background: (*has_fill != 0.0).then(|| {
1462 Color::rgba(
1463 channel(argb, 16),
1464 channel(argb, 8),
1465 channel(argb, 0),
1466 channel(argb, 24),
1467 )
1468 }),
1469 }
1470 }
1471}
1472
1473#[cfg(test)]
1474mod motion_wire_tests {
1475 use super::motion_wire::*;
1476 use day_spec::{AnimSpec, Color, Point, Rect};
1477
1478 #[test]
1479 fn timing_carries_delay_repeat_and_reverse() {
1480 assert_eq!(timing(None), [0; T_COUNT]);
1481 let t = timing(Some(&AnimSpec::linear(600).delay(900)));
1482 assert_eq!(t, [600, 900, 0, 0]);
1483 let t = timing(Some(&AnimSpec::linear(800).repeat(2, true)));
1484 assert_eq!((t[T_REPEAT], t[T_REVERSE]), (2, 1));
1485 let t = timing(Some(&AnimSpec::linear(600).repeat_forever(false)));
1486 assert_eq!((t[T_REPEAT], t[T_REVERSE]), (FOREVER, 0));
1487 }
1488
1489 #[test]
1490 fn keys_sample_every_curve_but_linear() {
1491 assert_eq!(keys(None), Vec::<f32>::new());
1492 assert_eq!(keys(Some(&AnimSpec::linear(300))), Vec::<f32>::new());
1493 let ease = keys(Some(&AnimSpec::ease_in(1000)));
1494 assert_eq!(ease.len(), 61);
1495 assert!((ease[30] - 0.25).abs() < 1e-6, "t² at half way");
1496 let spring = AnimSpec::spring(0.9, 0.25);
1497 let k = keys(Some(&spring));
1498 assert_eq!(k.first().copied(), Some(0.0));
1499 assert_eq!(k.last().copied(), Some(1.0));
1500 assert!(k.iter().any(|&p| p > 1.3), "a loose spring overshoots");
1501 }
1502
1503 #[test]
1506 fn sampled_curve_follows_the_spring() {
1507 let spring = AnimSpec::spring(0.9, 0.25);
1508 let k = keys(Some(&spring));
1509 let last = (k.len() - 1) as f32;
1510 let read = |t: f32| {
1511 let x = t * last;
1512 let i = x as usize;
1513 let f = x - i as f32;
1514 k[i] + (k[(i + 1).min(k.len() - 1)] - k[i]) * f
1515 };
1516 for step in 0..100_u8 {
1517 let t = f64::from(step) / 100.0 + 0.003;
1518 let want = spring.cycle_progress(t);
1519 assert!(
1520 (f64::from(read(t as f32)) - want).abs() < 0.02,
1521 "{t}: {want}"
1522 );
1523 }
1524 }
1525
1526 #[test]
1527 fn displayed_decodes_every_slot() {
1528 let d = displayed(&[
1529 0.5,
1530 10.0,
1531 -4.0,
1532 1.0,
1533 1.0,
1534 2.0,
1535 80.0,
1536 40.0,
1537 1.0,
1538 f64::from(0xFF80_4020_u32),
1539 ]);
1540 assert_eq!(d.opacity, Some(0.5));
1541 assert_eq!(d.translation, Some(Point::new(10.0, -4.0)));
1542 assert_eq!(d.frame, Some(Rect::new(1.0, 2.0, 80.0, 40.0)));
1543 let c = d.background.unwrap_or(Color::BLACK);
1544 assert!((c.r - 128.0 / 255.0).abs() < 1e-9 && (c.b - 32.0 / 255.0).abs() < 1e-9);
1545 let bare = displayed(&[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]);
1546 assert_eq!((bare.frame, bare.background), (None, None));
1547 assert_eq!(displayed(&[]).opacity, None);
1548 }
1549
1550 #[test]
1551 fn java_side_parity() {
1552 let bridge = include_str!("../java/dev/daybrite/day/bridge/DayBridge.java");
1553 for (name, value) in [
1554 ("T_DURATION", T_DURATION),
1555 ("T_DELAY", T_DELAY),
1556 ("T_REPEAT", T_REPEAT),
1557 ("T_REVERSE", T_REVERSE),
1558 ("T_COUNT", T_COUNT),
1559 ] {
1560 assert!(
1561 bridge.contains(&format!("static final int {name} = {value};")),
1562 "{name} = {value}"
1563 );
1564 }
1565 assert!(bridge.contains("double[] out = new double[10];"));
1566 }
1567}
1568
1569#[cfg(target_os = "android")]
1574pub use day_platform_android::java_class;
1575
1576#[cfg(target_os = "android")]
1577pub mod ext;
1578#[cfg(target_os = "android")]
1579pub use ext::*;
1580
1581#[cfg(target_os = "android")]
1582mod imp {
1583 pub use day_platform_android::*;
1584
1585 use framework::DayListItem;
1586
1587 use std::any::Any;
1588 use std::cell::{Cell, RefCell};
1589 use std::rc::Rc;
1590 use std::sync::OnceLock;
1591
1592 use jni::Env;
1593 use jni::objects::{Global, JClass, JObject, JString};
1594 use linkme::distributed_slice;
1595
1596 type Gref = std::sync::Arc<Global<JObject<'static>>>;
1601
1602 use day_spec::bridge;
1603 use day_spec::props::*;
1604 use day_spec::{
1605 A11yProps, AnimSpec, Builtin, Cap, Cursor, DrawOp, Event, EventSink, Font, ListSource,
1606 NodeId, PieceKind, Platform, Point, Proposal, RawHandle, Rect, Registry, Renderer, Role,
1607 Size, Support, Toolkit, Transform, WindowOptions, kinds,
1608 };
1609
1610 day_core::tls_group! {
1611 static CONTEXT_MENU_FNS: day_spec::sidetable::SideTable<day_spec::ContextMenuFn> = day_spec::sidetable::SideTable::new();
1612 static BUTTON_MENU_FNS: day_spec::sidetable::SideTable<day_spec::ContextMenuFn> = day_spec::sidetable::SideTable::new();
1615 static TRANSFER_SOURCES: day_spec::sidetable::SideTable<day_spec::transfer::Source> = day_spec::sidetable::SideTable::new();
1616 static TRANSFER_TARGETS: day_spec::sidetable::SideTable<day_spec::transfer::Target> = day_spec::sidetable::SideTable::new();
1617
1618 static LIST_SOURCES: std::cell::RefCell<std::collections::HashMap<i64, ListSource>> =
1628 std::cell::RefCell::new(std::collections::HashMap::new());
1629 static LIST_BINDINGS: std::cell::RefCell<std::collections::HashMap<(i64, i32), (usize, u64)>> =
1631 std::cell::RefCell::new(std::collections::HashMap::new());
1632 static LIST_NODE: std::cell::RefCell<std::collections::HashMap<usize, i64>> =
1633 std::cell::RefCell::new(std::collections::HashMap::new());
1634 static LIST_ITEM_PROPS: std::cell::RefCell<
1644 std::collections::HashMap<usize, day_spec::props::ListItemProps>,
1645 > = std::cell::RefCell::new(std::collections::HashMap::new());
1646 static NAV_MENU_ROWS: std::cell::RefCell<
1647 std::collections::HashMap<usize, (i64, String, String, String, String)>,
1648 > = std::cell::RefCell::new(std::collections::HashMap::new());
1649 static WINDOW_BARS: std::cell::RefCell<
1652 std::collections::HashMap<usize, day_spec::ToolbarMirror>,
1653 > = std::cell::RefCell::new(std::collections::HashMap::new());
1654 static NAV_SUITES: std::cell::RefCell<std::collections::HashSet<usize>> =
1657 std::cell::RefCell::new(std::collections::HashSet::new());
1658 static LABEL_NODE: std::cell::RefCell<std::collections::HashMap<usize, i64>> =
1661 std::cell::RefCell::new(std::collections::HashMap::new());
1662 #[allow(clippy::type_complexity)] static LIST_CELLS: std::cell::RefCell<
1664 std::collections::HashMap<i64, std::collections::HashMap<i32, Gref>>,
1665 > = std::cell::RefCell::new(std::collections::HashMap::new());
1666 static LIST_AUTOMATIC: std::cell::RefCell<std::collections::HashSet<i64>> =
1669 std::cell::RefCell::new(std::collections::HashSet::new());
1670 static LIST_SELECTED: std::cell::RefCell<
1674 std::collections::HashMap<i64, std::collections::BTreeSet<usize>>,
1675 > = std::cell::RefCell::new(std::collections::HashMap::new());
1676
1677 static SINK: RefCell<Option<Sink>> = const { RefCell::new(None) };
1678 static DENSITY: Cell<f64> = const { Cell::new(1.0) };
1679 static ROOT: RefCell<Option<(AHandle, Size)>> = const { RefCell::new(None) };
1680
1681 static SECONDARY: RefCell<Vec<(u64, Gref)>> = const { RefCell::new(Vec::new()) };
1684
1685 }
1686
1687 type SectionTreeEntry = (day_spec::TreeSource, Vec<u64>, Vec<u64>);
1688 thread_local! {
1689 static TREE_SOURCES: RefCell<std::collections::HashMap<i64, SectionTreeEntry>> = RefCell::new(std::collections::HashMap::new());
1690 }
1691 fn tree_reload(host: &AHandle) {
1692 use std::fmt::Write as _;
1693 let handle = host.clone();
1694 let id = LIST_NODE.with(|m| {
1695 m.borrow()
1696 .get(&(host.0.as_obj().as_raw() as usize))
1697 .copied()
1698 });
1699 let Some(id) = id else {
1700 return;
1701 };
1702 Material::post(Box::new(move || {
1703 let source = TREE_SOURCES.with(|m| m.borrow().get(&id).map(|e| e.0.clone()));
1704 let Some(source) = source else {
1705 return;
1706 };
1707 let mut tokens = Vec::new();
1708 let mut data = String::new();
1709 for g in 0..(source.children_len)(None) {
1710 let token = (source.child_token)(None, g);
1711 let index = tokens.len();
1712 tokens.push(token);
1713 let _ = writeln!(
1714 data,
1715 "{token}:-1:{}:{}",
1716 u8::from((source.section_header)(token)),
1717 u8::from((source.expanded)(token))
1718 );
1719 for c in 0..(source.children_len)(Some(token)) {
1720 let child = (source.child_token)(Some(token), c);
1721 tokens.push(child);
1722 let _ = writeln!(data, "{child}:{index}:0:0");
1723 }
1724 }
1725 TREE_SOURCES.with(|m| {
1726 if let Some(e) = m.borrow_mut().get_mut(&id) {
1727 e.1 = tokens;
1728 let selected =
1729 e.1.iter()
1730 .enumerate()
1731 .filter(|(_, t)| e.2.contains(t))
1732 .map(|(i, _)| i)
1733 .collect();
1734 LIST_SELECTED.with(|m| m.borrow_mut().insert(id, selected));
1735 }
1736 });
1737 with_env(|env| {
1738 let data = jstr(env, &data);
1739 let _ = java_in(env, |env| {
1740 DayBridge::treeReload(env, handle.0.as_obj(), &data)
1741 });
1742 });
1743 }));
1744 }
1745 fn tree_patch(host: &AHandle, patch: &TreePatch) {
1746 match patch {
1747 TreePatch::Reload => tree_reload(host),
1748 TreePatch::Expand(token, open) => {
1749 let (host, token, open) = (host.clone(), *token, *open);
1752 Material::post(Box::new(move || {
1753 bridge(|env| DayBridge::treeExpand(env, host.0.as_obj(), token as i64, open));
1754 }));
1755 }
1756 TreePatch::Reveal(token) => {
1757 bridge(|env| DayBridge::treeReveal(env, host.0.as_obj(), *token as i64));
1758 }
1759 TreePatch::Selected(tokens) => {
1760 if let Some(id) = LIST_NODE.with(|m| {
1761 m.borrow()
1762 .get(&(host.0.as_obj().as_raw() as usize))
1763 .copied()
1764 }) {
1765 let selected = TREE_SOURCES.with(|m| {
1766 m.borrow_mut().get_mut(&id).map_or_default(|e| {
1767 e.2.clone_from(tokens);
1768 e.1.iter()
1769 .enumerate()
1770 .filter(|(_, t)| tokens.contains(t))
1771 .map(|(i, _)| i)
1772 .collect()
1773 })
1774 });
1775 LIST_SELECTED.with(|m| m.borrow_mut().insert(id, selected));
1776 }
1777 bridge(|env| DayBridge::treeSelection(env, host.0.as_obj()));
1778 }
1779 }
1780 }
1781
1782 #[must_use]
1785 pub fn list_len(host_id: i64) -> usize {
1786 day_spec::ffi_guard::contain(0, || {
1787 LIST_SOURCES.with(|m| m.borrow().get(&host_id).map_or(0, |s| (s.len)()))
1788 })
1789 }
1790
1791 fn size_list_cell(
1799 host_id: i64,
1800 source: &ListSource,
1801 index: usize,
1802 cell: &JObject,
1803 raw: RawHandle,
1804 ) {
1805 let header = source.is_header.as_ref().is_some_and(|f| f(index))
1806 || source.is_supplement.as_ref().is_some_and(|f| f(index));
1807 if !header && !LIST_AUTOMATIC.with(|m| m.borrow().contains(&host_id)) {
1808 return;
1809 }
1810 let height = (source.cell_height)(raw);
1811 if height > 0.0 {
1812 set_list_cell_height(cell, height);
1813 }
1814 }
1815
1816 fn set_list_cell_height(cell: &JObject, height: f64) {
1818 let px = (height * DENSITY.with(std::cell::Cell::get)).round() as i32;
1819 bridge(|env| DayBridge::setListCellHeight(env, cell, px));
1820 }
1821
1822 #[expect(
1828 clippy::needless_pass_by_value,
1829 reason = "public signature; the JNI entry hands over the cell's local reference"
1830 )]
1831 pub fn list_bind(env: &mut Env, host_id: i64, position: i32, cell: JObject, pinned: bool) {
1832 day_spec::ffi_guard::contain((), || {
1833 let hash = framework::System::identityHashCode(env, &cell).unwrap_or(0);
1834 let cached = LIST_CELLS.with(|m| {
1835 m.borrow()
1836 .get(&host_id)
1837 .and_then(|cells| cells.get(&hash).cloned())
1838 });
1839 let gref = if let Some(g) = cached {
1840 g
1841 } else {
1842 let Ok(g) = env.new_global_ref(&cell) else {
1845 return;
1846 };
1847 let g = std::sync::Arc::new(g);
1848 LIST_CELLS.with(|m| {
1849 m.borrow_mut()
1850 .entry(host_id)
1851 .or_default()
1852 .insert(hash, g.clone())
1853 });
1854 g
1855 };
1856 let raw = gref.as_obj().as_raw() as RawHandle;
1857 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
1858 if let Some(source) = source {
1859 let index = position as usize;
1860 if index >= (source.len)() {
1861 return;
1862 }
1863 let token = (source.token_at)(index);
1864 LIST_BINDINGS.with(|m| m.borrow_mut().insert((host_id, hash), (index, token)));
1865 let bind = move |source: &ListSource| {
1866 if pinned {
1867 source.bind_pinned.clone()
1868 } else {
1869 source.bind_row.clone()
1870 }
1871 };
1872 if day_core::try_with_tree(|_| ()).is_some() {
1873 bind(&source)(index, raw);
1874 size_list_cell(host_id, &source, index, &cell, raw);
1875 } else {
1876 <Material as Platform>::post(Box::new(move || {
1881 if !LIST_BINDINGS
1882 .with(|m| m.borrow().get(&(host_id, hash)) == Some(&(index, token)))
1883 {
1884 return;
1885 }
1886 let current = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
1887 if let Some(current) = current
1888 && index < (current.len)()
1889 && (current.token_at)(index) == token
1890 {
1891 let raw = gref.as_obj().as_raw() as RawHandle;
1892 bind(¤t)(index, raw);
1893 size_list_cell(host_id, ¤t, index, gref.as_obj(), raw);
1894 }
1895 }));
1896 }
1897 } else {
1898 let entry = TREE_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
1899 if let Some((source, tokens, _)) = entry
1900 && let Some(token) = tokens.get(position as usize)
1901 {
1902 (source.bind_row)(*token, raw);
1903 let width = unsafe { env.as_cast_unchecked::<framework::View>(&cell) }
1905 .getWidth(env)
1906 .unwrap_or(0);
1907 if width > 0 {
1908 (source.layout_cell)(
1909 raw,
1910 f64::from(width) / DENSITY.with(std::cell::Cell::get),
1911 );
1912 }
1913 }
1914 }
1915 });
1916 }
1917
1918 #[expect(
1923 clippy::needless_pass_by_value,
1924 reason = "public signature; the JNI entry hands over the cell's local reference"
1925 )]
1926 pub fn list_recycle(env: &mut Env, host_id: i64, cell: JObject) {
1927 day_spec::ffi_guard::contain((), || {
1928 let hash = framework::System::identityHashCode(env, &cell).unwrap_or(0);
1929 LIST_BINDINGS.with(|m| m.borrow_mut().remove(&(host_id, hash)));
1930 let gref = LIST_CELLS.with(|m| {
1931 m.borrow()
1932 .get(&host_id)
1933 .and_then(|cells| cells.get(&hash).cloned())
1934 });
1935 let Some(gref) = gref else { return };
1936 if day_core::try_with_tree(|_| ()).is_some() {
1937 recycle_cell(host_id, &gref);
1938 } else {
1939 <Material as Platform>::post(Box::new(move || {
1945 if !LIST_BINDINGS.with(|m| m.borrow().contains_key(&(host_id, hash))) {
1946 recycle_cell(host_id, &gref);
1947 }
1948 }));
1949 }
1950 });
1951 }
1952
1953 fn recycle_cell(host_id: i64, gref: &Gref) {
1955 let raw = gref.as_obj().as_raw() as RawHandle;
1956 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
1957 if let Some(source) = source {
1958 (source.recycle)(raw);
1959 } else if let Some(source) =
1960 TREE_SOURCES.with(|m| m.borrow().get(&host_id).map(|e| e.0.clone()))
1961 {
1962 (source.recycle)(raw);
1963 }
1964 }
1965
1966 fn release_pinned_header(list: &AHandle, nid: i64) {
1970 let Some(source) = LIST_SOURCES.with(|m| m.borrow().get(&nid).cloned()) else {
1971 return;
1972 };
1973 if source.is_header.is_none() {
1974 return;
1975 }
1976 let gref = with_env(|env| {
1977 let Ok(cell) = DayBridge::listPinnedCell(env, list.0.as_obj()) else {
1978 if env.exception_check() {
1979 env.exception_clear();
1980 }
1981 return None;
1982 };
1983 if cell.is_null() {
1984 return None;
1985 }
1986 let hash = framework::System::identityHashCode(env, &cell).ok()?;
1987 LIST_CELLS.with(|m| m.borrow().get(&nid).and_then(|c| c.get(&hash).cloned()))
1988 });
1989 if let Some(gref) = gref {
1990 (source.release)(gref.as_obj().as_raw() as RawHandle);
1991 }
1992 }
1993
1994 #[must_use]
1997 pub fn list_is_selected(host_id: i64, position: i32) -> bool {
1998 day_spec::ffi_guard::contain(false, || {
1999 LIST_SELECTED.with(|m| {
2000 m.borrow()
2001 .get(&host_id)
2002 .is_some_and(|set| set.contains(&(position.max(0) as usize)))
2003 })
2004 })
2005 }
2006
2007 #[must_use]
2013 pub fn list_row_kind(host_id: i64, position: i32) -> i32 {
2014 day_spec::ffi_guard::contain(0, || {
2015 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2016 let Some(s) = source else { return 0 };
2017 let index = position.max(0) as usize;
2018 if index >= (s.len)() {
2019 return 0;
2020 }
2021 if s.is_supplement.as_ref().is_some_and(|f| f(index)) {
2022 return 2;
2023 }
2024 i32::from(s.is_header.as_ref().is_some_and(|f| f(index)))
2025 })
2026 }
2027
2028 pub fn list_viewport(host_id: i64, first: i32, last: i32, end_px: i32) {
2032 day_spec::ffi_guard::contain((), || {
2033 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2034 let Some(source) = source else { return };
2035 let Some(report) = &source.viewport else {
2036 return;
2037 };
2038 if let Some(v) = crate::list_wire::viewport(
2039 first,
2040 last,
2041 end_px,
2042 DENSITY.with(std::cell::Cell::get),
2043 (source.len)(),
2044 ) {
2045 report(v);
2046 }
2047 });
2048 }
2049
2050 pub fn list_reader_scroll(host_id: i64) {
2054 day_spec::ffi_guard::contain((), || {
2055 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2056 if let Some(report) = source.as_ref().and_then(|s| s.reader_scroll.as_ref()) {
2057 report();
2058 }
2059 });
2060 }
2061
2062 #[must_use]
2066 pub fn list_header_of(host_id: i64, position: i32) -> i32 {
2067 day_spec::ffi_guard::contain(-1, || {
2068 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2069 let Some(source) = source else { return -1 };
2070 let Some(is_header) = source.is_header.as_ref() else {
2071 return -1;
2072 };
2073 let len = (source.len)();
2074 if position < 0 || len == 0 {
2075 return -1;
2076 }
2077 let start = (position as usize).min(len - 1);
2078 if source.is_supplement.as_ref().is_some_and(|f| f(start)) {
2080 return -1;
2081 }
2082 (0..=start)
2083 .rev()
2084 .find(|&i| is_header(i))
2085 .map_or(-1, |i| i32::try_from(i).unwrap_or(-1))
2086 })
2087 }
2088
2089 #[expect(
2098 clippy::needless_pass_by_value,
2099 reason = "public signature; the JNI entry hands over the array's local reference"
2100 )]
2101 pub fn transfer_call<'l>(
2102 env: &mut Env<'l>,
2103 kind: i32,
2104 token: i64,
2105 x: f64,
2106 y: f64,
2107 bytes: jni::objects::JByteArray,
2108 local: bool,
2109 ) -> Result<jni::objects::JByteArray<'l>, jni::errors::Error> {
2110 use day_spec::transfer::*;
2111 let input = env.convert_byte_array(&bytes)?;
2112 let output = day_spec::ffi_guard::contain(Vec::new(), || match kind {
2113 0 => TRANSFER_SOURCES
2114 .with(|t| t.get(token as usize))
2115 .and_then(|f| f(Point::new(x, y)))
2116 .and_then(|o| o.encode())
2117 .unwrap_or_default(),
2118 1 => {
2119 let at = Location {
2120 position: Point::new(x, y),
2121 types: String::from_utf8_lossy(&input)
2122 .split('\n')
2123 .map(str::to_owned)
2124 .collect(),
2125 allowed: vec![Operation::Copy],
2126 local,
2127 };
2128 vec![u8::from(
2129 TRANSFER_TARGETS
2130 .with(|t| t.get(token as usize))
2131 .is_some_and(|t| t.proposal(&at) == Operation::Copy),
2132 )]
2133 }
2134 2 => {
2135 let ok = Offer::decode(&input).is_some_and(|offer| {
2136 TRANSFER_TARGETS
2137 .with(|t| t.get(token as usize))
2138 .is_some_and(|t| {
2139 t.deliver(
2140 Location {
2141 position: Point::new(x, y),
2142 types: offer.types(),
2143 allowed: vec![Operation::Copy],
2144 local,
2145 },
2146 offer,
2147 )
2148 })
2149 });
2150 vec![u8::from(ok)]
2151 }
2152 3 => {
2154 if let Some(t) = TRANSFER_TARGETS.with(|t| t.get(token as usize)) {
2155 t.leave();
2156 }
2157 Vec::new()
2158 }
2159 _ => Vec::new(),
2160 });
2161 env.byte_array_from_slice(&output)
2162 }
2163 fn transfer_install(h: &AHandle, source: bool) {
2166 let view = h.0.as_obj();
2167 let token = view.as_raw() as i64;
2168 bridge(|env| {
2169 if source {
2170 DayTransfer::source(env, view, token)
2171 } else {
2172 DayTransfer::target(env, view, token)
2173 }
2174 });
2175 }
2176
2177 #[must_use]
2182 pub fn list_can_drop(host_id: i64, from: i32, to: i32) -> bool {
2183 day_spec::ffi_guard::contain(false, || {
2185 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2186 let Some(source) = source else { return false };
2187 let Some(r) = source.reorder.as_ref() else {
2188 return false;
2189 };
2190 let len = (source.len)();
2191 let (from, to) = (from.max(0) as usize, to.max(0) as usize);
2192 if from >= len || to >= len {
2193 return false;
2194 }
2195 (r.can_move)(from, to) == to as i64
2196 })
2197 }
2198
2199 #[must_use]
2202 pub fn list_move(host_id: i64, from: i32, to: i32) -> bool {
2203 day_spec::ffi_guard::contain(false, || {
2205 if !list_can_drop(host_id, from, to) {
2206 return false;
2207 }
2208 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2209 let Some(r) = source.and_then(|s| s.reorder) else {
2210 return false;
2211 };
2212 let (from, to) = (from as usize, to as usize);
2213 if from != to {
2214 (r.move_row)(from, to);
2215 }
2216 true
2217 })
2218 }
2219
2220 #[must_use]
2223 pub fn list_can_delete(host_id: i64, index: i32) -> bool {
2224 day_spec::ffi_guard::contain(false, || {
2226 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2227 let Some(source) = source else { return false };
2228 let Some(d) = source.delete.as_ref() else {
2229 return false;
2230 };
2231 let index = index.max(0) as usize;
2232 index < (source.len)() && (d.can_delete)(index)
2233 })
2234 }
2235
2236 #[must_use]
2239 pub fn list_delete(host_id: i64, index: i32) -> bool {
2240 day_spec::ffi_guard::contain(false, || {
2242 if !list_can_delete(host_id, index) {
2243 return false;
2244 }
2245 let source = LIST_SOURCES.with(|m| m.borrow().get(&host_id).cloned());
2246 let Some(d) = source.and_then(|s| s.delete) else {
2247 return false;
2248 };
2249 (d.delete_row)(index as usize);
2250 true
2251 })
2252 }
2253
2254 pub const BRIDGE: &str = "dev/daybrite/day/bridge/DayBridge";
2255
2256 crate::java_class! {
2260 pub DayBridge => dev.daybrite.day.bridge.DayBridge,
2261 methods {
2262 static fn addChild(parent: android.view.View, child: android.view.View),
2263 static fn announce(text: JString, urgent: jboolean),
2264 static fn baselineAt(v: android.view.View, w_px: jint, h_px: jint) -> jint,
2265 static fn cancelFrame(token: jlong),
2266 static fn canSetAppearance() -> jboolean,
2267 static fn canSetLauncherShortcuts() -> jboolean,
2268 static fn closeWindow(node: jlong),
2269 static fn coverDismiss(cover: android.view.View),
2270 static fn coverPresent(cover: android.view.View, bg: jint, has_bg: jboolean, dismiss_disabled: jboolean),
2271 static fn coverSetDismissDisabled(cover: android.view.View, d: jboolean),
2272 static fn dismissPresent(req: jlong),
2273 static fn displayInfo() -> JString,
2274 static fn documentNavChrome(suite: android.view.View, visible: jboolean),
2275 static fn documentNavSuite(suite: android.view.View, new_label: JString, close_label: JString, can_add: jboolean),
2276 static fn enableGesture(v: android.view.View, id: jlong, is_drag: jboolean),
2277 static fn enableRecognizer(v: android.view.View, id: jlong, kind: jint),
2278 static fn enableHover(v: android.view.View, id: jlong),
2279 static fn enableKeys(v: android.view.View, id: jlong),
2280 static fn enablePan(v: android.view.View, id: jlong),
2281 static fn enablePinch(v: android.view.View, id: jlong),
2282 static fn enableRotate(v: android.view.View, id: jlong),
2283 static fn focusNavSearch(nav_host: android.view.View),
2284 static fn focusView(v: android.view.View, focused: jboolean),
2285 static fn focusWindow(node: jlong),
2286 static fn fontFamilies() -> JString,
2287 static fn imageDecode(id: jlong, bytes: jbyte[]) -> JString,
2288 static fn imageEncode(id: jlong, format: JString, quality: jint, fit_w: jdouble, fit_h: jdouble) -> jbyte[],
2289 static fn imageRelease(id: jlong),
2290 static fn isDarkMode() -> jboolean,
2291 static fn systemColor(role: jint) -> jint,
2292 static fn listPaintSelection(v: android.view.View, host_id: jlong),
2293 static fn listReload(v: android.view.View),
2294 static fn listConfigure(v: android.view.View, viewport: jboolean, reader: jboolean, supplements: jboolean),
2295 static fn listSplice(v: android.view.View, ops: jint[]),
2296 static fn listScroll(v: android.view.View, row: jint, align: jint, animated: jboolean),
2297 static fn listScrollToEnd(v: android.view.View),
2298 static fn listScrollToRow(v: android.view.View, row: jint),
2299 static fn listSetSections(v: android.view.View, on: jboolean),
2300 static fn listPinnedCell(v: android.view.View) -> android.view.View,
2301 static fn localeTags() -> JString,
2302 static fn makeButton(id: jlong, title: JString) -> android.view.View,
2303 static fn makeCanvas(id: jlong) -> android.view.View,
2304 static fn makeContainer() -> android.view.View,
2305 static fn makeCover(node: jlong, half: jboolean) -> android.view.View,
2306 static fn makeDivider(vertical: jboolean) -> android.view.View,
2307 static fn makeImage(name: JString, mode: jint, tint: jint) -> android.view.View,
2308 static fn makeImageBitmap(id: jlong, mode: jint) -> android.view.View,
2309 static fn makeImageBytes(bytes: jbyte[], mode: jint) -> android.view.View,
2310 static fn makeLabel(text: JString) -> android.view.View,
2311 static fn makeList(host_id: jlong, row_height_px: jint, selectable: jboolean, reorderable: jboolean, deletable: jboolean, delete_label: JString) -> android.view.View,
2312 static fn makeNavHost(id: jlong, title: JString, adaptive: jboolean, tile_min_dp: jfloat) -> android.view.View,
2313 static fn makeNavMenu(id: jlong, joined_items: JString, joined_icons: JString, joined_sections: JString) -> android.view.View,
2314 static fn makeNavPage(id: jlong, immersive: jboolean) -> android.view.View,
2315 static fn makeNavSuite(id: jlong, initial: jint) -> android.view.View,
2316 static fn makeProgress(determinate: jboolean, fraction: jdouble) -> android.view.View,
2317 static fn makeScroll(horizontal: jboolean, flags: jint, snap_px: jfloat, node: jlong) -> android.view.View,
2318 static fn makeSlider(id: jlong, value: jdouble, min: jdouble, max: jdouble) -> android.view.View,
2319 static fn makeTextField(id: jlong, value: JString, placeholder: JString) -> android.view.View,
2320 static fn makeToggle(id: jlong, value: jboolean, enabled: jboolean) -> android.view.View,
2321 static fn makeTree(id: jlong, height: jint, selectable: jboolean) -> android.view.View,
2322 static fn markNavChromePage(page: android.view.View),
2323 static fn measureHeight(v: android.view.View) -> jint,
2324 static fn measureHeightForWidth(v: android.view.View, w_px: jint) -> jint,
2325 static fn measureText(text: JString, size: jdouble, weight: jint, italic: jboolean, family: JString) -> JString,
2326 static fn measureWidth(v: android.view.View) -> jint,
2327 static fn mountSettled(),
2328 static fn moveChild(parent: android.view.View, child: android.view.View, index: jint),
2329 static fn nativeBack() -> jboolean,
2330 static fn navLoad(key: JString) -> JString,
2331 static fn navPop(host: android.view.View),
2332 static fn navPush(host: android.view.View, title: JString, immersive: jboolean),
2333 static fn navSave(key: JString, value: JString),
2334 static fn navSetGuard(host: android.view.View, on: jboolean),
2335 static fn navSetTitle(host: android.view.View, title: JString),
2336 static fn navTake(key: JString) -> JString,
2337 static fn openUrl(url: JString),
2338 static fn openWindow(node: jlong, title: JString),
2339 static fn prepareSnapshot(host: android.view.View, revision: jlong) -> jint,
2340 static fn present(req: jlong, sheet: jboolean, title: JString, message: JString, buttons_joined: JString, roles_joined: JString),
2341 static fn presentFileOpen(req: jlong, title: JString, filters_joined: JString, multiple: jboolean),
2342 static fn presentFileSave(req: jlong, title: JString, suggested: JString, src_path: JString, filters_joined: JString),
2343 static fn presentPrompt(req: jlong, title: JString, message: JString, placeholder: JString, initial: JString, ok: JString, cancel: JString),
2344 static fn readNative(v: android.view.View) -> JString[],
2345 static fn reduceMotion() -> jboolean,
2346 static fn removeChild(child: android.view.View),
2347 static fn reorderNavSuite(suite: android.view.View, order: JString),
2348 static fn requestFrame(token: jlong),
2349 static fn scrollToRect(v: android.view.View, x: jint, y: jint, w: jint, h: jint, animated: jboolean),
2350 static fn navScrollToEdge(v: android.view.View, bottom: jboolean) -> jboolean,
2351 static fn setA11y(v: android.view.View, label: JString, hint: JString, value: JString, id: JString, role: jint, level: jint, hidden: jboolean, selected: jint),
2352 static fn setAppBack(on: jboolean),
2353 static fn setAppearance(mode: jint),
2354 static fn setAppMenu(spec: JString),
2355 static fn setButtonContent(view: android.view.View, title: JString, icon_name: JString, icon_only: jboolean),
2356 static fn setButtonSelected(v: android.view.View, on: jboolean),
2357 static fn setButtonStyle(v: android.view.View, kind: jint, argb: jint, fg_argb: jint),
2358 static fn setCanvasOps(v: android.view.View, nums: jdouble[], texts_joined: JString,
2359 geometry: jdouble[]),
2360 static fn setContextMenu(v: android.view.View, spec: JString),
2361 static fn setDragAxis(v: android.view.View, axis: jint),
2362 static fn setHitSlop(v: android.view.View, top: jint, leading: jint, bottom: jint, trailing: jint),
2363 static fn setSubtreeEnabled(root: android.view.View, enabled: jboolean),
2364 static fn primaryPointer() -> JString,
2365 static fn setContextMenuFn(v: android.view.View, token: jlong),
2366 static fn setButtonMenu(v: android.view.View, token: jlong),
2367 static fn releaseContextMenu(v: android.view.View),
2368 static fn setDeferSystemGestures(on: jboolean),
2369 static fn setDocumentTabKeys(menu: android.view.View, keys: JString),
2370 static fn setEnabled(v: android.view.View, b: jboolean),
2371 static fn setFrame(v: android.view.View, x: jint, y: jint, w: jint, h: jint, timing: jint[], keys: jfloat[]),
2372 static fn setViewDirection(v: android.view.View, rtl: jboolean),
2373 static fn textScale(sp: jfloat) -> jfloat,
2374 static fn setImageBitmap(v: android.view.View, id: jlong),
2375 static fn setImageBytes(v: android.view.View, bytes: jbyte[]),
2376 static fn setImageName(v: android.view.View, name: JString),
2377 static fn setImageTint(v: android.view.View, tint: jint),
2378 static fn initImageTint(v: android.view.View, tint: jint),
2379 static fn setInputTraits(v: android.view.View, secure: jboolean, read_only: jboolean, purpose: jint, submit_label: jint),
2380 static fn setLabel(v: android.view.View, text: JString),
2381 static fn setLabelAlignment(view: android.view.View, align: jint),
2382 static fn setLabelColor(v: android.view.View, argb: jint, on: jboolean),
2383 static fn setLabelFont(v: android.view.View, sp: jfloat, weight: jint, italic: jboolean, family: JString, tabular: jboolean),
2384 static fn setLabelRuns(v: android.view.View, node: jlong, text: JString, starts: jint[], ends: jint[], flags: jint[], colors: jint[], backgrounds: jint[], scales: jint[], links_joined: JString, decorations: jint[]),
2385 static fn setLabelSecondary(v: android.view.View, on: jboolean),
2386 static fn setLabelSingleLine(view: android.view.View),
2387 static fn setLabelParagraph(view: android.view.View, max_lines: jint, truncation: jint, letter_spacing: jfloat, line_height: jfloat),
2388 static fn setLabelReportsSelection(view: android.view.View, node: jlong),
2389 static fn setLabelFeatures(view: android.view.View, features: JString),
2390 static fn setLauncherShortcuts(packed: JString),
2391 static fn setListCellHeight(cell: android.view.View, px: jint),
2392 static fn setNavMenuBadges(nav_menu: android.view.View, joined_icons: JString, joined_tints: JString, joined_texts: JString),
2393 static fn setNavMenuSelected(nav_menu: android.view.View, index: jint),
2394 static fn setNavMenuTints(nav_menu: android.view.View, joined_tints: JString),
2395 static fn setNavRefreshing(view: android.view.View, busy: jboolean),
2396 static fn setNavRowMenus(nav_menu: android.view.View, joined_specs: JString),
2397 static fn setNavSearch(nav_host: android.view.View, id: jlong, prompt: JString, text: JString, hides_on_scroll: jboolean, initially_hidden: jboolean),
2398 static fn setNavSearchText(nav_host: android.view.View, text: JString),
2399 static fn setNavSuiteRows(menu: android.view.View, titles: JString, icons: JString, badges: JString, menu_node: jlong),
2400 static fn updateNavMenuRows(v: android.view.View, joined_rows: JString, joined_items: JString, joined_icons: JString),
2401 static fn setNavSuiteSelected(suite: android.view.View, index: jint),
2402 static fn setOpacity(v: android.view.View, alpha: jfloat, timing: jint[], keys: jfloat[]),
2403 static fn setPlaceholder(v: android.view.View, value: JString),
2404 static fn setPrimaryWindowTitle(title: JString),
2405 static fn setProgress(v: android.view.View, fraction: jdouble),
2406 static fn setScrollContent(v: android.view.View, w: jint, h: jint),
2407 static fn setSectionCard(v: android.view.View, radius_px: jfloat),
2408 static fn setSlider(v: android.view.View, value: jdouble, ignored_min: jdouble),
2409 static fn setStatusBarHidden(hidden: jboolean),
2410 static fn setSurface(v: android.view.View, argb: jint, has_bg: jboolean, radius_px: jfloat, clips: jboolean),
2411 static fn setSurfaceFill(v: android.view.View, argb: jint, has_bg: jboolean),
2412 static fn animateSurfaceFill(v: android.view.View, argb: jint, has_bg: jboolean, timing: jint[], keys: jfloat[]),
2413 static fn setSurfaceStyle(v: android.view.View, spec: jdouble[], clips: jboolean),
2414 static fn setSurfaceGradient(v: android.view.View, spec: jdouble[]),
2415 static fn resetSurface(v: android.view.View),
2416 static fn setTextField(v: android.view.View, value: JString),
2417 static fn setTextFieldSelection(v: android.view.View, start: jint, end: jint),
2418 static fn setToggle(v: android.view.View, value: jboolean),
2419 static fn setTransform(v: android.view.View, tx: jfloat, ty: jfloat, sx: jfloat, sy: jfloat, rot: jfloat, timing: jint[], keys: jfloat[]),
2420 static fn readDisplayed(v: android.view.View) -> jdouble[],
2421 static fn setWindowSecure(node: jlong, on: jboolean),
2422 static fn setWindowState(node: jlong, code: jint),
2423 static fn setWindowSurface(v: android.view.View, radius_px: jfloat, clips: jboolean),
2424 static fn setWindowTitle(node: jlong, title: JString),
2425 static fn setWindowToolbar(root: android.view.View, spec: JString),
2426 static fn share(url: JString, title: JString, actions: JString) -> jboolean,
2427 static fn snapshotOrigin(root: android.view.View) -> JString,
2428 static fn treeExpand(view: android.view.View, token: jlong, open: jboolean),
2429 static fn treeReload(view: android.view.View, data: JString),
2430 static fn treeReveal(view: android.view.View, token: jlong),
2431 static fn treeSelection(view: android.view.View),
2432 static fn uiIdle() -> jboolean,
2433 static fn updateNavMenu(v: android.view.View, joined_items: JString, joined_icons: JString, joined_sections: JString),
2434 static fn updateWindowToolbar(root: android.view.View, id: JString, op: jint, num: jdouble),
2435 static fn updateWindowToolbarText(root: android.view.View, id: JString, text: JString),
2436 static fn windowImage(chrome: jboolean) -> jbyte[],
2437 static fn postMain(token: jlong),
2439 static fn postMainDelayed(token: jlong, delay_ms: jlong),
2440 },
2441 native_methods {
2444 static fn nativeOnEvent(id: jlong, kind: jint, num: jdouble, text: JString),
2445 static fn nativeHandlesKeys(id: jlong) -> jboolean,
2446 static fn nativeHandlesText(id: jlong) -> jboolean,
2447 static fn nativeContextMenu(token: jlong, x: jfloat, y: jfloat) -> JString,
2448 static fn nativeButtonMenu(token: jlong) -> JString,
2449 static fn nativeRunPosted(token: jlong),
2450 static fn nativeDoFrame(token: jlong, frame_time_nanos: jlong),
2451 static fn nativeListLen(host_id: jlong) -> jint,
2452 static fn nativeListBind(host_id: jlong, position: jint, cell: android.view.View),
2453 static fn nativeListBindPinned(host_id: jlong, position: jint, cell: android.view.View),
2454 static fn nativeListRecycle(host_id: jlong, cell: android.view.View),
2455 static fn nativeListIsSelected(host_id: jlong, position: jint) -> jboolean,
2456 static fn nativeListRowKind(host_id: jlong, position: jint) -> jint,
2457 static fn nativeListViewport(host_id: jlong, first: jint, last: jint, end_px: jint),
2458 static fn nativeListReaderScroll(host_id: jlong),
2459 static fn nativeListHeaderOf(host_id: jlong, position: jint) -> jint,
2460 static fn nativeListCanDrop(host_id: jlong, from: jint, to: jint) -> jboolean,
2461 static fn nativeListMove(host_id: jlong, from: jint, to: jint) -> jboolean,
2462 static fn nativeListCanDelete(host_id: jlong, index: jint) -> jboolean,
2463 static fn nativeListDelete(host_id: jlong, index: jint) -> jboolean,
2464 },
2465 }
2466
2467 pub(crate) mod framework {
2471 crate::java_class! {
2473 pub DayListItem => dev.daybrite.day.bridge.DayListItem,
2474 methods {
2475 static fn make(title: JString, subtitle: JString, detail: JString, icon: JString,
2476 tint: jint, checked: jboolean) -> android.view.View,
2477 static fn setTexts(v: android.view.View, title: JString, subtitle: JString,
2478 detail: JString),
2479 static fn setIcon(v: android.view.View, name: JString, tint: jint),
2480 static fn setChecked(v: android.view.View, on: jboolean),
2481 },
2482 }
2483
2484 crate::java_class! {
2485 pub System => java.lang.System,
2486 methods {
2487 static fn identityHashCode(object: JObject) -> jint,
2488 },
2489 }
2490
2491 crate::java_class! {
2492 pub Context => android.content.Context,
2493 methods {
2494 fn getAssets() -> android.content.res.AssetManager,
2495 },
2496 }
2497
2498 crate::java_class! {
2499 pub View => android.view.View,
2500 methods {
2501 fn getWidth() -> jint,
2502 fn setPointerIcon(icon: android.view.PointerIcon),
2503 },
2504 }
2505
2506 crate::java_class! {
2507 pub TextView => android.widget.TextView,
2508 methods {
2509 fn setTextIsSelectable(selectable: jboolean),
2510 },
2511 }
2512
2513 crate::java_class! {
2514 pub PointerIcon => android.view.PointerIcon,
2515 methods {
2516 static fn getSystemIcon(context: android.content.Context, kind: jint)
2517 -> android.view.PointerIcon,
2518 },
2519 }
2520 }
2521
2522 crate::java_class! {
2525 DayTransfer => dev.daybrite.day.bridge.DayTransfer,
2526 methods {
2527 static fn source(view: android.view.View, token: jlong),
2528 static fn target(view: android.view.View, token: jlong),
2529 static fn release(view: android.view.View),
2530 },
2531 native_methods {
2532 static fn nativeCall(kind: jint, token: jlong, x: jdouble, y: jdouble, bytes: jbyte[],
2533 local: jboolean) -> jbyte[],
2534 },
2535 }
2536
2537 crate::java_class! {
2540 DayCanvasView => dev.daybrite.day.bridge.DayCanvasView,
2541 methods {
2542 static fn exportError() -> JString,
2543 static fn renderBitmap(id: jlong, nums: jdouble[], texts_joined: JString,
2544 geometry: jdouble[], pw: jint, ph: jint, scale: jdouble) -> JString,
2545 static fn renderPdf(nums: jdouble[], num_counts: jint[], texts_joined: JString,
2546 text_counts: jint[], sizes: jdouble[]) -> jbyte[],
2547 },
2548 }
2549
2550 impl DayBridgeNativeInterface for DayBridgeAPI {
2554 type Error = jni::errors::Error;
2555
2556 fn nativeOnEvent<'l>(
2557 env: &mut Env<'l>,
2558 _class: JClass<'l>,
2559 id: i64,
2560 kind: i32,
2561 num: f64,
2562 text: JString<'l>,
2563 ) -> Result<(), Self::Error> {
2564 dispatch_event(env, id, kind, num, &text);
2565 Ok(())
2566 }
2567
2568 fn nativeContextMenu<'l>(
2569 env: &mut Env<'l>,
2570 _class: JClass<'l>,
2571 token: i64,
2572 x: f32,
2573 y: f32,
2574 ) -> Result<JString<'l>, Self::Error> {
2575 let spec = day_spec::ffi_guard::contain(String::new(), || {
2576 let provider = CONTEXT_MENU_FNS.with(|menus| menus.get(token as usize));
2578 let mut spec = String::new();
2579 if let Some(provider) = provider {
2580 let items = provider(Point {
2581 x: f64::from(x) / density(),
2582 y: f64::from(y) / density(),
2583 });
2584 serialize_menu(&items, &mut spec);
2585 }
2586 spec
2587 });
2588 env.new_string(spec)
2589 }
2590
2591 fn nativeButtonMenu<'l>(
2592 env: &mut Env<'l>,
2593 _class: JClass<'l>,
2594 token: i64,
2595 ) -> Result<JString<'l>, Self::Error> {
2596 let spec = day_spec::ffi_guard::contain(String::new(), || {
2597 let provider = BUTTON_MENU_FNS.with(|menus| menus.get(token as usize));
2599 let mut spec = String::new();
2600 if let Some(provider) = provider {
2601 let still = || {
2603 BUTTON_MENU_FNS
2604 .with(|menus| menus.get(token as usize))
2605 .is_some()
2606 };
2607 if let Some(items) = day_spec::resolve_button_menu(&provider, still) {
2608 serialize_menu(&items, &mut spec);
2609 }
2610 }
2611 spec
2612 });
2613 env.new_string(spec)
2614 }
2615
2616 fn nativeHandlesKeys<'l>(
2617 _env: &mut Env<'l>,
2618 _class: JClass<'l>,
2619 id: i64,
2620 ) -> Result<bool, Self::Error> {
2621 Ok(handles_keys(id))
2622 }
2623
2624 fn nativeHandlesText<'l>(
2625 _env: &mut Env<'l>,
2626 _class: JClass<'l>,
2627 id: i64,
2628 ) -> Result<bool, Self::Error> {
2629 Ok(handles_text(id))
2630 }
2631
2632 fn nativeRunPosted<'l>(
2633 _env: &mut Env<'l>,
2634 _class: JClass<'l>,
2635 token: i64,
2636 ) -> Result<(), Self::Error> {
2637 run_posted(token);
2638 Ok(())
2639 }
2640
2641 fn nativeDoFrame<'l>(
2642 _env: &mut Env<'l>,
2643 _class: JClass<'l>,
2644 token: i64,
2645 frame_time_nanos: i64,
2646 ) -> Result<(), Self::Error> {
2647 run_frame(token, frame_time_nanos);
2648 Ok(())
2649 }
2650
2651 fn nativeListLen<'l>(
2652 _env: &mut Env<'l>,
2653 _class: JClass<'l>,
2654 host_id: i64,
2655 ) -> Result<i32, Self::Error> {
2656 Ok(i32::try_from(list_len(host_id)).unwrap_or(i32::MAX))
2657 }
2658
2659 fn nativeListBind<'l>(
2660 env: &mut Env<'l>,
2661 _class: JClass<'l>,
2662 host_id: i64,
2663 position: i32,
2664 cell: JObject<'l>,
2665 ) -> Result<(), Self::Error> {
2666 list_bind(env, host_id, position, cell, false);
2667 Ok(())
2668 }
2669
2670 fn nativeListBindPinned<'l>(
2671 env: &mut Env<'l>,
2672 _class: JClass<'l>,
2673 host_id: i64,
2674 position: i32,
2675 cell: JObject<'l>,
2676 ) -> Result<(), Self::Error> {
2677 list_bind(env, host_id, position, cell, true);
2678 Ok(())
2679 }
2680
2681 fn nativeListRecycle<'l>(
2682 env: &mut Env<'l>,
2683 _class: JClass<'l>,
2684 host_id: i64,
2685 cell: JObject<'l>,
2686 ) -> Result<(), Self::Error> {
2687 list_recycle(env, host_id, cell);
2688 Ok(())
2689 }
2690
2691 fn nativeListIsSelected<'l>(
2692 _env: &mut Env<'l>,
2693 _class: JClass<'l>,
2694 host_id: i64,
2695 position: i32,
2696 ) -> Result<bool, Self::Error> {
2697 Ok(list_is_selected(host_id, position))
2698 }
2699
2700 fn nativeListRowKind<'l>(
2701 _env: &mut Env<'l>,
2702 _class: JClass<'l>,
2703 host_id: i64,
2704 position: i32,
2705 ) -> Result<i32, Self::Error> {
2706 Ok(list_row_kind(host_id, position))
2707 }
2708
2709 fn nativeListViewport<'l>(
2710 _env: &mut Env<'l>,
2711 _class: JClass<'l>,
2712 host_id: i64,
2713 first: i32,
2714 last: i32,
2715 end_px: i32,
2716 ) -> Result<(), Self::Error> {
2717 list_viewport(host_id, first, last, end_px);
2718 Ok(())
2719 }
2720
2721 fn nativeListReaderScroll<'l>(
2722 _env: &mut Env<'l>,
2723 _class: JClass<'l>,
2724 host_id: i64,
2725 ) -> Result<(), Self::Error> {
2726 list_reader_scroll(host_id);
2727 Ok(())
2728 }
2729
2730 fn nativeListHeaderOf<'l>(
2731 _env: &mut Env<'l>,
2732 _class: JClass<'l>,
2733 host_id: i64,
2734 position: i32,
2735 ) -> Result<i32, Self::Error> {
2736 Ok(list_header_of(host_id, position))
2737 }
2738
2739 fn nativeListCanDrop<'l>(
2740 _env: &mut Env<'l>,
2741 _class: JClass<'l>,
2742 host_id: i64,
2743 from: i32,
2744 to: i32,
2745 ) -> Result<bool, Self::Error> {
2746 Ok(list_can_drop(host_id, from, to))
2747 }
2748
2749 fn nativeListMove<'l>(
2750 _env: &mut Env<'l>,
2751 _class: JClass<'l>,
2752 host_id: i64,
2753 from: i32,
2754 to: i32,
2755 ) -> Result<bool, Self::Error> {
2756 Ok(list_move(host_id, from, to))
2757 }
2758
2759 fn nativeListCanDelete<'l>(
2760 _env: &mut Env<'l>,
2761 _class: JClass<'l>,
2762 host_id: i64,
2763 index: i32,
2764 ) -> Result<bool, Self::Error> {
2765 Ok(list_can_delete(host_id, index))
2766 }
2767
2768 fn nativeListDelete<'l>(
2769 _env: &mut Env<'l>,
2770 _class: JClass<'l>,
2771 host_id: i64,
2772 index: i32,
2773 ) -> Result<bool, Self::Error> {
2774 Ok(list_delete(host_id, index))
2775 }
2776 }
2777
2778 impl DayTransferNativeInterface for DayTransferAPI {
2779 type Error = jni::errors::Error;
2780
2781 #[allow(clippy::too_many_arguments)]
2782 fn nativeCall<'l>(
2783 env: &mut Env<'l>,
2784 _class: JClass<'l>,
2785 kind: i32,
2786 token: i64,
2787 x: f64,
2788 y: f64,
2789 bytes: jni::objects::JByteArray<'l>,
2790 local: bool,
2791 ) -> Result<jni::objects::JByteArray<'l>, Self::Error> {
2792 transfer_call(env, kind, token, x, y, bytes, local)
2793 }
2794 }
2795
2796 #[derive(Clone)]
2797 pub struct AHandle(pub Gref);
2798
2799 #[allow(non_camel_case_types)]
2803 mod aasset {
2804 use std::os::raw::{c_char, c_int, c_void};
2805 pub enum AAssetManager {}
2806 pub enum AAsset {}
2807 pub const AASSET_MODE_BUFFER: c_int = 3;
2808 #[link(name = "android")]
2809 unsafe extern "C" {
2810 pub fn AAssetManager_fromJava(
2811 env: *mut jni::sys::JNIEnv,
2812 mgr: jni::sys::jobject,
2813 ) -> *mut AAssetManager;
2814 pub fn AAssetManager_open(
2815 mgr: *mut AAssetManager,
2816 filename: *const c_char,
2817 mode: c_int,
2818 ) -> *mut AAsset;
2819 pub fn AAsset_getBuffer(asset: *mut AAsset) -> *const c_void;
2820 pub fn AAsset_getLength64(asset: *mut AAsset) -> i64;
2821 pub fn AAsset_close(asset: *mut AAsset);
2822 }
2823 }
2824
2825 struct AssetMgr {
2827 aam: *mut aasset::AAssetManager,
2828 _keepalive: Global<JObject<'static>>,
2829 }
2830 unsafe impl Send for AssetMgr {}
2832 unsafe impl Sync for AssetMgr {}
2833 static ASSET_MGR: OnceLock<AssetMgr> = OnceLock::new();
2834
2835 fn register_resource_opener(env: &mut Env) {
2837 let Some(keepalive) = java_in(env, |env| {
2839 let ctx = DayRuntime::ctx(env)?;
2840 let am = unsafe { env.as_cast_unchecked::<framework::Context>(&ctx) }.getAssets(env)?;
2842 env.new_global_ref(am)
2843 }) else {
2844 return;
2845 };
2846 let aam =
2847 unsafe { aasset::AAssetManager_fromJava(env.get_raw(), keepalive.as_obj().as_raw()) };
2848 if aam.is_null() {
2849 return;
2850 }
2851 let _ = ASSET_MGR.set(AssetMgr {
2852 aam,
2853 _keepalive: keepalive,
2854 });
2855 day_spec::resource::set_resource_opener(open_resource);
2856 }
2857
2858 fn open_resource(name: &str) -> Option<day_spec::resource::Resource> {
2860 struct AssetGuard(*mut aasset::AAsset);
2861 impl Drop for AssetGuard {
2862 fn drop(&mut self) {
2863 unsafe { aasset::AAsset_close(self.0) };
2864 }
2865 }
2866 let mgr = ASSET_MGR.get()?.aam;
2867 let cname = std::ffi::CString::new(name).ok()?;
2868 let asset =
2869 unsafe { aasset::AAssetManager_open(mgr, cname.as_ptr(), aasset::AASSET_MODE_BUFFER) };
2870 if asset.is_null() {
2871 return None;
2872 }
2873 let len = unsafe { aasset::AAsset_getLength64(asset) };
2874 let ptr = unsafe { aasset::AAsset_getBuffer(asset) }.cast::<u8>();
2875 if ptr.is_null() || len < 0 {
2876 unsafe { aasset::AAsset_close(asset) };
2877 return None;
2878 }
2879 Some(unsafe {
2881 day_spec::resource::Resource::from_raw(ptr, len as usize, Box::new(AssetGuard(asset)))
2882 })
2883 }
2884
2885 type Sink = Rc<dyn Fn(NodeId, Event)>;
2887
2888 pub fn emit(id: NodeId, ev: Event) {
2889 let sink = SINK.with(|s| s.borrow().clone());
2890 if let Some(sink) = sink {
2891 sink(id, ev);
2892 }
2893 }
2894
2895 fn density() -> f64 {
2896 DENSITY.with(std::cell::Cell::get)
2897 }
2898
2899 fn pointer_icon_type(c: &Cursor) -> Option<i32> {
2905 Some(match c {
2906 Cursor::Default => return None,
2907 Cursor::Pointer => 1002,
2908 Cursor::Text => 1008,
2909 Cursor::VerticalText => 1009,
2910 Cursor::Crosshair => 1007,
2911 Cursor::Move => 1013,
2912 Cursor::Grab => 1020,
2913 Cursor::Grabbing => 1021,
2914 Cursor::NotAllowed => 1012,
2915 Cursor::Wait | Cursor::Progress => 1004,
2916 Cursor::Help => 1003,
2917 Cursor::ContextMenu => 1001,
2918 Cursor::Copy => 1011,
2919 Cursor::Alias => 1010,
2920 Cursor::Cell => 1006,
2921 Cursor::ZoomIn => 1018,
2922 Cursor::ZoomOut => 1019,
2923 Cursor::None => 0,
2924 Cursor::NsResize | Cursor::RowResize => 1015,
2925 Cursor::EwResize | Cursor::ColResize => 1014,
2926 Cursor::NeswResize => 1016,
2927 Cursor::NwseResize => 1017,
2928 Cursor::Native(name) => match &**name {
2929 "all_scroll" => 1013,
2930 "no_drop" => 1012,
2931 "top_right_diagonal_double_arrow" => 1016,
2932 "top_left_diagonal_double_arrow" => 1017,
2933 _ => return None,
2934 },
2935 })
2936 }
2937
2938 pub fn view_handle(env: &mut Env, view: JObject) -> jni::errors::Result<AHandle> {
2946 if view.is_null() {
2947 return Err(jni::errors::Error::NullPtr("factory returned a null View"));
2948 }
2949 Ok(AHandle(std::sync::Arc::new(env.new_global_ref(view)?)))
2950 }
2951
2952 pub fn realize<F>(what: &str, make: F) -> AHandle
2961 where
2962 F: for<'a, 'l> FnOnce(&'a mut Env<'l>) -> jni::errors::Result<JObject<'l>>,
2963 {
2964 java(|env| {
2965 let view = make(env)?;
2966 view_handle(env, view)
2967 })
2968 .unwrap_or_else(|| {
2969 log::warn!(
2970 "day-toolkit-material: {what}: the Java factory failed; substituting a placeholder"
2971 );
2972 AHandle(with_env(|env| placeholder_view(env, what)))
2973 })
2974 }
2975
2976 #[must_use]
2978 pub fn argb(c: day_spec::Color) -> i32 {
2979 let f = |v: f64| (v.clamp(0.0, 1.0) * 255.0) as u32;
2980 ((f(c.a) << 24) | (f(c.r) << 16) | (f(c.g) << 8) | f(c.b)) as i32
2981 }
2982
2983 fn apply_button_content(
2984 env: &mut Env,
2985 view: &Gref,
2986 title: &str,
2987 icon: Option<&day_spec::Icon>,
2988 icon_only: bool,
2989 ) {
2990 let title = jstr(env, title);
2991 let icon = jstr(env, &icon_name(icon));
2992 let _ = java_in(env, |env| {
2993 DayBridge::setButtonContent(env, view.as_obj(), &title, &icon, icon_only)
2994 });
2995 }
2996
2997 pub fn apply_button_style(env: &mut Env, v: &Gref, style: day_spec::props::ButtonStyleSpec) {
3000 use day_spec::props::ButtonStyleSpec as S;
3001 let (kind, fill) = match style {
3002 S::Automatic => (0, day_spec::Color::CLEAR),
3003 S::Bordered => (1, day_spec::Color::CLEAR),
3004 S::Prominent => (2, day_spec::Color::CLEAR),
3005 S::Tinted(c) => (3, c.resolved()),
3006 S::Compact => (4, day_spec::Color::CLEAR),
3008 S::Plain => (5, day_spec::Color::CLEAR),
3009 };
3010 let _ = java_in(env, |env| {
3011 DayBridge::setButtonStyle(env, v.as_obj(), kind, argb(fill), argb(S::on_tint(fill)))
3012 });
3013 }
3014
3015 pub fn set_label_runs(
3020 env: &mut Env,
3021 node: i64,
3022 v: &Gref,
3023 text: &str,
3024 runs: &[day_spec::TextRun],
3025 ) {
3026 let mut starts = Vec::with_capacity(runs.len());
3029 let mut ends = Vec::with_capacity(runs.len());
3030 let mut flags = Vec::with_capacity(runs.len());
3031 let mut colors = Vec::with_capacity(runs.len());
3032 let mut backgrounds = Vec::with_capacity(runs.len());
3033 let mut scales = Vec::with_capacity(runs.len());
3036 let mut links: Vec<Option<String>> = Vec::with_capacity(runs.len());
3037 let mut decorations = Vec::new();
3039 for r in runs {
3040 let Some(slice) = text.get(r.range.clone()) else {
3041 continue;
3042 };
3043 let start = text[..r.range.start].encode_utf16().count() as i32;
3044 let end = start + slice.encode_utf16().count() as i32;
3045 starts.push(start);
3046 ends.push(end);
3047 let f = crate::text_wire::run_flags(r);
3048 crate::text_wire::decoration_entries(r, start, end, &mut decorations);
3049 flags.push(f);
3050 colors.push(r.color.map_or(0, |c| argb(c.resolved())));
3051 backgrounds.push(r.background.map_or(0, |c| argb(c.resolved())));
3052 scales.push((r.font.scale * 1000.0).round() as i32);
3053 links.push(r.link.clone());
3054 }
3055 let (Ok(sa), Ok(se), Ok(sf), Ok(sc), Ok(sb), Ok(sz), Ok(sd)) = (
3056 env.new_int_array(starts.len()),
3057 env.new_int_array(ends.len()),
3058 env.new_int_array(flags.len()),
3059 env.new_int_array(colors.len()),
3060 env.new_int_array(backgrounds.len()),
3061 env.new_int_array(scales.len()),
3062 env.new_int_array(decorations.len()),
3063 ) else {
3064 return;
3065 };
3066 if sa.set_region(env, 0, &starts).is_err()
3067 || se.set_region(env, 0, &ends).is_err()
3068 || sf.set_region(env, 0, &flags).is_err()
3069 || sc.set_region(env, 0, &colors).is_err()
3070 || sb.set_region(env, 0, &backgrounds).is_err()
3071 || sz.set_region(env, 0, &scales).is_err()
3072 || sd.set_region(env, 0, &decorations).is_err()
3073 {
3074 return;
3075 }
3076 let joined = links
3080 .iter()
3081 .map(|l| l.clone().unwrap_or_default())
3082 .collect::<Vec<_>>()
3083 .join("\u{1f}");
3084 let s = jstr(env, text);
3085 let jl = jstr(env, &joined);
3086 let _ = java_in(env, |env| {
3087 DayBridge::setLabelRuns(
3088 env,
3089 v.as_obj(),
3090 node,
3091 &s,
3092 &sa,
3093 &se,
3094 &sf,
3095 &sc,
3096 &sb,
3097 &sz,
3098 &jl,
3099 &sd,
3100 )
3101 });
3102 }
3103
3104 fn bridge_view<F>(env: &mut Env, what: &str, make: F) -> Gref
3107 where
3108 F: for<'a, 'l> FnOnce(&'a mut Env<'l>) -> jni::errors::Result<JObject<'l>>,
3109 {
3110 match try_bridge_view(env, make) {
3111 Ok(g) => g,
3112 Err(e) => {
3113 log::warn!(
3114 "day-toolkit-material: DayBridge.{what} failed ({e}); substituting a placeholder view"
3115 );
3116 placeholder_view(env, what)
3117 }
3118 }
3119 }
3120
3121 fn try_bridge_view<F>(env: &mut Env, make: F) -> Result<Gref, jni::errors::Error>
3124 where
3125 F: for<'a, 'l> FnOnce(&'a mut Env<'l>) -> jni::errors::Result<JObject<'l>>,
3126 {
3127 let made = match make(env) {
3128 Ok(view) => view_handle(env, view).map(|h| h.0),
3129 Err(e) => Err(e),
3130 };
3131 if made.is_err() && env.exception_check() {
3132 env.exception_describe();
3133 env.exception_clear();
3134 }
3135 made
3136 }
3137
3138 pub fn placeholder_view(env: &mut Env, what: &str) -> Gref {
3146 let text = format!("⟨{what}⟩");
3147 try_bridge_view(env, |env| {
3148 let text = JString::from_str(env, &text)?;
3149 DayBridge::makeLabel(env, &text)
3150 })
3151 .expect("day-toolkit-material: DayBridge.makeLabel unavailable — bridge not staged?")
3154 }
3155
3156 fn bridge(call: impl FnOnce(&mut Env) -> jni::errors::Result<()>) {
3158 let _ = java(call);
3159 }
3160
3161 fn anim_arrays<'local>(
3165 env: &mut Env<'local>,
3166 anim: Option<&AnimSpec>,
3167 ) -> jni::errors::Result<(
3168 jni::objects::JIntArray<'local>,
3169 jni::objects::JFloatArray<'local>,
3170 )> {
3171 let timing = crate::motion_wire::timing(anim);
3172 let keys = crate::motion_wire::keys(anim);
3173 let t = env.new_int_array(timing.len())?;
3174 t.set_region(env, 0, &timing)?;
3175 let k = env.new_float_array(keys.len())?;
3176 k.set_region(env, 0, &keys)?;
3177 Ok((t, k))
3178 }
3179
3180 fn apply_surface(h: &AHandle, bg: Option<day_spec::Color>, corner_radius: f64, clips: bool) {
3184 let d = DENSITY.with(std::cell::Cell::get);
3185 bridge(|env| {
3186 DayBridge::setSurface(
3187 env,
3188 h.0.as_obj(),
3189 bg.map_or(0, argb_i32),
3190 bg.is_some(),
3191 (corner_radius * d) as f32,
3192 clips,
3193 )
3194 });
3195 }
3196
3197 fn apply_styled_surface(h: &AHandle, p: &ContainerProps) {
3200 let spec = super::surface_spec(p, DENSITY.with(std::cell::Cell::get));
3201 bridge(|env| {
3202 let arr = env.new_double_array(spec.len())?;
3203 arr.set_region(env, 0, &spec)?;
3204 DayBridge::setSurfaceStyle(env, h.0.as_obj(), &arr, p.clips)
3205 });
3206 }
3207
3208 fn apply_container_surface(h: &AHandle, p: &ContainerProps, fresh: bool) {
3214 if !fresh {
3215 bridge(|env| DayBridge::resetSurface(env, h.0.as_obj()));
3216 }
3217 if super::is_styled_surface(p) {
3218 apply_styled_surface(h, p);
3219 } else if p.fill.is_some() || p.corner_radius > 0.0 || p.clips {
3220 apply_surface(
3221 h,
3222 super::solid_fill(p.fill.as_ref()),
3223 p.corner_radius,
3224 p.clips,
3225 );
3226 }
3227 }
3228
3229 fn measure_call<F>(h: &AHandle, measure: F) -> f64
3232 where
3233 F: for<'a, 'l> FnOnce(&'a mut Env<'l>, &JObject) -> jni::errors::Result<i32>,
3234 {
3235 f64::from(java(|env| measure(env, h.0.as_obj())).unwrap_or(0))
3236 }
3237
3238 pub fn init(env: &mut Env, root: JObject, density_: f32, w: i32, h: i32) {
3241 day_spec::ffi_guard::contain((), || {
3242 LIST_SOURCES.with(|m| m.borrow_mut().clear());
3252 LIST_NODE.with(|m| m.borrow_mut().clear());
3253 LIST_CELLS.with(|m| m.borrow_mut().clear());
3254 LIST_BINDINGS.with(|m| m.borrow_mut().clear());
3255 LIST_SELECTED.with(|m| m.borrow_mut().clear());
3256 LIST_AUTOMATIC.with(|m| m.borrow_mut().clear());
3257 NAV_MENU_ROWS.with(|m| m.borrow_mut().clear());
3258 NAV_SUITES.with(|m| m.borrow_mut().clear());
3259 WINDOW_BARS.with(|m| m.borrow_mut().clear());
3260 LABEL_NODE.with(|m| m.borrow_mut().clear());
3261 SECONDARY.with(|m| m.borrow_mut().clear());
3264 if java_in(env, |env| {
3265 let class = env.find_class(jni::jni_str!("dev/daybrite/day/bridge/DayRuntime"))?;
3266 day_platform_android::init(env, &class)
3267 })
3268 .is_none()
3269 {
3270 return;
3271 }
3272 day_process::services::initialize();
3273 register_resource_opener(env);
3274 let d = f64::from(density_);
3275 DENSITY.with(|x| x.set(d));
3276 let Ok(root_ref) = env.new_global_ref(root) else {
3279 log::error!(
3280 "day-toolkit-material: init could not take a global ref on the root view"
3281 );
3282 return;
3283 };
3284 let handle = AHandle(std::sync::Arc::new(root_ref));
3285 let size = Size::new(f64::from(w) / d, f64::from(h) / d);
3286 ROOT.with(|r| *r.borrow_mut() = Some((handle, size)));
3287 if let Some(path) = java_in(env, |env| {
3291 let dir = DayRuntime::cacheDirPath(env)?;
3292 string_of(env, &dir)
3293 }) && !path.is_empty()
3294 {
3295 day_spec::present::set_app_temp_dir(path);
3296 }
3297 });
3298 }
3299
3300 #[expect(
3305 clippy::needless_pass_by_value,
3306 reason = "public signature; the JNI entry hands over the root's local reference"
3307 )]
3308 pub fn window_started(env: &mut Env, root: JObject, node: i64, w: i32, h: i32) -> bool {
3309 day_spec::ffi_guard::contain(false, || {
3311 let d = DENSITY.with(std::cell::Cell::get);
3312 let Ok(gref) = env.new_global_ref(&root) else {
3313 return false;
3314 };
3315 let gref = std::sync::Arc::new(gref);
3316 let raw = gref.as_obj().as_raw() as day_spec::RawHandle;
3317 SECONDARY.with(|s| s.borrow_mut().push((node as u64, gref)));
3318 let ok = day_core::finish_window_open(
3319 day_spec::NodeId(node as u64),
3320 raw,
3321 Size::new(f64::from(w) / d, f64::from(h) / d),
3322 );
3323 if !ok {
3324 SECONDARY.with(|s| s.borrow_mut().retain(|(n, _)| *n != node as u64));
3325 }
3326 ok
3327 })
3328 }
3329
3330 fn secondary_node_of(env: &mut Env, host: &AHandle) -> Option<u64> {
3332 SECONDARY.with(|s| {
3333 s.borrow()
3334 .iter()
3335 .find(|(_, gref)| {
3336 env.is_same_object(host.0.as_obj(), gref.as_obj())
3337 .unwrap_or(false)
3338 })
3339 .map(|(n, _)| *n)
3340 })
3341 }
3342
3343 const K_PRESSED: i32 = bridge::BridgeKind::Pressed as i32;
3346 const K_TEXT_CHANGED: i32 = bridge::BridgeKind::TextChanged as i32;
3347 const K_TOGGLE_CHANGED: i32 = bridge::BridgeKind::ToggleChanged as i32;
3348 const K_VALUE_CHANGED: i32 = bridge::BridgeKind::ValueChanged as i32;
3349 const K_VALUE_COMMITTED: i32 = bridge::BridgeKind::ValueCommitted as i32;
3350 const K_SEARCH_CHANGED: i32 = bridge::BridgeKind::SearchChanged as i32;
3351 const K_NAV_PRESENTATION: i32 = bridge::BridgeKind::NavPresentation as i32;
3352 const K_LIST_ACTIVATED: i32 = bridge::BridgeKind::ListActivated as i32;
3353 const K_SELECTION_CHANGED: i32 = bridge::BridgeKind::SelectionChanged as i32;
3354 const K_NAV_BACK: i32 = bridge::BridgeKind::NavBack as i32;
3355 const K_FRAME_CHANGED: i32 = bridge::BridgeKind::FrameChanged as i32;
3356 const K_DEEPLINK: i32 = bridge::BridgeKind::Deeplink as i32;
3357 const K_PRESENT_BUTTON: i32 = bridge::BridgeKind::PresentButton as i32;
3358 const K_PRESENT_TEXT: i32 = bridge::BridgeKind::PresentText as i32;
3359 const K_PRESENT_DISMISSED: i32 = bridge::BridgeKind::PresentDismissed as i32;
3360 const K_GESTURE: i32 = bridge::BridgeKind::Gesture as i32;
3361 const K_CUSTOM: i32 = bridge::BridgeKind::Custom as i32;
3362 const K_MENU_ACTION: i32 = bridge::BridgeKind::MenuAction as i32;
3363 const K_LIFECYCLE: i32 = bridge::BridgeKind::Lifecycle as i32;
3364 const K_PRESENT_FILE: i32 = bridge::BridgeKind::PresentFile as i32;
3365 const K_FOCUS_CHANGED: i32 = bridge::BridgeKind::FocusChanged as i32;
3366 const K_SUBMITTED: i32 = bridge::BridgeKind::Submitted as i32;
3367 const K_WINDOW_RESIZED: i32 = bridge::BridgeKind::WindowResized as i32;
3368 const K_SAFE_AREA: i32 = bridge::BridgeKind::SafeArea as i32;
3369 const K_WINDOW_CLOSED: i32 = bridge::BridgeKind::WindowClosed as i32;
3370 const K_WINDOW_FOCUSED: i32 = bridge::BridgeKind::WindowFocused as i32;
3371 const K_APPEARANCE_CHANGED: i32 = bridge::BridgeKind::AppearanceChanged as i32;
3372 const K_REDUCE_MOTION_CHANGED: i32 = bridge::BridgeKind::ReduceMotionChanged as i32;
3373 const K_COVER_HIDDEN: i32 = bridge::BridgeKind::CoverHidden as i32;
3374 const K_LINK_ACTIVATED: i32 = bridge::BridgeKind::LinkActivated as i32;
3375 const K_TOOLBAR_CHANGED: i32 = bridge::BridgeKind::ToolbarChanged as i32;
3376 const K_KEY: i32 = bridge::BridgeKind::Key as i32;
3377 const K_TEXT: i32 = bridge::BridgeKind::Text as i32;
3378 const K_WINDOW_STATE_CHANGED: i32 = bridge::BridgeKind::WindowStateChanged as i32;
3379
3380 pub fn dispatch_event(env: &mut Env, id: i64, kind: i32, num: f64, jstr: &JString) {
3385 day_spec::ffi_guard::contain((), || {
3386 dispatch_event_inner(env, id, kind, num, jstr);
3387 });
3388 }
3389
3390 #[must_use]
3394 pub fn handles_keys(id: i64) -> bool {
3395 day_spec::ffi_guard::contain(false, || day_spec::keys::handled(NodeId(id as u64)))
3396 }
3397
3398 #[must_use]
3402 pub fn handles_text(id: i64) -> bool {
3403 day_spec::ffi_guard::contain(false, || day_spec::keys::text(NodeId(id as u64)))
3404 }
3405
3406 fn dispatch_event_inner(env: &mut Env, id: i64, kind: i32, num: f64, jstr: &JString) {
3407 if kind == K_CUSTOM {
3408 let text = string_of(env, jstr).ok().unwrap_or_default();
3409 if text == "day:will-recreate" {
3412 save_route_for_remount(env);
3413 return;
3414 }
3415 if let Some(payload) = text.strip_prefix(crate::text_wire::SELECTION_PREFIX) {
3420 if let Some((start, end)) = crate::text_wire::selection(payload) {
3421 emit(NodeId(id as u64), Event::TextSelected { start, end });
3422 }
3423 return;
3424 }
3425 if let Some(payload) = text.strip_prefix(crate::list_wire::OFFSET_PREFIX) {
3428 if let Some(at) = crate::list_wire::offset(payload, density()) {
3429 emit(NodeId(id as u64), Event::ScrollChanged(at));
3430 }
3431 return;
3432 }
3433 if let Some(payload) = text.strip_prefix(crate::list_wire::PHASE_PREFIX) {
3434 if let Some(phase) = crate::list_wire::phase(payload) {
3435 emit(NodeId(id as u64), Event::ScrollPhase(phase));
3436 }
3437 return;
3438 }
3439 for tag in ["day:tab-new", "day:tab-close", "day:tab-move"] {
3440 if let Some(key) = text.strip_prefix(tag).and_then(|s| s.strip_prefix(':')) {
3441 emit(
3442 NodeId(id as u64),
3443 Event::Custom {
3444 tag,
3445 num,
3446 text: key.to_owned(),
3447 },
3448 );
3449 return;
3450 }
3451 }
3452 if let Some(token) = text
3453 .strip_prefix("day-tree-expand:")
3454 .and_then(|s| s.parse::<u64>().ok())
3455 {
3456 emit(
3457 NodeId(id as u64),
3458 Event::TreeExpanded {
3459 token,
3460 expanded: num != 0.0,
3461 },
3462 );
3463 return;
3464 }
3465 if let Some(token) = text
3466 .strip_prefix("day-tree-select:")
3467 .and_then(|s| s.parse::<u64>().ok())
3468 {
3469 TREE_SOURCES.with(|m| {
3470 if let Some(e) = m.borrow_mut().get_mut(&id) {
3471 e.2 = vec![token];
3472 }
3473 });
3474 emit(NodeId(id as u64), Event::TreeSelection(vec![token]));
3475 return;
3476 }
3477 }
3478
3479 if kind == K_CUSTOM
3480 && string_of(env, jstr).ok().as_deref() == Some("day-list-first-visible")
3481 {
3482 let source = LIST_SOURCES.with(|map| map.borrow().get(&id).cloned());
3483 if let Some(source) = source
3484 && let Some(report) = &source.first_visible
3485 {
3486 report((num.max(0.0) as usize).min((source.len)().saturating_sub(1)));
3487 }
3488 return;
3489 }
3490 let ev = match kind {
3491 K_PRESSED => Event::Pressed,
3492 k if k == bridge::BridgeKind::RefreshRequested as i32 => Event::RefreshRequested,
3493 K_TEXT_CHANGED => {
3494 let text = string_of(env, jstr).ok().unwrap_or_default();
3495 Event::TextChanged(text)
3496 }
3497 K_TOGGLE_CHANGED => Event::ToggleChanged(num != 0.0),
3498 K_VALUE_CHANGED => Event::ValueChanged(num),
3499 K_VALUE_COMMITTED => Event::ValueCommitted(num),
3500 K_SEARCH_CHANGED => {
3504 let text = string_of(env, jstr).ok().unwrap_or_default();
3505 #[expect(
3506 clippy::float_cmp,
3507 reason = "`DayNavHost` sends the submit flag as exactly 1"
3508 )]
3509 let submitted = num == 1.0;
3510 if submitted {
3511 Event::SearchSubmitted(text)
3512 } else {
3513 Event::SearchChanged(text)
3514 }
3515 }
3516 K_NAV_PRESENTATION => Event::NavPresentationChanged(if num >= 0.5 {
3518 day_spec::props::NavPresentation::Split
3519 } else {
3520 day_spec::props::NavPresentation::Stack
3521 }),
3522 K_SELECTION_CHANGED => Event::SelectionChanged(num as i64),
3523 K_LIST_ACTIVATED => Event::ListActivated(num as usize),
3524 K_NAV_BACK if id == 0 => {
3530 emit(
3531 day_spec::WINDOW_NODE,
3532 Event::NavBack {
3533 already_popped: false,
3534 },
3535 );
3536 return;
3537 }
3538 K_NAV_BACK => Event::NavBack {
3539 already_popped: num != 0.0,
3540 },
3541 K_FRAME_CHANGED => {
3543 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3544 let Some((w, h)) = text.split_once(',') else {
3545 return;
3546 };
3547 let d = DENSITY.with(std::cell::Cell::get);
3548 let (Ok(w), Ok(h)) = (w.parse::<f64>(), h.parse::<f64>()) else {
3549 return;
3550 };
3551 Event::FrameChanged(Size::new(w / d, h / d))
3552 }
3553 k if k == bridge::BridgeKind::DocumentOpened as i32 => {
3555 if let Ok(path) = string_of(env, jstr) {
3556 day_core::request_open_files(vec![path]);
3557 }
3558 return;
3559 }
3560 K_DEEPLINK => {
3561 let route: String = string_of(env, jstr).ok().unwrap_or_default();
3562 day_core::request_open_url(&route);
3563 return;
3564 }
3565 k if k == bridge::BridgeKind::SharedText as i32 => {
3567 let payload: String = string_of(env, jstr).ok().unwrap_or_default();
3568 let (text, subject) = match payload.split_once('\u{1f}') {
3569 Some((text, subject)) => (text, Some(subject)),
3570 None => (payload.as_str(), None),
3571 };
3572 day_core::request_shared_text(text, subject);
3573 return;
3574 }
3575 K_PRESENT_BUTTON => Event::PresentResult {
3577 req: id as u64,
3578 result: day_spec::present::PresentResult::Button(num as i64),
3579 },
3580 K_PRESENT_TEXT => {
3581 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3582 Event::PresentResult {
3583 req: id as u64,
3584 result: day_spec::present::PresentResult::Text(text),
3585 }
3586 }
3587 K_PRESENT_DISMISSED => Event::PresentResult {
3588 req: id as u64,
3589 result: day_spec::present::PresentResult::Dismissed,
3590 },
3591 K_PRESENT_FILE => {
3594 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3595 Event::PresentResult {
3596 req: id as u64,
3597 result: day_spec::present::PresentResult::decode(3, 0, text),
3598 }
3599 }
3600 K_GESTURE => {
3603 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3604 let d = DENSITY.with(std::cell::Cell::get);
3605 match crate::gesture_event(num as i32, &text, d) {
3606 Some(ev @ Event::PointerKindChanged(_)) => {
3607 emit(day_spec::WINDOW_NODE, ev);
3608 return;
3609 }
3610 Some(ev) => ev,
3611 None => return,
3612 }
3613 }
3614 K_CUSTOM => {
3618 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3619 Event::Custom { tag: "", num, text }
3620 }
3621 K_COVER_HIDDEN => Event::CoverHidden,
3624 K_LINK_ACTIVATED => Event::LinkActivated(string_of(env, jstr).ok().unwrap_or_default()),
3627 K_KEY => Event::Key(crate::key_event(
3631 false,
3632 string_of(env, jstr).ok().unwrap_or_default(),
3633 num,
3634 )),
3635 K_TEXT => Event::Key(crate::key_event(
3638 true,
3639 string_of(env, jstr).ok().unwrap_or_default(),
3640 num,
3641 )),
3642 K_TOOLBAR_CHANGED => {
3646 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3647 let value = if text == "sel" {
3648 day_spec::ToolbarValue::Selected(num.max(0.0) as usize)
3649 } else if let Some(t) = text.strip_prefix("text:") {
3650 note_search_text(id as u64, t);
3651 day_spec::ToolbarValue::Text(t.to_string())
3652 } else if let Some(t) = text.strip_prefix("submit:") {
3653 day_spec::ToolbarValue::Submit(t.to_string())
3654 } else {
3655 day_spec::ToolbarValue::On(num != 0.0)
3656 };
3657 Event::ToolbarChanged {
3658 action: id as u64,
3659 value,
3660 }
3661 }
3662 K_MENU_ACTION => Event::MenuAction(id as u64),
3665 K_LIFECYCLE => match android_lifecycle(num as i32) {
3668 Some(phase) => Event::Lifecycle(phase),
3669 None => return,
3670 },
3671 K_SAFE_AREA => {
3678 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3679 let p: Vec<f64> = text.split(',').filter_map(|s| s.parse().ok()).collect();
3680 if p.len() < 4 {
3681 return;
3682 }
3683 let d = DENSITY.with(std::cell::Cell::get);
3684 day_core::set_safe_area(day_spec::Insets {
3685 top: p[0] / d,
3686 bottom: p[1] / d,
3687 leading: p[2] / d,
3688 trailing: p[3] / d,
3689 });
3690 return;
3691 }
3692 K_APPEARANCE_CHANGED => {
3695 day_core::note_appearance_changed();
3696 return;
3697 }
3698 K_REDUCE_MOTION_CHANGED => {
3702 day_core::note_motion_changed();
3703 return;
3704 }
3705 K_WINDOW_RESIZED => {
3706 let text: String = string_of(env, jstr).ok().unwrap_or_default();
3707 let p: Vec<f64> = text.split(',').filter_map(|s| s.parse().ok()).collect();
3708 if p.len() < 2 {
3709 return;
3710 }
3711 let d = DENSITY.with(std::cell::Cell::get);
3712 let target = if id == 0 {
3715 day_spec::WINDOW_NODE
3716 } else {
3717 day_spec::NodeId(id as u64)
3718 };
3719 let size = Size::new(p[0] / d, p[1] / d);
3720 let keyboard = p.get(2).map_or(0.0, |k| k.max(0.0) / d);
3723 day_core::note_keyboard_overlap(target, size, keyboard);
3724 emit(target, Event::WindowResized(size));
3725 return;
3726 }
3727 K_WINDOW_STATE_CHANGED => {
3731 let state = day_spec::WindowState::from_code(num as i32);
3732 log::debug!("android: window state now {state:?}");
3733 let target = if id == 0 {
3734 day_spec::WINDOW_NODE
3735 } else {
3736 day_spec::NodeId(id as u64)
3737 };
3738 emit(target, Event::WindowStateChanged(state));
3739 return;
3740 }
3741 K_WINDOW_CLOSED => Event::WindowClosed,
3743 K_WINDOW_FOCUSED => Event::WindowFocused(num != 0.0),
3744 K_FOCUS_CHANGED => Event::FocusChanged(num != 0.0),
3746 K_SUBMITTED => Event::Submitted,
3747 unknown => {
3748 #[cfg(debug_assertions)]
3751 {
3752 use std::sync::{Mutex, OnceLock};
3753 static SEEN: OnceLock<Mutex<std::collections::BTreeSet<i32>>> = OnceLock::new();
3754 let seen = SEEN.get_or_init(|| Mutex::new(std::collections::BTreeSet::new()));
3755 if let Ok(mut g) = seen.lock()
3756 && g.insert(unknown)
3757 {
3758 log::warn!("day-toolkit-material: dropping unknown event kind {unknown}");
3759 }
3760 }
3761 let _ = unknown;
3762 return;
3763 }
3764 };
3765 emit(NodeId(id as u64), ev);
3766 }
3767
3768 pub fn run_posted(token: i64) {
3771 let f: Box<Box<dyn FnOnce() + Send>> =
3774 unsafe { Box::from_raw(token as *mut Box<dyn FnOnce() + Send>) };
3775 day_spec::ffi_guard::contain((), f);
3776 }
3777
3778 pub fn run_frame(token: i64, frame_nanos: i64) {
3782 day_core::frame::native::deliver(
3783 token as u64,
3784 day_spec::FrameStamp::new(frame_nanos as f64 / 1_000_000_000.0),
3785 );
3786 }
3787
3788 #[distributed_slice]
3789 pub static RENDERERS: [fn() -> Renderer<Material>];
3790
3791 pub struct Material {
3792 registry: Registry<Material>,
3793 }
3794
3795 impl Material {
3796 #[must_use]
3797 pub fn new() -> Self {
3798 let mut registry = Registry::default();
3799 for f in RENDERERS {
3800 registry.register(f());
3801 }
3802 Material { registry }
3803 }
3804 }
3805
3806 impl Default for Material {
3807 fn default() -> Self {
3808 Self::new()
3809 }
3810 }
3811
3812 fn parse_display_info(line: &str) -> Option<day_spec::Monitor> {
3815 let f: Vec<&str> = line.split('\t').collect();
3816 let [id, name, rest @ ..] = f.as_slice() else {
3817 return None;
3818 };
3819 let n: Vec<f64> = rest
3820 .iter()
3821 .map(|s| s.parse::<f64>().ok())
3822 .collect::<Option<_>>()?;
3823 let [scale, w, h, wl, wt, ww, wh] = n.as_slice() else {
3824 return None;
3825 };
3826 Some(day_spec::Monitor {
3827 id: (*id).to_string(),
3828 name: (*name).to_string(),
3829 frame: day_spec::Rect::new(0.0, 0.0, *w, *h),
3830 work_area: day_spec::Rect::new(*wl, *wt, *ww, *wh),
3831 scale: *scale,
3832 primary: true,
3833 })
3834 }
3835
3836 fn jstr(env: &mut Env, s: &str) -> jni::objects::JString<'static> {
3837 unsafe { std::mem::transmute(env.new_string(s).expect("new_string")) }
3839 }
3840
3841 fn android_lifecycle(code: i32) -> Option<day_spec::Lifecycle> {
3843 use day_spec::Lifecycle::{
3844 DidBecomeActive, DidEnterBackground, DidExit, DidReceiveMemoryWarning,
3845 WillEnterForeground, WillResignActive, WillTerminate,
3846 };
3847 Some(match code {
3848 2 => DidBecomeActive,
3849 3 => WillResignActive,
3850 4 => WillEnterForeground,
3851 5 => DidEnterBackground,
3852 6 => DidReceiveMemoryWarning,
3853 7 => WillTerminate,
3854 8 => DidExit,
3855 _ => return None,
3856 })
3857 }
3858
3859 #[must_use]
3862 pub const fn lifecycle_supported(_phase: day_spec::Lifecycle) -> bool {
3863 true
3864 }
3865
3866 fn android_role_label(role: day_spec::MenuRole) -> &'static str {
3870 use day_spec::MenuRole::{
3871 About, CheckForUpdates, CloseWindow, Copy, Cut, Delete, Fullscreen, Minimize,
3872 NewWindow, Paste, Preferences, Quit, Redo, SelectAll, Undo,
3873 };
3874 match role {
3875 Cut => "Cut",
3876 Copy => "Copy",
3877 Paste => "Paste",
3878 SelectAll => "Select All",
3879 Undo => "Undo",
3880 Redo => "Redo",
3881 Delete => "Delete",
3882 About => "About",
3883 Quit => "Quit",
3884 Preferences => "Settings",
3885 Minimize => "Minimize",
3886 CloseWindow => "Close",
3887 Fullscreen => "Full Screen",
3888 NewWindow => "New Window",
3889 CheckForUpdates => "Check for Updates…",
3890 }
3891 }
3892
3893 fn serialize_toolbar(items: &[day_spec::ToolbarItem]) -> String {
3916 use day_spec::ToolbarItemKind as K;
3917 fn clean(s: &str) -> String {
3918 s.replace(['\u{1d}', '\u{1e}', '\u{1f}'], " ")
3919 }
3920 let (page, window): (Vec<_>, Vec<_>) = items
3921 .iter()
3922 .filter(|i| i.id != day_spec::SIDEBAR_TOGGLE_ID)
3923 .partition(|i| {
3924 matches!(
3925 i.column,
3926 day_spec::ToolbarColumn::Detail | day_spec::ToolbarColumn::List
3927 )
3928 });
3929 let mut out = String::new();
3930 for item in page.into_iter().chain(window) {
3931 let (kind, extra) = match &item.kind {
3932 K::Button => ("button", String::new()),
3933 K::Toggle { on } => ("toggle", u8::from(*on).to_string()),
3934 K::Menu { items } => {
3935 let mut spec = String::new();
3936 serialize_menu(items, &mut spec);
3937 ("menu", spec)
3938 }
3939 K::Segmented { segments, selected } => {
3940 let mut e = selected.to_string();
3944 for seg in segments {
3945 e.push('\u{1d}');
3946 e.push_str(&clean(&seg.title));
3947 e.push('\u{1c}');
3948 e.push_str(&clean(&icon_name(seg.icon.as_ref())));
3949 }
3950 ("segmented", e)
3951 }
3952 K::Label => ("label", String::new()),
3953 K::Separator => ("sep", String::new()),
3954 K::Search {
3955 text, placeholder, ..
3956 } => (
3957 "search",
3958 format!("{}\u{1d}{}", clean(text), clean(placeholder)),
3959 ),
3960 };
3961 let icon = match (&item.kind, &item.icon) {
3964 (K::Search { .. }, None) => symbol_drawable(day_spec::Symbol::Search),
3965 (_, icon) => icon_name(icon.as_ref()),
3966 };
3967 if !out.is_empty() {
3968 out.push('\u{1e}');
3969 }
3970 let placement = match item.placement {
3973 day_spec::ToolbarPlacement::Navigation => "nav",
3974 day_spec::ToolbarPlacement::Principal => "mid",
3975 day_spec::ToolbarPlacement::Primary => "primary",
3976 day_spec::ToolbarPlacement::Secondary => "secondary",
3977 day_spec::ToolbarPlacement::Bottom => "bottom",
3979 day_spec::ToolbarPlacement::Automatic => "auto",
3980 };
3981 out.push_str(
3982 &[
3983 clean(&item.id),
3984 kind.to_string(),
3985 clean(&item.label),
3986 clean(&icon),
3987 u8::from(item.enabled).to_string(),
3988 item.action.to_string(),
3989 extra,
3990 placement.to_string(),
3991 ]
3992 .join("\u{1f}"),
3993 );
3994 }
3995 out
3996 }
3997
3998 fn note_search_text(action: u64, text: &str) {
4003 WINDOW_BARS.with(|m| {
4004 for bar in m.borrow_mut().values_mut() {
4005 let Some(item) = bar
4006 .by_action(action)
4007 .filter(|i| matches!(i.kind, day_spec::ToolbarItemKind::Search { .. }))
4008 .map(|i| i.id.clone())
4009 else {
4010 continue;
4011 };
4012 bar.patch(&day_spec::ToolbarPatch::Text {
4013 item,
4014 text: text.to_string(),
4015 });
4016 }
4017 });
4018 }
4019
4020 fn icon_name(icon: Option<&day_spec::Icon>) -> String {
4026 match icon {
4027 Some(day_spec::Icon::Image(name)) => name.clone(),
4028 Some(day_spec::Icon::Symbol(sym)) => symbol_drawable(*sym),
4029 None => String::new(),
4030 }
4031 }
4032
4033 #[must_use]
4037 pub fn symbol_drawable(sym: day_spec::Symbol) -> String {
4038 let mut out = String::from("day_symbol");
4039 for c in format!("{sym:?}").chars() {
4040 if c.is_ascii_uppercase() {
4041 out.push('_');
4042 out.push(c.to_ascii_lowercase());
4043 } else {
4044 out.push(c);
4045 }
4046 }
4047 out
4048 }
4049
4050 fn serialize_menu(items: &[day_spec::MenuItem], out: &mut String) {
4051 use std::fmt::Write as _;
4052 fn clean(s: &str) -> String {
4053 s.replace(['\t', '\n'], " ")
4054 }
4055 for item in items {
4059 match item {
4060 day_spec::MenuItem::Separator => out.push_str("-\t0\t1\t-1\t\n"),
4061 day_spec::MenuItem::Submenu { label, items, .. } => {
4062 let _ = writeln!(out, "S\t0\t1\t-1\t{}", clean(label));
4063 serialize_menu(items, out);
4064 out.push_str("E\t0\t1\t-1\t\n");
4065 }
4066 day_spec::MenuItem::Action {
4067 action,
4068 label,
4069 shortcut: _,
4070 enabled,
4071 checked,
4072 role,
4073 ..
4078 } => {
4079 let text = match role {
4080 Some(r) if label.is_empty() => android_role_label(*r).to_string(),
4081 _ => label.clone(),
4082 };
4083 let _ = writeln!(
4084 out,
4085 "A\t{}\t{}\t{}\t{}",
4086 action,
4087 i32::from(*enabled),
4088 checked.map_or(-1, i32::from),
4089 clean(&text)
4090 );
4091 }
4092 }
4093 }
4094 }
4095
4096 #[must_use]
4101 pub fn font_style(f: Font) -> (f32, day_spec::FontWeight) {
4102 use day_spec::FontWeight::{Regular, Semibold};
4103 match f {
4104 Font::LargeTitle => (34.0, Regular),
4105 Font::Title => (28.0, Regular),
4106 Font::Title2 => (22.0, Regular),
4107 Font::Title3 => (20.0, Regular),
4108 Font::Headline => (17.0, Semibold),
4109 Font::Subheadline => (15.0, Regular),
4110 Font::Body => (17.0, Regular),
4111 Font::Callout => (16.0, Regular),
4112 Font::Footnote => (13.0, Regular),
4113 Font::Caption => (12.0, Regular),
4114 Font::Caption2 => (11.0, Regular),
4115 Font::System(pt) | Font::Custom(_, pt) => (pt as f32, Regular),
4116 }
4117 }
4118
4119 fn custom_family(spec: day_spec::FontSpec) -> Option<&'static str> {
4123 match spec.style {
4124 Font::Custom(name, _) => Some(name),
4125 _ => None,
4126 }
4127 }
4128
4129 fn android_weight(w: day_spec::FontWeight) -> i32 {
4131 use day_spec::FontWeight as W;
4132 match w {
4133 W::Thin => 100,
4134 W::UltraLight => 200,
4135 W::Light => 300,
4136 W::Regular => 400,
4137 W::Medium => 500,
4138 W::Semibold => 600,
4139 W::Bold => 700,
4140 W::Heavy => 800,
4141 W::Black => 900,
4142 }
4143 }
4144
4145 fn font_params(spec: day_spec::FontSpec) -> (f32, i32, bool, bool) {
4149 let (sp, inherent) = font_style(spec.style);
4150 let weight = android_weight(spec.weight.unwrap_or(inherent));
4151 let sp = spec.resolved_points(f64::from(sp)) as f32;
4152 (sp, weight, spec.italic, spec.tabular)
4153 }
4154
4155 fn apply_label_font(env: &mut Env, view: &Gref, spec: day_spec::FontSpec) {
4159 let (sp, weight, italic, tabular) = font_params(spec);
4160 let fam = match (custom_family(spec), spec.monospace) {
4164 (Some(f), _) => jstr(env, f),
4165 (None, true) => jstr(env, "monospace"),
4166 (None, false) => JString::default(),
4167 };
4168 let _ = java_in(env, |env| {
4169 DayBridge::setLabelFont(env, view.as_obj(), sp, weight, italic, &fam, tabular)
4170 });
4171 if spec.small_caps || spec.oldstyle_figures {
4174 let features = crate::text_wire::features(&spec).unwrap_or_default();
4175 let f = jstr(env, &features);
4176 let _ = java_in(env, |env| {
4177 DayBridge::setLabelFeatures(env, view.as_obj(), &f)
4178 });
4179 }
4180 }
4181
4182 fn apply_label_paragraph(env: &mut Env, view: &Gref, p: &day_spec::props::LabelParagraph) {
4186 let (lines, truncation, spacing, height) = crate::text_wire::paragraph_args(p);
4187 let _ = java_in(env, |env| {
4188 DayBridge::setLabelParagraph(env, view.as_obj(), lines, truncation, spacing, height)
4189 });
4190 }
4191
4192 fn nav_tints_joined(tints: &[Option<day_spec::Color>]) -> String {
4196 tints
4197 .iter()
4198 .map(|t| t.map_or(0, argb_i32).to_string())
4199 .collect::<Vec<_>>()
4200 .join("\u{1f}")
4201 }
4202
4203 fn nav_menu_select(env: &mut Env, h: &AHandle, sel: Option<usize>) {
4212 let _ = java_in(env, |env| {
4213 DayBridge::setNavMenuSelected(env, h.0.as_obj(), sel.map_or(-1, |i| i as i32))
4214 });
4215 if env.exception_check() {
4216 env.exception_clear();
4217 }
4218 }
4219
4220 fn nav_menus_joined(menus: &[Vec<day_spec::MenuItem>]) -> String {
4221 menus
4222 .iter()
4223 .map(|items| {
4224 let mut spec = String::new();
4225 serialize_menu(items, &mut spec);
4226 spec
4227 })
4228 .collect::<Vec<_>>()
4229 .join("\u{1e}")
4230 }
4231
4232 fn argb_i32(c: day_spec::Color) -> i32 {
4233 super::argb_u32(c) as i32
4234 }
4235
4236 const TEMPLATE_TINT: i32 = 1;
4239
4240 fn list_item_icon(icon: Option<&day_spec::Icon>) -> String {
4245 match icon {
4246 Some(day_spec::Icon::Image(name)) => name.clone(),
4247 Some(day_spec::Icon::Symbol(sym)) => symbol_drawable(*sym),
4248 None => String::new(),
4249 }
4250 }
4251
4252 fn list_item_patch(h: &AHandle, patch: &day_spec::props::ListItemPatch) {
4255 use day_spec::props::ListItemPatch as P;
4256 let key = h.0.as_obj().as_raw() as usize;
4257 let Some(p) = LIST_ITEM_PROPS.with(|m| {
4258 let mut m = m.borrow_mut();
4259 let p = m.get_mut(&key)?;
4260 match patch {
4261 P::Title(t) => p.title.clone_from(t),
4262 P::Subtitle(t) => p.subtitle.clone_from(t),
4263 P::Detail(t) => p.detail.clone_from(t),
4264 P::Icon(i) => p.icon.clone_from(i),
4265 P::IconTint(c) => p.icon_tint = *c,
4266 P::Checked(on) => p.checked = *on,
4267 }
4268 Some(p.clone())
4269 }) else {
4270 return;
4271 };
4272 with_env(|env| {
4273 let _ = match patch {
4274 P::Title(_) | P::Subtitle(_) | P::Detail(_) => {
4275 let (t, s, d) = (
4276 jstr(env, &p.title),
4277 jstr(env, &p.subtitle),
4278 jstr(env, &p.detail),
4279 );
4280 java_in(env, |env| {
4281 DayListItem::setTexts(env, h.0.as_obj(), &t, &s, &d)
4282 })
4283 }
4284 P::Icon(_) | P::IconTint(_) => {
4285 let name = jstr(env, &list_item_icon(p.icon.as_ref()));
4286 let tint = p.icon_tint.map_or(0, |c| argb_i32(c.resolved()));
4287 java_in(env, |env| {
4288 DayListItem::setIcon(env, h.0.as_obj(), &name, tint)
4289 })
4290 }
4291 P::Checked(on) => {
4292 java_in(env, |env| DayListItem::setChecked(env, h.0.as_obj(), *on))
4293 }
4294 };
4295 if env.exception_check() {
4296 env.exception_clear();
4297 }
4298 });
4299 }
4300
4301 fn image_tint(tint: Option<day_spec::Color>, template: bool) -> i32 {
4302 match tint {
4303 Some(c) => argb_i32(c),
4304 None if template => TEMPLATE_TINT,
4305 None => 0,
4306 }
4307 }
4308
4309 fn warn_missing_renderer(kind: PieceKind) {
4316 day_spec::placeholder::report(kind, "android");
4317 }
4318
4319 fn realize_placeholder(kind: PieceKind) -> AHandle {
4323 with_env(|env| AHandle(placeholder_view(env, kind)))
4324 }
4325
4326 thread_local! {
4327 static BITMAP_INFO: RefCell<std::collections::HashMap<u64, day_spec::BitmapInfo>> =
4330 RefCell::new(std::collections::HashMap::new());
4331 }
4332
4333 fn encode_bitmap(
4339 id: day_spec::BitmapId,
4340 spec: &day_spec::EncodeSpec,
4341 ) -> Result<Vec<u8>, day_spec::ImageError> {
4342 use day_spec::ImageFormat as F;
4343 let format = match spec.format {
4344 F::Png => "png",
4345 F::Jpeg => "jpeg",
4346 _ => return Err(day_spec::ImageError::Encode),
4349 };
4350 if !BITMAP_INFO.with(|m| m.borrow().contains_key(&id.0)) {
4351 return Err(day_spec::ImageError::Gone);
4352 }
4353 if !vm_ready() {
4354 return Err(day_spec::ImageError::Unsupported);
4355 }
4356 let quality = spec
4358 .quality
4359 .map_or(-1, |q| (q.clamp(0.0, 1.0) * 100.0).round() as i32);
4360 let (fit_w, fit_h) = spec.fit.map_or((0.0, 0.0), |f| (f.width, f.height));
4361 with_env(|env| {
4362 let jfmt = jstr(env, format);
4363 java_in(env, |env| {
4364 let arr = DayBridge::imageEncode(env, id.0 as i64, &jfmt, quality, fit_w, fit_h)?;
4365 if arr.is_null() {
4366 return Ok(None);
4367 }
4368 env.convert_byte_array(&arr).map(Some)
4369 })
4370 .flatten()
4371 })
4372 .ok_or(day_spec::ImageError::Encode)
4373 }
4374
4375 fn export_failure(env: &mut Env, fallback: &str) -> day_spec::ExportError {
4378 let why = java_string(env, DayCanvasView::exportError)
4379 .filter(|s| !s.is_empty())
4380 .unwrap_or_else(|| fallback.to_string());
4381 day_spec::ExportError::Failed(why)
4382 }
4383
4384 fn export_bitmap(
4391 id: day_spec::BitmapId,
4392 ops: &[DrawOp],
4393 pw: u32,
4394 ph: u32,
4395 scale: f64,
4396 ) -> Result<day_spec::BitmapInfo, day_spec::ExportError> {
4397 let (Ok(jw), Ok(jh)) = (i32::try_from(pw), i32::try_from(ph)) else {
4399 return Err(day_spec::ExportError::TooLarge {
4400 width: pw,
4401 height: ph,
4402 });
4403 };
4404 let (nums, texts, geometry) = day_spec::encode_ops_with_geometry(ops);
4405 with_env(|env| {
4406 let refused = java_in(env, |env| {
4407 let arr = env.new_double_array(nums.len())?;
4408 arr.set_region(env, 0, &nums)?;
4409 let geo = env.new_double_array(geometry.len())?;
4410 geo.set_region(env, 0, &geometry)?;
4411 let joined = JString::from_str(env, texts.join("\u{1f}"))?;
4412 let why = DayCanvasView::renderBitmap(
4413 env,
4414 id.0 as i64,
4415 &arr,
4416 &joined,
4417 &geo,
4418 jw,
4419 jh,
4420 scale,
4421 )?;
4422 if why.is_null() {
4423 return Ok(None);
4424 }
4425 Ok(Some(string_of(env, &why).unwrap_or_default()))
4426 });
4427 match refused {
4428 Some(None) => Ok(day_spec::BitmapInfo {
4429 pixels: Size::new(f64::from(pw), f64::from(ph)),
4430 scale,
4431 format: None,
4432 has_alpha: true,
4434 }),
4435 Some(Some(why)) => Err(day_spec::ExportError::Failed(if why.is_empty() {
4436 "the bitmap could not be created".to_string()
4437 } else {
4438 why
4439 })),
4440 None => Err(day_spec::ExportError::Failed(
4441 "the bitmap render call failed".into(),
4442 )),
4443 }
4444 })
4445 }
4446
4447 fn export_pdf(pages: &[day_spec::PdfPage]) -> Result<Vec<u8>, day_spec::ExportError> {
4451 if !vm_ready() {
4452 return Err(day_spec::ExportError::Unsupported);
4453 }
4454 let mut nums = Vec::new();
4455 let mut texts = Vec::new();
4456 let mut num_counts = Vec::with_capacity(pages.len());
4457 let mut text_counts = Vec::with_capacity(pages.len());
4458 let mut sizes = Vec::with_capacity(pages.len() * 2);
4459 for page in pages {
4460 let (n, t) = day_spec::encode_ops(&page.ops);
4461 let counts = (i32::try_from(n.len()), i32::try_from(t.len()));
4462 let (Ok(nc), Ok(tc)) = counts else {
4463 return Err(day_spec::ExportError::Invalid);
4464 };
4465 num_counts.push(nc);
4466 text_counts.push(tc);
4467 nums.extend_from_slice(&n);
4468 texts.extend(t);
4469 sizes.push(page.size.width);
4470 sizes.push(page.size.height);
4471 }
4472 with_env(|env| {
4473 let bytes = java_in(env, |env| {
4474 let jnums = env.new_double_array(nums.len())?;
4475 jnums.set_region(env, 0, &nums)?;
4476 let jnum_counts = env.new_int_array(num_counts.len())?;
4477 jnum_counts.set_region(env, 0, &num_counts)?;
4478 let jtext_counts = env.new_int_array(text_counts.len())?;
4479 jtext_counts.set_region(env, 0, &text_counts)?;
4480 let jsizes = env.new_double_array(sizes.len())?;
4481 jsizes.set_region(env, 0, &sizes)?;
4482 let joined = JString::from_str(env, texts.join("\u{1f}"))?;
4483 let arr = DayCanvasView::renderPdf(
4484 env,
4485 &jnums,
4486 &jnum_counts,
4487 &joined,
4488 &jtext_counts,
4489 &jsizes,
4490 )?;
4491 if arr.is_null() {
4492 return Ok(None);
4493 }
4494 env.convert_byte_array(&arr).map(Some)
4495 });
4496 match bytes {
4497 Some(Some(pdf)) => Ok(pdf),
4498 Some(None) => Err(export_failure(env, "the PDF could not be written")),
4499 None => Err(day_spec::ExportError::Failed(
4500 "the PDF render call failed".into(),
4501 )),
4502 }
4503 })
4504 }
4505
4506 fn android_window_image(chrome: bool) -> Result<Vec<u8>, String> {
4511 with_env(|env| {
4512 let arr = DayBridge::windowImage(env, chrome).map_err(|e| {
4513 env.exception_clear();
4514 format!("windowImage: {e}")
4515 })?;
4516 if arr.is_null() {
4517 return Err("no window to capture".to_string());
4518 }
4519 env.convert_byte_array(&arr)
4520 .map_err(|e| format!("windowImage: {e}"))
4521 })
4522 }
4523
4524 impl Toolkit for Material {
4525 type Handle = AHandle;
4526
4527 fn set_drag_source(&mut self, h: &AHandle, source: day_spec::transfer::Source) {
4528 TRANSFER_SOURCES.with(|t| t.insert(h.0.as_obj().as_raw() as usize, source));
4529 transfer_install(h, true);
4530 }
4531 fn set_drop_target(&mut self, h: &AHandle, target: day_spec::transfer::Target) {
4532 TRANSFER_TARGETS.with(|t| t.insert(h.0.as_obj().as_raw() as usize, target));
4533 transfer_install(h, false);
4534 }
4535 #[expect(
4536 clippy::match_same_arms,
4537 reason = "one arm per capability, each documented with the Android mechanism behind it"
4538 )]
4539 fn capability(&self, cap: Cap) -> Support {
4540 match cap {
4541 Cap::ShareActions if day_platform_android::sdk_int() >= 34 => Support::Native,
4543 Cap::ShareActions => Support::Unsupported,
4544 Cap::SearchField => Support::Native,
4545 Cap::ComboBox => Support::Native,
4546 Cap::Stepper => Support::Emulated,
4547 Cap::DateTimePicker => Support::Native,
4548 Cap::ColorPicker => Support::Emulated,
4549 Cap::PullRefresh => Support::Native,
4550 Cap::Pager => Support::Native,
4551 Cap::PullRefreshGesture => Support::Native,
4552 Cap::DragDrop | Cap::DragExternalImport | Cap::DragExternalExport | Cap::DragMultipleItems => Support::Native,
4553 Cap::Cursor => Support::Native,
4555 Cap::Focusable => Support::Native,
4559 Cap::KeyPhases => Support::Native,
4562 Cap::HitSlop => Support::Native,
4565 Cap::FontList => Support::Native,
4568 Cap::ListItem => Support::Native,
4570 Cap::ListSections => Support::Emulated,
4574 Cap::ListViewport => Support::Native,
4578 Cap::ListReaderScroll => Support::Native,
4583 Cap::ListScrollAlign => Support::Native,
4586 Cap::ScrollOffset => Support::Native,
4588 Cap::ScrollPhases => Support::Native,
4592 Cap::ScrollSnap => Support::Emulated,
4596 Cap::ScrollKeyboardDismiss => Support::Native,
4600 Cap::ScrollZoom => Support::Unsupported,
4603 Cap::PagerProgress => Support::Native,
4605 Cap::ImageDecode | Cap::ImageEncode => Support::Native,
4612 Cap::CanvasBitmap | Cap::CanvasPdf => Support::Native,
4615 Cap::Snapshot => Support::Native,
4618 Cap::Appearance => {
4625 if with_env(|env| {
4626 DayBridge::canSetAppearance(env)
4627 .unwrap_or(false)
4628 }) {
4629 Support::Native
4630 } else {
4631 Support::Unsupported
4632 }
4633 }
4634 Cap::TextRuns | Cap::TextLinks => Support::Native,
4638 Cap::LabelSelection => Support::Native,
4641 Cap::Announce => Support::Native,
4645 Cap::ReduceMotion => Support::Native,
4649 Cap::Dialogs
4651 | Cap::FileDialogs
4652 | Cap::Animation
4653 | Cap::Cover
4654 | Cap::StatusBarHidden
4656 | Cap::NavHeader
4659 | Cap::Toolbar
4663 | Cap::NavSplit
4667 | Cap::TextEditable
4668 | Cap::TextSelectable
4669 | Cap::TextSpellCheck
4670 | Cap::ListReorder
4673 | Cap::ListRecycling
4676 | Cap::ListDelete
4679 | Cap::WindowFullscreen
4682 | Cap::ContentProtection
4687 | Cap::MultiWindow
4690 | Cap::BaselineAlignment
4692 | Cap::NavTabs
4696 | Cap::NavTabsAdaptive => Support::Native,
4699 Cap::NavReorder => Support::Unsupported,
4703 Cap::NavRepresent => Support::Emulated,
4708 Cap::Monitors => Support::Emulated,
4711 Cap::DynamicShortcuts => {
4713 if with_env(|env| {
4714 DayBridge::canSetLauncherShortcuts(env)
4715 .unwrap_or(false)
4716 }) {
4717 Support::Native
4718 } else {
4719 Support::Unsupported
4720 }
4721 }
4722 Cap::Tree => Support::Emulated,
4727 Cap::TreeSections => Support::Native,
4728 _ => Support::Unsupported,
4729 }
4730 }
4731
4732 fn defer_system_gestures(&mut self, edges: day_spec::Edges) {
4733 bridge(|env| DayBridge::setDeferSystemGestures(env, !edges.is_empty()));
4735 }
4736
4737 fn set_status_bar_hidden(&mut self, hidden: bool) {
4738 bridge(|env| DayBridge::setStatusBarHidden(env, hidden));
4741 }
4742
4743 fn present(&mut self, req: u64, spec: &day_spec::present::PresentSpec) {
4744 use day_spec::present::PresentSpec;
4745 let reqj = req as i64;
4746 match spec {
4747 PresentSpec::Dialog { sheet, .. } => with_env(|env| {
4748 let title = jstr(env, spec.title());
4749 let message = jstr(env, spec.message().unwrap_or(""));
4750 let buttons = jstr(env, &spec.buttons_joined());
4751 let roles = jstr(env, &spec.roles_joined());
4752 let _ = java_in(env, |env| {
4753 DayBridge::present(env, reqj, *sheet, &title, &message, &buttons, &roles)
4754 });
4755 }),
4756 PresentSpec::Prompt {
4757 placeholder,
4758 initial,
4759 ok,
4760 cancel,
4761 ..
4762 } => with_env(|env| {
4763 let title = jstr(env, spec.title());
4764 let message = jstr(env, spec.message().unwrap_or(""));
4765 let ph = jstr(env, placeholder);
4766 let init = jstr(env, initial);
4767 let okj = jstr(env, ok);
4768 let cancelj = jstr(env, cancel);
4769 let _ = java_in(env, |env| {
4770 DayBridge::presentPrompt(
4771 env, reqj, &title, &message, &ph, &init, &okj, &cancelj,
4772 )
4773 });
4774 }),
4775 PresentSpec::OpenFile { multiple, .. } => with_env(|env| {
4779 let title = jstr(env, spec.title());
4780 let filters = jstr(env, &spec.filters_joined());
4781 let _ = java_in(env, |env| {
4782 DayBridge::presentFileOpen(env, reqj, &title, &filters, *multiple)
4783 });
4784 }),
4785 PresentSpec::OpenFolder { .. } => emit(
4788 day_spec::WINDOW_NODE,
4789 Event::PresentResult {
4790 req,
4791 result: day_spec::present::PresentResult::Dismissed,
4792 },
4793 ),
4794 PresentSpec::SaveFile {
4795 suggested_name,
4796 src_path,
4797 ..
4798 } => with_env(|env| {
4799 let title = jstr(env, spec.title());
4800 let name = jstr(env, suggested_name);
4801 let src = jstr(env, src_path);
4802 let filters = jstr(env, &spec.filters_joined());
4803 let _ = java_in(env, |env| {
4804 DayBridge::presentFileSave(env, reqj, &title, &name, &src, &filters)
4805 });
4806 }),
4807 }
4808 }
4809
4810 fn dismiss(&mut self, req: u64) {
4811 bridge(|env| DayBridge::dismissPresent(env, req as i64));
4812 }
4813
4814 fn share_support(&self) -> day_spec::Support {
4815 day_spec::Support::Native
4816 }
4817 fn share(
4818 &mut self,
4819 spec: &day_spec::share::ShareSpec,
4820 _anchor: Option<&Self::Handle>,
4821 ) -> bool {
4822 use std::fmt::Write as _;
4823 let actions = spec.actions.iter().fold(String::new(), |mut out, a| {
4826 let title: String = a
4827 .title
4828 .chars()
4829 .map(|c| if c == '\t' || c == '\n' { ' ' } else { c })
4830 .collect();
4831 let icon = a.symbol.map_or_default(symbol_drawable);
4832 let _ = writeln!(out, "{}\t{icon}\t{title}", a.id);
4833 out
4834 });
4835 with_env(|env| {
4836 let url = jstr(env, &spec.url);
4837 let title = jstr(env, &spec.title);
4838 let actions = jstr(env, &actions);
4839 java_in(env, |env| DayBridge::share(env, &url, &title, &actions)).unwrap_or(false)
4840 })
4841 }
4842
4843 fn open_url(&mut self, url: &str) {
4844 with_env(|env| {
4845 let u = jstr(env, url);
4846 let _ = java_in(env, |env| DayBridge::openUrl(env, &u));
4847 });
4848 }
4849
4850 fn realize(&mut self, kind: PieceKind, props: &dyn Any, id: NodeId) -> AHandle {
4851 let idj = id.0 as i64;
4852 match Builtin::from_key(kind) {
4853 Some(Builtin::Container) => {
4854 let h = with_env(|env| {
4855 AHandle(bridge_view(env, "makeContainer", |env| {
4856 DayBridge::makeContainer(env)
4857 }))
4858 });
4859 if let Some(p) = props.downcast_ref::<ContainerProps>() {
4860 if p.role == Some(day_spec::SurfaceRole::SectionCard) {
4861 let d = DENSITY.with(std::cell::Cell::get);
4862 bridge(|env| {
4863 DayBridge::setSectionCard(
4864 env,
4865 h.0.as_obj(),
4866 (p.corner_radius * d) as f32,
4867 )
4868 });
4869 } else if p.role == Some(day_spec::SurfaceRole::Window) {
4870 let d = DENSITY.with(std::cell::Cell::get);
4871 bridge(|env| {
4872 DayBridge::setWindowSurface(
4873 env,
4874 h.0.as_obj(),
4875 (p.corner_radius * d) as f32,
4876 p.clips,
4877 )
4878 });
4879 } else {
4880 apply_container_surface(&h, p, true);
4881 }
4882 }
4883 h
4884 }
4885 Some(Builtin::Scroll) => {
4886 let p = props.downcast_ref::<day_spec::props::ScrollProps>();
4889 let horizontal = p.is_some_and(|p| p.horizontal);
4890 let (flags, snap_px) =
4891 p.map_or((0, 0.0), |p| crate::list_wire::scroll_flags(p, density()));
4892 with_env(|env| {
4893 AHandle(bridge_view(env, "makeScroll", |env| {
4894 DayBridge::makeScroll(env, horizontal, flags, snap_px, id.0 as i64)
4895 }))
4896 })
4897 }
4898 Some(Builtin::Tree) => {
4899 let Some(p) = day_spec::props_of::<TreeProps>(kind, "android", props) else {
4900 return realize_placeholder(kind);
4901 };
4902 let height = match p.row_height {
4903 RowHeight::Uniform(h) => h,
4904 RowHeight::Automatic => 36.0,
4905 };
4906 let handle = with_env(|env| {
4907 AHandle(bridge_view(env, "makeTree", |env| {
4908 DayBridge::makeTree(
4909 env,
4910 id.0 as i64,
4911 (height * DENSITY.with(std::cell::Cell::get)).round() as i32,
4912 p.selectable,
4913 )
4914 }))
4915 });
4916 LIST_NODE.with(|m| {
4917 m.borrow_mut()
4918 .insert(handle.0.as_obj().as_raw() as usize, id.0 as i64)
4919 });
4920 handle
4921 }
4922 Some(Builtin::List) => {
4923 let Some(p) = day_spec::props_of::<ListProps>(kind, "android", props) else {
4924 return realize_placeholder(kind);
4925 };
4926 let d = DENSITY.with(std::cell::Cell::get);
4927 let rowh = match p.row_height {
4928 RowHeight::Uniform(h) => h,
4929 RowHeight::Automatic => 44.0,
4930 };
4931 let handle = with_env(|env| {
4932 let del_label = jstr(env, &p.delete_label);
4933 AHandle(bridge_view(env, "makeList", |env| {
4934 DayBridge::makeList(
4935 env,
4936 id.0 as i64,
4937 (rowh * d).round() as i32,
4938 p.selectable,
4939 p.reorderable,
4940 p.deletable,
4941 &del_label,
4942 )
4943 }))
4944 });
4945 LIST_NODE.with(|m| {
4946 m.borrow_mut()
4947 .insert(handle.0.as_obj().as_raw() as usize, id.0 as i64)
4948 });
4949 if p.row_height == RowHeight::Automatic {
4950 LIST_AUTOMATIC.with(|m| m.borrow_mut().insert(id.0 as i64));
4951 }
4952 if p.sections {
4955 bridge(|env| DayBridge::listSetSections(env, handle.0.as_obj(), true));
4956 }
4957 handle
4958 }
4959 Some(Builtin::Nav) => {
4960 let Some(p) = day_spec::props_of::<NavProps>(kind, "android", props) else {
4961 return realize_placeholder(kind);
4962 };
4963 if p.presentation.rows_are_chrome() {
4970 let host = with_env(|env| {
4971 AHandle(bridge_view(env, "makeNavSuite", |env| {
4972 DayBridge::makeNavSuite(env, idj, 0)
4973 }))
4974 });
4975 if let Some(config) = &p.documents {
4976 with_env(|env| {
4977 let new_label = jstr(env, &config.new_label);
4978 let close_label = jstr(env, &config.close_label);
4979 let _ = java_in(env, |env| {
4980 DayBridge::documentNavSuite(
4981 env,
4982 host.0.as_obj(),
4983 &new_label,
4984 &close_label,
4985 config.can_add,
4986 )
4987 });
4988 });
4989 }
4990 NAV_SUITES
4991 .with(|m| m.borrow_mut().insert(host.0.as_obj().as_raw() as usize));
4992 emit(
4995 id,
4996 Event::NavPresentationChanged(day_spec::props::NavPresentation::Tabs),
4997 );
4998 return host;
4999 }
5000 let adaptive = p.presentation != day_spec::props::NavPresentation::Stack;
5005 let host = with_env(|env| {
5006 let s = jstr(env, &p.title);
5007 let split = day_spec::SizeClass::SPLIT_MIN_WIDTH as f32;
5010 AHandle(bridge_view(env, "makeNavHost", |env| {
5011 DayBridge::makeNavHost(env, idj, &s, adaptive, split)
5012 }))
5013 });
5014 if let Some(sp) = p
5019 .search
5020 .as_ref()
5021 .filter(|sp| sp.placement == day_spec::props::SearchPlacement::Inline)
5022 {
5023 let (prompt, text) = (sp.prompt.clone(), sp.text.clone());
5024 with_env(|env| {
5025 let pr = jstr(env, &prompt);
5026 let tx = jstr(env, &text);
5027 let _ = java_in(env, |env| {
5028 DayBridge::setNavSearch(
5029 env,
5030 host.0.as_obj(),
5031 idj,
5032 &pr,
5033 &tx,
5034 sp.hides_on_scroll,
5035 sp.initially_hidden,
5036 )
5037 });
5038 if env.exception_check() {
5039 env.exception_clear();
5040 }
5041 });
5042 }
5043 host
5044 }
5045 Some(Builtin::NavPage) => with_env(|env| {
5046 let h = AHandle(bridge_view(env, "makeNavPage", |env| {
5047 DayBridge::makeNavPage(
5048 env,
5049 idj,
5050 day_spec::props_of::<NavPageProps>(kind, "android", props)
5051 .is_some_and(|p| p.immersive),
5052 )
5053 }));
5054 let sidebar = day_spec::props_of::<NavPageProps>(kind, "android", props)
5059 .is_some_and(|p| p.pane == day_spec::props::Pane::Sidebar);
5060 if sidebar {
5061 let _ = java_in(env, |env| DayBridge::markNavChromePage(env, h.0.as_obj()));
5062 }
5063 h
5064 }),
5065 Some(Builtin::Cover) => {
5070 let half = day_spec::props_of::<CoverProps>(kind, "android", props)
5071 .is_some_and(|p| p.half);
5072 with_env(|env| {
5073 AHandle(bridge_view(env, "makeCover", |env| {
5074 DayBridge::makeCover(env, idj, half)
5075 }))
5076 })
5077 }
5078 Some(Builtin::NavMenu) => {
5079 let Some(p) = day_spec::props_of::<NavMenuProps>(kind, "android", props) else {
5080 return realize_placeholder(kind);
5081 };
5082 let joined = p.items.join("\u{1f}");
5083 let joined_icons = p
5085 .icons
5086 .iter()
5087 .map(|o| o.clone().unwrap_or_default())
5088 .collect::<Vec<_>>()
5089 .join("\u{1f}");
5090 let joined_tints = nav_tints_joined(
5091 &p.tints
5092 .iter()
5093 .map(|t| t.map(day_spec::Ink::resolved))
5094 .collect::<Vec<_>>(),
5095 );
5096 let joined_badge_icons = p
5097 .badge_icons
5098 .iter()
5099 .map(|o| o.clone().unwrap_or_default())
5100 .collect::<Vec<_>>()
5101 .join("\u{1f}");
5102 let joined_badge_tints = nav_tints_joined(
5103 &p.badge_tints
5104 .iter()
5105 .map(|t| t.map(day_spec::Ink::resolved))
5106 .collect::<Vec<_>>(),
5107 );
5108 let joined_menus = nav_menus_joined(&p.menus);
5109 let joined_sections = p
5113 .sections
5114 .iter()
5115 .map(|o| o.clone().unwrap_or_default())
5116 .collect::<Vec<_>>()
5117 .join("\u{1f}");
5118 with_env(|env| {
5119 let s = jstr(env, &joined);
5120 let si = jstr(env, &joined_icons);
5121 let ss = jstr(env, &joined_sections);
5122 let handle = AHandle(bridge_view(env, "makeNavMenu", |env| {
5123 DayBridge::makeNavMenu(env, idj, &s, &si, &ss)
5124 }));
5125 let texts = p
5128 .badges
5129 .iter()
5130 .map(|s| s.as_deref().unwrap_or(""))
5131 .collect::<Vec<_>>()
5132 .join("\u{1f}");
5133 NAV_MENU_ROWS.with(|m| {
5134 m.borrow_mut().insert(
5135 handle.0.as_obj().as_raw() as usize,
5136 (
5137 idj,
5138 joined.clone(),
5139 joined_icons.clone(),
5140 p.document_keys.join("\u{1f}"),
5141 texts.clone(),
5142 ),
5143 )
5144 });
5145 let st = jstr(env, &joined_tints);
5149 let _ = java_in(env, |env| {
5150 DayBridge::setNavMenuTints(env, handle.0.as_obj(), &st)
5151 });
5152 let counts = jstr(env, &texts);
5154 let sb = jstr(env, &joined_badge_icons);
5155 let sbt = jstr(env, &joined_badge_tints);
5156 let _ = java_in(env, |env| {
5157 DayBridge::setNavMenuBadges(env, handle.0.as_obj(), &sb, &sbt, &counts)
5158 });
5159 nav_menu_select(env, &handle, p.selected);
5163 let sm = jstr(env, &joined_menus);
5165 let _ = java_in(env, |env| {
5166 DayBridge::setNavRowMenus(env, handle.0.as_obj(), &sm)
5167 });
5168 if env.exception_check() {
5169 env.exception_clear();
5170 }
5171 handle
5172 })
5173 }
5174 Some(Builtin::Label) => {
5175 let Some(p) = day_spec::props_of::<LabelProps>(kind, "android", props) else {
5176 return realize_placeholder(kind);
5177 };
5178 with_env(|env| {
5179 let s = jstr(env, &p.text);
5180 let view =
5181 bridge_view(env, "makeLabel", |env| DayBridge::makeLabel(env, &s));
5182 apply_label_font(env, &view, p.font);
5184 if !p.wraps {
5185 let _ = java_in(env, |env| {
5186 DayBridge::setLabelSingleLine(env, view.as_obj())
5187 });
5188 }
5189 let paragraph = p.paragraph();
5190 if paragraph != day_spec::props::LabelParagraph::default() {
5191 apply_label_paragraph(env, &view, ¶graph);
5192 }
5193 if let Some(col) = p.color {
5194 let _ = java_in(env, |env| {
5195 DayBridge::setLabelColor(
5196 env,
5197 view.as_obj(),
5198 argb_i32(col.resolved()),
5199 true,
5200 )
5201 });
5202 } else if p.role == day_spec::props::TextRole::Secondary {
5203 let _ = java_in(env, |env| {
5206 DayBridge::setLabelSecondary(env, view.as_obj(), true)
5207 });
5208 }
5209 LABEL_NODE
5212 .with(|m| m.borrow_mut().insert(view.as_obj().as_raw() as usize, idj));
5213 if !p.runs.is_empty() {
5214 set_label_runs(env, idj, &view, &p.text, &p.runs);
5215 }
5216 let align = crate::text_wire::align_code(p.align);
5217 if align != 0 {
5218 let _ = java_in(env, |env| {
5219 DayBridge::setLabelAlignment(env, view.as_obj(), align)
5220 });
5221 }
5222 if p.reports_selection {
5225 let _ = java_in(env, |env| {
5226 DayBridge::setLabelReportsSelection(env, view.as_obj(), idj)
5227 });
5228 }
5229 AHandle(view)
5230 })
5231 }
5232 Some(Builtin::Button) => {
5233 let Some(p) = day_spec::props_of::<ButtonProps>(kind, "android", props) else {
5234 return realize_placeholder(kind);
5235 };
5236 with_env(|env| {
5237 let s = jstr(env, &p.title);
5238 let v = bridge_view(env, "makeButton", |env| {
5239 DayBridge::makeButton(env, idj, &s)
5240 });
5241 let _ =
5242 java_in(env, |env| DayBridge::setEnabled(env, v.as_obj(), p.enabled));
5243 let _ = java_in(env, |env| {
5244 DayBridge::setButtonSelected(env, v.as_obj(), p.selected)
5245 });
5246 apply_button_style(env, &v, p.style);
5247 if p.icon.is_some() {
5248 apply_button_content(env, &v, &p.title, p.icon.as_ref(), p.icon_only);
5249 }
5250 AHandle(v)
5251 })
5252 }
5253 Some(Builtin::Toggle) => {
5254 let Some(p) = day_spec::props_of::<ToggleProps>(kind, "android", props) else {
5255 return realize_placeholder(kind);
5256 };
5257 with_env(|env| {
5258 AHandle(bridge_view(env, "makeToggle", |env| {
5259 DayBridge::makeToggle(env, idj, p.on, p.enabled)
5260 }))
5261 })
5262 }
5263 Some(Builtin::Slider) => {
5264 let Some(p) = day_spec::props_of::<SliderProps>(kind, "android", props) else {
5265 return realize_placeholder(kind);
5266 };
5267 with_env(|env| {
5268 AHandle(bridge_view(env, "makeSlider", |env| {
5269 DayBridge::makeSlider(env, idj, p.value, p.min, p.max)
5270 }))
5271 })
5272 }
5273 Some(Builtin::Picker) => crate::picker::realize_any(self, props, id),
5274 Some(Builtin::TextArea) => crate::textarea::realize_any(self, props, id),
5275 Some(Builtin::TextField) => {
5276 let Some(p) = day_spec::props_of::<TextFieldProps>(kind, "android", props)
5277 else {
5278 return realize_placeholder(kind);
5279 };
5280 with_env(|env| {
5281 let v = jstr(env, &p.text);
5282 let ph = jstr(env, &p.placeholder);
5283 AHandle(bridge_view(env, "makeTextField", |env| {
5284 DayBridge::makeTextField(env, idj, &v, &ph)
5285 }))
5286 })
5287 }
5288 Some(Builtin::Divider) => {
5289 let vertical = day_spec::props_of::<DividerProps>(kind, "android", props)
5290 .is_some_and(|p| p.vertical);
5291 with_env(|env| {
5292 AHandle(bridge_view(env, "makeDivider", |env| {
5293 DayBridge::makeDivider(env, vertical)
5294 }))
5295 })
5296 }
5297 Some(Builtin::Progress) => {
5298 let Some(p) = day_spec::props_of::<ProgressProps>(kind, "android", props)
5299 else {
5300 return realize_placeholder(kind);
5301 };
5302 if p.value.is_none() {
5303 return crate::controls::spinner::make(self, p, id);
5304 }
5305 with_env(|env| {
5306 AHandle(bridge_view(env, "makeProgress", |env| {
5307 DayBridge::makeProgress(env, p.value.is_some(), p.value.unwrap_or(0.0))
5308 }))
5309 })
5310 }
5311 Some(Builtin::Canvas) => with_env(|env| {
5312 AHandle(bridge_view(env, "makeCanvas", |env| {
5313 DayBridge::makeCanvas(env, idj)
5314 }))
5315 }),
5316 Some(Builtin::Image) => {
5317 let Some(p) = day_spec::props_of::<ImageProps>(kind, "android", props) else {
5318 return realize_placeholder(kind);
5319 };
5320 let mode = match p.content_mode {
5322 ContentMode::Fit => 0,
5323 ContentMode::Fill => 1,
5324 ContentMode::Stretch => 2,
5325 };
5326 let tint = image_tint(p.tint.map(day_spec::Ink::resolved), p.template);
5330 let handle = with_env(|env| match &p.source {
5336 day_spec::ImageSource::Named(named) => {
5337 let s = jstr(env, named);
5338 AHandle(bridge_view(env, "makeImage", |env| {
5339 DayBridge::makeImage(env, &s, mode, tint)
5340 }))
5341 }
5342 day_spec::ImageSource::Bytes(bytes) => {
5343 let Ok(arr) = env.byte_array_from_slice(bytes) else {
5344 return AHandle(bridge_view(env, "makeImageBytes", |env| {
5345 DayBridge::makeImageBytes(
5346 env,
5347 jni::objects::JByteArray::default(),
5348 mode,
5349 )
5350 }));
5351 };
5352 AHandle(bridge_view(env, "makeImageBytes", |env| {
5353 DayBridge::makeImageBytes(env, &arr, mode)
5354 }))
5355 }
5356 day_spec::ImageSource::Decoded(id) => {
5357 AHandle(bridge_view(env, "makeImageBitmap", |env| {
5358 DayBridge::makeImageBitmap(env, id.0 as i64, mode)
5359 }))
5360 }
5361 });
5362 if tint != 0 && !matches!(p.source, day_spec::ImageSource::Named(_)) {
5363 bridge(|env| DayBridge::initImageTint(env, handle.0.as_obj(), tint));
5364 }
5365 handle
5366 }
5367 Some(Builtin::ListItem) => {
5368 let Some(p) = day_spec::props_of::<day_spec::props::ListItemProps>(
5369 kind, "android", props,
5370 ) else {
5371 return realize_placeholder(kind);
5372 };
5373 let handle = with_env(|env| {
5374 let (t, s, d) = (
5375 jstr(env, &p.title),
5376 jstr(env, &p.subtitle),
5377 jstr(env, &p.detail),
5378 );
5379 let icon = jstr(env, &list_item_icon(p.icon.as_ref()));
5380 let tint = p.icon_tint.map_or(0, |c| argb_i32(c.resolved()));
5381 AHandle(bridge_view(env, "makeListItem", |env| {
5382 DayListItem::make(env, &t, &s, &d, &icon, tint, p.checked)
5383 }))
5384 });
5385 LIST_ITEM_PROPS.with(|m| {
5386 m.borrow_mut()
5387 .insert(handle.0.as_obj().as_raw() as usize, p.clone())
5388 });
5389 handle
5390 }
5391 Some(
5394 Builtin::ListCell
5395 | Builtin::Inspector
5396 | Builtin::InspectorPane
5397 | Builtin::Split
5398 | Builtin::SplitPane,
5399 )
5400 | None => {
5401 if let Some(make) = self.registry.get(kind).map(|r| r.make) {
5402 return make(self, props, id);
5403 }
5404 warn_missing_renderer(kind);
5405 with_env(|env| {
5406 let s = jstr(env, &format!("⟨{kind}⟩"));
5407 AHandle(bridge_view(env, "makeLabel", |env| {
5408 DayBridge::makeLabel(env, &s)
5409 }))
5410 })
5411 }
5412 }
5413 }
5414
5415 fn update(
5416 &mut self,
5417 h: &AHandle,
5418 kind: PieceKind,
5419 patch: &dyn Any,
5420 anim: Option<&AnimSpec>,
5421 ) {
5422 if let Some(patch) = patch.downcast_ref::<TreePatch>() {
5423 tree_patch(h, patch);
5424 return;
5425 }
5426 match kind {
5427 kinds::LIST_ITEM => {
5428 if let Some(p) = patch.downcast_ref::<day_spec::props::ListItemPatch>() {
5429 list_item_patch(h, p);
5430 }
5431 }
5432 kinds::IMAGE => {
5433 if let Some(p) = patch.downcast_ref::<day_spec::props::ImagePatch>() {
5434 match p {
5435 day_spec::props::ImagePatch::Tint(c) => {
5436 let tint = image_tint((*c).map(day_spec::Ink::resolved), false);
5440 with_env(|env| {
5441 let _ = java_in(env, |env| {
5442 DayBridge::setImageTint(env, h.0.as_obj(), tint)
5443 });
5444 });
5445 }
5446 day_spec::props::ImagePatch::Source(source) => {
5450 with_env(|env| match source {
5451 day_spec::ImageSource::Named(named) => {
5452 let s = jstr(env, named);
5453 let _ = java_in(env, |env| {
5454 DayBridge::setImageName(env, h.0.as_obj(), &s)
5455 });
5456 }
5457 day_spec::ImageSource::Bytes(bytes) => {
5458 if let Ok(arr) = env.byte_array_from_slice(bytes) {
5459 let _ = java_in(env, |env| {
5460 DayBridge::setImageBytes(env, h.0.as_obj(), &arr)
5461 });
5462 }
5463 }
5464 day_spec::ImageSource::Decoded(id) => {
5465 let _ = java_in(env, |env| {
5466 DayBridge::setImageBitmap(
5467 env,
5468 h.0.as_obj(),
5469 id.0 as i64,
5470 )
5471 });
5472 }
5473 });
5474 }
5475 }
5476 }
5477 }
5478 kinds::CONTAINER => match patch.downcast_ref::<ContainerPatch>() {
5479 Some(ContainerPatch::Fill(fill @ (None | Some(day_spec::Paint::Solid(_))))) => {
5484 let c = super::solid_fill(fill.as_ref());
5485 bridge(|env| {
5486 let (timing, keys) = anim_arrays(env, anim)?;
5487 DayBridge::animateSurfaceFill(
5488 env,
5489 h.0.as_obj(),
5490 c.map_or(0, argb_i32),
5491 c.is_some(),
5492 &timing,
5493 &keys,
5494 )
5495 });
5496 }
5497 Some(ContainerPatch::Fill(fill)) => {
5499 let spec = super::gradient_spec(fill.as_ref());
5500 bridge(|env| {
5501 let arr = env.new_double_array(spec.len())?;
5502 arr.set_region(env, 0, &spec)?;
5503 DayBridge::setSurfaceGradient(env, h.0.as_obj(), &arr)
5504 });
5505 }
5506 Some(ContainerPatch::Surface(p)) => apply_container_surface(h, p, false),
5510 None => {}
5511 },
5512 kinds::NAV_MENU => {
5513 if let Some(p) = patch.downcast_ref::<day_spec::props::RefreshPatch>() {
5514 with_env(|env| {
5515 let _ = java_in(env, |env| {
5516 DayBridge::setNavRefreshing(env, h.0.as_obj(), p.refreshing)
5517 });
5518 });
5519 return;
5520 }
5521 match patch.downcast_ref::<NavMenuPatch>() {
5522 Some(NavMenuPatch::Items {
5527 items,
5528 icons,
5529 tints,
5530 menus,
5531 badges,
5532 badge_icons,
5533 badge_tints,
5534 sections,
5535 selected,
5536 document_keys,
5537 rows_changed,
5538 ..
5540 }) => {
5541 let joined = items.join("\u{1f}");
5542 let joined_icons = icons
5543 .iter()
5544 .map(|o| o.clone().unwrap_or_default())
5545 .collect::<Vec<_>>()
5546 .join("\u{1f}");
5547 let joined_tints = nav_tints_joined(
5548 &tints
5549 .iter()
5550 .map(|t| t.map(day_spec::Ink::resolved))
5551 .collect::<Vec<_>>(),
5552 );
5553 let joined_badge_icons = badge_icons
5554 .iter()
5555 .map(|o| o.clone().unwrap_or_default())
5556 .collect::<Vec<_>>()
5557 .join("\u{1f}");
5558 let joined_badge_tints = nav_tints_joined(
5559 &badge_tints
5560 .iter()
5561 .map(|t| t.map(day_spec::Ink::resolved))
5562 .collect::<Vec<_>>(),
5563 );
5564 let joined_menus = nav_menus_joined(menus);
5565 let joined_sections = sections
5566 .iter()
5567 .map(|o| o.clone().unwrap_or_default())
5568 .collect::<Vec<_>>()
5569 .join("\u{1f}");
5570 with_env(|env| {
5571 let s = jstr(env, &joined);
5572 let si = jstr(env, &joined_icons);
5573 let ss = jstr(env, &joined_sections);
5574 let _ = match rows_changed {
5577 Some(rows) => {
5578 let r = jstr(
5579 env,
5580 &rows
5581 .iter()
5582 .map(std::string::ToString::to_string)
5583 .collect::<Vec<_>>()
5584 .join(","),
5585 );
5586 java_in(env, |env| {
5587 DayBridge::updateNavMenuRows(
5588 env,
5589 h.0.as_obj(),
5590 &r,
5591 &s,
5592 &si,
5593 )
5594 })
5595 }
5596 None => java_in(env, |env| {
5597 DayBridge::updateNavMenu(env, h.0.as_obj(), &s, &si, &ss)
5598 }),
5599 };
5600 let keys = jstr(env, &document_keys.join("\u{1f}"));
5601 let _ = java_in(env, |env| {
5602 DayBridge::setDocumentTabKeys(env, h.0.as_obj(), &keys)
5603 });
5604 nav_menu_select(env, h, *selected);
5607 let st = jstr(env, &joined_tints);
5608 let _ = java_in(env, |env| {
5609 DayBridge::setNavMenuTints(env, h.0.as_obj(), &st)
5610 });
5611 let texts = badges
5612 .iter()
5613 .map(|s| s.as_deref().unwrap_or(""))
5614 .collect::<Vec<_>>()
5615 .join("\u{1f}");
5616 let counts = jstr(env, &texts);
5617 let sb = jstr(env, &joined_badge_icons);
5618 let sbt = jstr(env, &joined_badge_tints);
5619 let _ = java_in(env, |env| {
5620 DayBridge::setNavMenuBadges(
5621 env,
5622 h.0.as_obj(),
5623 &sb,
5624 &sbt,
5625 &counts,
5626 )
5627 });
5628 let sm = jstr(env, &joined_menus);
5629 let _ = java_in(env, |env| {
5630 DayBridge::setNavRowMenus(env, h.0.as_obj(), &sm)
5631 });
5632 if env.exception_check() {
5633 env.exception_clear();
5634 }
5635 });
5636 }
5637 Some(NavMenuPatch::Selected(sel)) => {
5643 with_env(|env| nav_menu_select(env, h, *sel));
5644 }
5645 Some(NavMenuPatch::IconProgress(_)) | None => {}
5646 }
5647 }
5648 kinds::NAV => {
5649 if let Some(p) = patch.downcast_ref::<day_spec::props::DocumentTabsPatch>() {
5650 with_env(|env| {
5651 let _ = java_in(env, |env| {
5652 DayBridge::documentNavChrome(env, h.0.as_obj(), p.native)
5653 });
5654 });
5655 return;
5656 }
5657 if matches!(
5661 patch.downcast_ref::<day_spec::props::SearchPatch>(),
5662 Some(day_spec::props::SearchPatch::Focus)
5663 ) {
5664 with_env(|env| {
5665 let _ =
5666 java_in(env, |env| DayBridge::focusNavSearch(env, h.0.as_obj()));
5667 if env.exception_check() {
5668 env.exception_clear();
5669 }
5670 });
5671 }
5672 if let Some(day_spec::props::SearchPatch::Text(t)) =
5673 patch.downcast_ref::<day_spec::props::SearchPatch>()
5674 {
5675 let text = t.clone();
5676 with_env(|env| {
5677 let tx = jstr(env, &text);
5678 let _ = java_in(env, |env| {
5679 DayBridge::setNavSearchText(env, h.0.as_obj(), &tx)
5680 });
5681 if env.exception_check() {
5682 env.exception_clear();
5683 }
5684 });
5685 }
5686 if let Some(p) = patch.downcast_ref::<NavPatch>() {
5687 match p {
5688 NavPatch::Pushed { title, immersive } => with_env(|env| {
5689 let s = jstr(env, title);
5690 let _ = java_in(env, |env| {
5691 DayBridge::navPush(env, h.0.as_obj(), &s, *immersive)
5692 });
5693 }),
5694 NavPatch::Popped => bridge(|env| DayBridge::navPop(env, h.0.as_obj())),
5695 NavPatch::Title(t) => with_env(|env| {
5696 let s = jstr(env, t);
5697 let _ = java_in(env, |env| {
5698 DayBridge::navSetTitle(env, h.0.as_obj(), &s)
5699 });
5700 }),
5701 NavPatch::GuardTop(on) => with_env(|env| {
5702 let _ = java_in(env, |env| {
5703 DayBridge::navSetGuard(env, h.0.as_obj(), *on)
5704 });
5705 }),
5706 #[expect(
5711 clippy::match_same_arms,
5712 reason = "each group of no-op patches keeps its own arm and the comment saying why"
5713 )]
5714 NavPatch::Presentation(_) => {}
5715 NavPatch::Reorder(order) => with_env(|env| {
5716 let text = jstr(
5717 env,
5718 &order
5719 .iter()
5720 .map(usize::to_string)
5721 .collect::<Vec<_>>()
5722 .join(","),
5723 );
5724 let _ = java_in(env, |env| {
5725 DayBridge::reorderNavSuite(env, h.0.as_obj(), &text)
5726 });
5727 }),
5728 NavPatch::Select(i) => {
5732 bridge(|env| {
5733 DayBridge::setNavSuiteSelected(env, h.0.as_obj(), *i as i32)
5734 });
5735 }
5736 NavPatch::ListVisible(_) | NavPatch::ListInStack(_) => {}
5740 }
5741 }
5742 }
5743 kinds::COVER => {
5744 if let Some(p) = patch.downcast_ref::<CoverPatch>() {
5745 match p {
5746 CoverPatch::Present {
5747 background,
5748 dismiss_disabled,
5749 } => bridge(|env| {
5750 DayBridge::coverPresent(
5751 env,
5752 h.0.as_obj(),
5753 background.map_or(0, |c| argb_i32(c.resolved())),
5754 background.is_some(),
5755 *dismiss_disabled,
5756 )
5757 }),
5758 CoverPatch::DismissDisabled(d) => bridge(|env| {
5759 DayBridge::coverSetDismissDisabled(env, h.0.as_obj(), *d)
5760 }),
5761 CoverPatch::Dismiss => {
5762 bridge(|env| DayBridge::coverDismiss(env, h.0.as_obj()));
5763 }
5764 }
5765 }
5766 }
5767 kinds::LABEL => {
5768 if let Some(p) = patch.downcast_ref::<LabelPatch>() {
5769 match p {
5770 LabelPatch::Paragraph(p) => {
5771 with_env(|env| apply_label_paragraph(env, &h.0, p));
5772 }
5773 LabelPatch::Text(t) => with_env(|env| {
5774 let s = jstr(env, t);
5775 let _ =
5776 java_in(env, |env| DayBridge::setLabel(env, h.0.as_obj(), &s));
5777 }),
5778 LabelPatch::Font(f) => with_env(|env| apply_label_font(env, &h.0, *f)),
5779 LabelPatch::Runs(text, runs) => {
5780 let node = LABEL_NODE.with(|m| {
5781 m.borrow()
5782 .get(&(h.0.as_obj().as_raw() as usize))
5783 .copied()
5784 .unwrap_or(0)
5785 });
5786 with_env(|env| set_label_runs(env, node, &h.0, text, runs));
5787 }
5788 LabelPatch::Color(c) => {
5789 bridge(|env| {
5790 DayBridge::setLabelColor(
5791 env,
5792 h.0.as_obj(),
5793 c.map_or(0, |c| argb_i32(c.resolved())),
5794 c.is_some(),
5795 )
5796 });
5797 }
5798 }
5799 }
5800 }
5801 kinds::BUTTON => {
5802 if let Some(p) = patch.downcast_ref::<ButtonPatch>() {
5803 match p {
5804 ButtonPatch::Content(c) => with_env(|env| {
5805 apply_button_content(
5806 env,
5807 &h.0,
5808 &c.title,
5809 c.icon.as_ref(),
5810 c.icon_only,
5811 );
5812 }),
5813 ButtonPatch::Title(t) => with_env(|env| {
5814 let s = jstr(env, t);
5815 let _ =
5816 java_in(env, |env| DayBridge::setLabel(env, h.0.as_obj(), &s));
5817 }),
5818 ButtonPatch::Enabled(e) => {
5819 bridge(|env| DayBridge::setEnabled(env, h.0.as_obj(), *e));
5820 }
5821 ButtonPatch::Selected(on) => {
5822 bridge(|env| DayBridge::setButtonSelected(env, h.0.as_obj(), *on));
5823 }
5824 ButtonPatch::Style(s) => {
5825 with_env(|env| apply_button_style(env, &h.0, *s));
5826 }
5827 }
5828 }
5829 }
5830 kinds::TOGGLE => {
5831 if let Some(p) = patch.downcast_ref::<TogglePatch>() {
5832 match p {
5833 TogglePatch::On(on) => {
5834 bridge(|env| DayBridge::setToggle(env, h.0.as_obj(), *on));
5835 }
5836 TogglePatch::Enabled(e) => {
5837 bridge(|env| DayBridge::setEnabled(env, h.0.as_obj(), *e));
5838 }
5839 }
5840 }
5841 }
5842 kinds::SLIDER => {
5843 if let Some(p) = patch.downcast_ref::<SliderPatch>() {
5844 match p {
5845 SliderPatch::Value(v) => {
5846 bridge(|env| DayBridge::setSlider(env, h.0.as_obj(), *v, 0.0));
5848 }
5849 SliderPatch::Enabled(e) => {
5850 bridge(|env| DayBridge::setEnabled(env, h.0.as_obj(), *e));
5851 }
5852 }
5853 }
5854 }
5855 kinds::PROGRESS => {
5856 if let Some(p @ ProgressPatch::Animating(_)) =
5857 patch.downcast_ref::<ProgressPatch>()
5858 {
5859 crate::controls::spinner::update(self, h, p);
5860 return;
5861 }
5862
5863 if let Some(ProgressPatch::Value(Some(v))) =
5864 patch.downcast_ref::<ProgressPatch>()
5865 {
5866 bridge(|env| DayBridge::setProgress(env, h.0.as_obj(), *v));
5867 }
5868 }
5869 kinds::PICKER => crate::picker::update_any(self, h, patch),
5870 kinds::TEXT_AREA => crate::textarea::update_any(self, h, patch),
5871 kinds::TEXT_FIELD => {
5872 if let Some(p) = patch.downcast_ref::<TextFieldPatch>() {
5873 match p {
5874 TextFieldPatch::Text { text, from_native } => {
5875 if !*from_native {
5876 with_env(|env| {
5877 let s = jstr(env, text);
5878 let _ = java_in(env, |env| {
5879 DayBridge::setTextField(env, h.0.as_obj(), &s)
5880 });
5881 });
5882 }
5883 }
5884 TextFieldPatch::Placeholder(t) => with_env(|env| {
5885 let s = jstr(env, t);
5886 let _ = java_in(env, |env| {
5887 DayBridge::setPlaceholder(env, h.0.as_obj(), &s)
5888 });
5889 }),
5890 TextFieldPatch::Enabled(e) => {
5891 bridge(|env| DayBridge::setEnabled(env, h.0.as_obj(), *e));
5892 }
5893 TextFieldPatch::Select(sel) => {
5894 let at = |n: usize| n.min(i32::MAX as usize) as i32;
5895 bridge(|env| {
5896 DayBridge::setTextFieldSelection(
5897 env,
5898 h.0.as_obj(),
5899 at(sel.start),
5900 at(sel.end),
5901 )
5902 });
5903 }
5904 }
5905 }
5906 }
5907 kinds::LIST => match patch.downcast_ref::<ListPatch>() {
5908 Some(ListPatch::Reload) => {
5909 bridge(|env| DayBridge::listReload(env, h.0.as_obj()));
5912 }
5913 Some(ListPatch::Splice(deltas)) => {
5914 let ops = crate::list_wire::splice_ops(deltas);
5918 java(|env| {
5919 let array = env.new_int_array(ops.len())?;
5920 array.set_region(env, 0, &ops)?;
5921 DayBridge::listSplice(env, h.0.as_obj(), &array)
5922 });
5923 }
5924 Some(ListPatch::ScrollToEnd) => {
5925 bridge(|env| DayBridge::listScrollToEnd(env, h.0.as_obj()));
5927 }
5928 Some(ListPatch::ScrollToRow(row)) => {
5929 bridge(|env| DayBridge::listScrollToRow(env, h.0.as_obj(), *row as i32));
5930 }
5931 Some(ListPatch::Selected(rows)) => {
5932 let key = h.0.as_obj().as_raw() as usize;
5936 if let Some(nid) = LIST_NODE.with(|m| m.borrow().get(&key).copied()) {
5937 LIST_SELECTED.with(|m| {
5938 m.borrow_mut().insert(nid, rows.iter().copied().collect());
5939 });
5940 bridge(|env| DayBridge::listPaintSelection(env, h.0.as_obj(), nid));
5941 }
5942 }
5943 Some(ListPatch::RowSizeInvalidated { cell, height }) => {
5944 let key = h.0.as_obj().as_raw() as usize;
5948 let list = LIST_NODE.with(|m| m.borrow().get(&key).copied());
5949 let (cell, height) = (*cell, *height);
5950 if let Some(nid) = list {
5951 <Material as Platform>::post(Box::new(move || {
5952 let gref = LIST_CELLS.with(|m| {
5954 m.borrow().get(&nid).and_then(|cells| {
5955 cells
5956 .values()
5957 .find(|g| g.as_obj().as_raw() as usize == cell)
5958 .cloned()
5959 })
5960 });
5961 if let Some(gref) = gref {
5962 set_list_cell_height(gref.as_obj(), height);
5963 }
5964 }));
5965 }
5966 }
5967 Some(ListPatch::Editing(_)) | None => {}
5970 },
5971 _ => {
5972 if let Some(update) = self.registry.get(kind).map(|r| r.update) {
5973 update(self, h, patch);
5974 }
5975 }
5976 }
5977 }
5978
5979 fn release_piece(&mut self, kind: day_spec::PieceKind, h: &Self::Handle) {
5981 let f = self.registry.get(kind).and_then(|r| r.release);
5984 if let Some(f) = f {
5985 f(self, h);
5986 }
5987 }
5988 fn release(&mut self, h: AHandle) {
5989 bridge(|env| DayBridge::releaseContextMenu(env, h.0.as_obj()));
5990 bridge(|env| DayTransfer::release(env, h.0.as_obj()));
5991 with_env(|env| {
5994 SECONDARY.with(|s| {
5995 s.borrow_mut().retain(|(_, gref)| {
5996 !env.is_same_object(h.0.as_obj(), gref.as_obj())
5997 .unwrap_or(false)
5998 });
5999 });
6000 });
6001 let key = h.0.as_obj().as_raw() as usize;
6002 day_spec::sidetable::sweep(key);
6006 LABEL_NODE.with(|m| m.borrow_mut().remove(&key));
6007 NAV_MENU_ROWS.with(|m| m.borrow_mut().remove(&key));
6008 LIST_ITEM_PROPS.with(|m| m.borrow_mut().remove(&key));
6009 if let Some(nid) = LIST_NODE.with(|m| m.borrow_mut().remove(&key)) {
6010 release_pinned_header(&h, nid);
6011 TREE_SOURCES.with(|m| m.borrow_mut().remove(&nid));
6012 LIST_SOURCES.with(|m| {
6013 m.borrow_mut().remove(&nid);
6014 });
6015 LIST_CELLS.with(|m| {
6018 m.borrow_mut().remove(&nid);
6019 });
6020 LIST_BINDINGS.with(|m| m.borrow_mut().retain(|(host, _), _| *host != nid));
6021 LIST_SELECTED.with(|m| {
6022 m.borrow_mut().remove(&nid);
6023 });
6024 LIST_AUTOMATIC.with(|m| m.borrow_mut().remove(&nid));
6025 }
6026 bridge(|env| DayBridge::removeChild(env, h.0.as_obj()));
6027 }
6028
6029 fn insert(&mut self, parent: &AHandle, child: &AHandle, _index: usize) {
6030 bridge(|env| DayBridge::addChild(env, parent.0.as_obj(), child.0.as_obj()));
6031 let rows = NAV_MENU_ROWS.with(|m| {
6035 m.borrow()
6036 .get(&(child.0.as_obj().as_raw() as usize))
6037 .cloned()
6038 });
6039 if let Some((node, titles, icons, keys, badges)) = rows {
6040 with_env(|env| {
6041 let t = jstr(env, &titles);
6042 let i = jstr(env, &icons);
6043 let b = jstr(env, &badges);
6044 let _ = java_in(env, |env| {
6045 DayBridge::setNavSuiteRows(env, child.0.as_obj(), &t, &i, &b, node)
6046 });
6047 let keys = jstr(env, &keys);
6048 let _ = java_in(env, |env| {
6049 DayBridge::setDocumentTabKeys(env, child.0.as_obj(), &keys)
6050 });
6051 if env.exception_check() {
6052 env.exception_clear();
6053 }
6054 });
6055 }
6056 }
6057
6058 fn remove(&mut self, _parent: &AHandle, child: &AHandle) {
6059 bridge(|env| DayBridge::removeChild(env, child.0.as_obj()));
6060 }
6061
6062 fn move_child(&mut self, parent: &AHandle, child: &AHandle, to: usize) {
6063 bridge(|env| DayBridge::moveChild(env, parent.0.as_obj(), child.0.as_obj(), to as i32));
6064 }
6065
6066 fn measure(&mut self, h: &AHandle, kind: PieceKind, p: Proposal) -> Size {
6067 let d = density();
6068 match kind {
6069 kinds::LABEL => {
6070 let natural_w = measure_call(h, |env, v| DayBridge::measureWidth(env, v)) / d;
6071 match p.width {
6072 Some(pw) if natural_w > pw => {
6073 let wpx = (pw * d).round() as i32;
6074 let hh = with_env(|env| {
6075 f64::from(
6076 DayBridge::measureHeightForWidth(env, h.0.as_obj(), wpx)
6077 .unwrap_or(0),
6078 )
6079 });
6080 Size::new(pw, hh / d)
6081 }
6082 _ => Size::new(
6083 natural_w,
6084 measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d,
6085 ),
6086 }
6087 }
6088 kinds::NAV_MENU => Size::new(
6089 p.width.unwrap_or(320.0),
6090 p.height.unwrap_or_else(|| {
6091 measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d
6092 }),
6093 ),
6094 kinds::LIST_ITEM => {
6096 let w = p.width.unwrap_or_else(|| {
6097 measure_call(h, |env, v| DayBridge::measureWidth(env, v)) / d
6098 });
6099 let wpx = (w * d).round() as i32;
6100 let hh = with_env(|env| {
6101 f64::from(
6102 DayBridge::measureHeightForWidth(env, h.0.as_obj(), wpx).unwrap_or(0),
6103 )
6104 });
6105 Size::new(w, hh / d)
6106 }
6107 kinds::SLIDER => Size::new(
6108 p.width.unwrap_or(180.0),
6109 (measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d).max(24.0),
6110 ),
6111 kinds::TEXT_AREA => crate::textarea::measure_any(self, h, p),
6113 kinds::TEXT_FIELD => Size::new(
6114 p.width.unwrap_or(180.0),
6115 (measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d).max(40.0),
6116 ),
6117 kinds::DIVIDER => Size::new(p.width.unwrap_or(0.0), 1.0),
6118 kinds::LIST => Size::new(p.width.unwrap_or(0.0), p.height.unwrap_or(0.0)),
6119 kinds::CANVAS => Size::new(
6126 p.width.unwrap_or_else(|| {
6127 measure_call(h, |env, v| DayBridge::measureWidth(env, v)) / d
6128 }),
6129 p.height.unwrap_or_else(|| {
6130 measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d
6131 }),
6132 ),
6133 _ => {
6134 if let Some(measure) = self.registry.get(kind).and_then(|r| r.measure) {
6135 return measure(self, h, p);
6136 }
6137 Size::new(
6138 measure_call(h, |env, v| DayBridge::measureWidth(env, v)) / d,
6139 measure_call(h, |env, v| DayBridge::measureHeight(env, v)) / d,
6140 )
6141 }
6142 }
6143 }
6144
6145 fn first_baseline(&mut self, h: &AHandle, kind: PieceKind, size: Size) -> Option<f64> {
6149 if !day_spec::kind_has_baseline(kind) {
6150 return None;
6151 }
6152 let d = density();
6153 let px = java(|env| {
6154 DayBridge::baselineAt(
6155 env,
6156 h.0.as_obj(),
6157 (size.width * d).round() as i32,
6158 (size.height * d).round() as i32,
6159 )
6160 })?;
6161 (px >= 0).then(|| f64::from(px) / d)
6162 }
6163
6164 fn set_frame(&mut self, h: &AHandle, frame: Rect, anim: Option<&AnimSpec>) {
6165 let d = density();
6168 bridge(|env| {
6169 let (timing, keys) = anim_arrays(env, anim)?;
6170 DayBridge::setFrame(
6171 env,
6172 h.0.as_obj(),
6173 (frame.origin.x * d).round() as i32,
6174 (frame.origin.y * d).round() as i32,
6175 (frame.size.width * d).round() as i32,
6176 (frame.size.height * d).round() as i32,
6177 &timing,
6178 &keys,
6179 )
6180 });
6181 }
6182
6183 fn set_opacity(&mut self, h: &AHandle, opacity: f64, anim: Option<&AnimSpec>) {
6184 bridge(|env| {
6185 let (timing, keys) = anim_arrays(env, anim)?;
6186 DayBridge::setOpacity(env, h.0.as_obj(), opacity as f32, &timing, &keys)
6187 });
6188 }
6189
6190 fn set_transform(
6191 &mut self,
6192 h: &AHandle,
6193 t: Transform,
6194 _size: Size,
6195 anim: Option<&AnimSpec>,
6196 ) {
6197 let d = density();
6198 bridge(|env| {
6199 let (timing, keys) = anim_arrays(env, anim)?;
6200 DayBridge::setTransform(
6201 env,
6202 h.0.as_obj(),
6203 (t.tx * d) as f32,
6204 (t.ty * d) as f32,
6205 t.sx as f32,
6206 t.sy as f32,
6207 t.rotation.degrees() as f32,
6208 &timing,
6209 &keys,
6210 )
6211 });
6212 }
6213
6214 fn read_displayed(&self, h: &AHandle) -> day_spec::Displayed {
6218 if !vm_ready() {
6219 return day_spec::Displayed::default();
6220 }
6221 java(|env| {
6222 let arr = DayBridge::readDisplayed(env, h.0.as_obj())?;
6223 let mut slots = vec![0.0; arr.len(env)?];
6224 arr.get_region(env, 0, &mut slots)?;
6225 Ok(crate::motion_wire::displayed(&slots))
6226 })
6227 .unwrap_or_default()
6228 }
6229
6230 fn set_selectable(&mut self, h: &AHandle, selectable: bool) -> Option<AHandle> {
6231 bridge(|env| {
6234 downcast::<framework::TextView>(env, h.0.as_obj())?
6235 .setTextIsSelectable(env, selectable)
6236 });
6237 None
6238 }
6239
6240 fn set_input_traits(
6241 &mut self,
6242 h: &AHandle,
6243 traits: &day_spec::InputTraits,
6244 ) -> Option<AHandle> {
6245 use day_spec::{InputPurpose, SubmitLabel};
6246 let purpose = match traits.purpose {
6251 InputPurpose::Text => 0,
6252 InputPurpose::Name => 1,
6253 InputPurpose::Email => 2,
6254 InputPurpose::Url => 3,
6255 InputPurpose::Phone => 4,
6256 InputPurpose::Number => 5,
6257 InputPurpose::Decimal => 6,
6258 InputPurpose::Username => 7,
6259 InputPurpose::Password => 8,
6260 InputPurpose::NewPassword => 9,
6261 InputPurpose::OneTimeCode => 10,
6262 };
6263 let submit = match traits.submit_label {
6264 SubmitLabel::Return => 0,
6265 SubmitLabel::Done => 1,
6266 SubmitLabel::Go => 2,
6267 SubmitLabel::Next => 3,
6268 SubmitLabel::Search => 4,
6269 SubmitLabel::Send => 5,
6270 };
6271 with_env(|env| {
6275 let _ = DayBridge::setInputTraits(
6276 env,
6277 h.0.as_obj(),
6278 traits.secure,
6279 traits.read_only,
6280 purpose,
6281 submit,
6282 );
6283 if env.exception_check() {
6284 env.exception_clear();
6285 }
6286 });
6287 None
6288 }
6289
6290 fn set_cursor(&mut self, h: &AHandle, cursor: Cursor) {
6291 let ty = pointer_icon_type(&cursor);
6295 bridge(|env| {
6296 let icon = match ty {
6297 None => JObject::null(),
6298 Some(t) => {
6299 let ctx = DayRuntime::ctx(env)?;
6300 framework::PointerIcon::getSystemIcon(env, &ctx, t)?.into()
6301 }
6302 };
6303 downcast::<framework::View>(env, h.0.as_obj())?.setPointerIcon(env, &icon)
6304 });
6305 }
6306
6307 fn set_scroll_content(&mut self, h: &AHandle, content: Size) {
6308 let d = density();
6309 bridge(|env| {
6310 DayBridge::setScrollContent(
6311 env,
6312 h.0.as_obj(),
6313 (content.width * d).round() as i32,
6314 (content.height * d).round() as i32,
6315 )
6316 });
6317 }
6318
6319 fn list_row_metrics(&mut self, _h: &AHandle) -> day_spec::RowMetrics {
6321 day_spec::RowMetrics {
6322 insets: day_spec::Insets {
6323 top: 8.0,
6324 leading: 16.0,
6325 bottom: 8.0,
6326 trailing: 16.0,
6327 },
6328 min_height: 56.0,
6329 }
6330 }
6331
6332 fn list_scroll(&mut self, h: &AHandle, to: day_spec::ListScroll) -> bool {
6337 let row = to.row.map_or(-1, |r| i32::try_from(r).unwrap_or(i32::MAX));
6338 let align = crate::list_wire::align_code(to.align);
6339 java(|env| DayBridge::listScroll(env, h.0.as_obj(), row, align, to.animated)).is_some()
6340 }
6341
6342 fn nav_scroll_to_edge(&mut self, h: &AHandle, bottom: bool) -> bool {
6343 with_env(|env| DayBridge::navScrollToEdge(env, h.0.as_obj(), bottom).unwrap_or(false))
6344 }
6345
6346 fn scroll_to(&mut self, h: &AHandle, target: Rect, animated: bool) {
6347 let d = density();
6348 bridge(|env| {
6349 DayBridge::scrollToRect(
6350 env,
6351 h.0.as_obj(),
6352 (target.origin.x * d).round() as i32,
6353 (target.origin.y * d).round() as i32,
6354 (target.size.width * d).round() as i32,
6355 (target.size.height * d).round() as i32,
6356 animated,
6357 )
6358 });
6359 }
6360
6361 fn set_focusable(&mut self, h: &AHandle, node: NodeId, focusable: bool) {
6362 if focusable {
6363 bridge(|env| DayBridge::enableKeys(env, h.0.as_obj(), node.0 as i64));
6364 }
6365 }
6366
6367 fn focus(&mut self, h: &AHandle, _node: NodeId, focused: bool) {
6368 bridge(|env| DayBridge::focusView(env, h.0.as_obj(), focused));
6371 }
6372
6373 fn set_event_sink(&mut self, sink: EventSink) {
6374 SINK.with(|s| *s.borrow_mut() = Some(Rc::from(sink)));
6375 }
6376
6377 fn enable_gesture(&mut self, h: &AHandle, node: NodeId, kind: day_spec::GestureKind) {
6378 if kind == day_spec::GestureKind::Pan {
6382 bridge(|env| DayBridge::enablePan(env, h.0.as_obj(), node.0 as i64));
6383 return;
6384 }
6385 if kind == day_spec::GestureKind::Pinch {
6386 bridge(|env| DayBridge::enablePinch(env, h.0.as_obj(), node.0 as i64));
6387 return;
6388 }
6389 if kind == day_spec::GestureKind::Rotate {
6392 bridge(|env| DayBridge::enableRotate(env, h.0.as_obj(), node.0 as i64));
6393 return;
6394 }
6395 if matches!(kind, day_spec::GestureKind::Hover) {
6399 bridge(|env| DayBridge::enableHover(env, h.0.as_obj(), node.0 as i64));
6400 return;
6401 }
6402 let recognizer = match kind {
6407 day_spec::GestureKind::LongPress => Some(bridge::gesture::LONG_PRESS),
6408 day_spec::GestureKind::DoubleTap => Some(bridge::gesture::DOUBLE_TAP),
6409 day_spec::GestureKind::Press => Some(bridge::gesture::PRESS_IN),
6410 day_spec::GestureKind::Touches => Some(bridge::gesture::TOUCHES),
6411 _ => None,
6412 };
6413 if let Some(code) = recognizer {
6414 bridge(|env| DayBridge::enableRecognizer(env, h.0.as_obj(), node.0 as i64, code));
6415 return;
6416 }
6417 let is_drag = matches!(kind, day_spec::GestureKind::Drag);
6418 bridge(|env| DayBridge::enableGesture(env, h.0.as_obj(), node.0 as i64, is_drag));
6419 }
6420
6421 fn gesture_support(&self, _kind: day_spec::GestureKind) -> Support {
6422 Support::Native
6426 }
6427
6428 fn set_hit_slop(&mut self, h: &AHandle, _node: NodeId, slop: day_spec::Insets) {
6429 let d = density();
6431 let px = |v: f64| (v.max(0.0) * d).round() as i32;
6432 bridge(|env| {
6433 DayBridge::setHitSlop(
6434 env,
6435 h.0.as_obj(),
6436 px(slop.top),
6437 px(slop.leading),
6438 px(slop.bottom),
6439 px(slop.trailing),
6440 )
6441 });
6442 }
6443
6444 fn set_drag_axis(&mut self, h: &AHandle, _node: NodeId, axis: Option<day_spec::DragAxis>) {
6445 let code = match axis {
6446 None => 0,
6447 Some(day_spec::DragAxis::Horizontal) => 1,
6448 Some(day_spec::DragAxis::Vertical) => 2,
6449 };
6450 bridge(|env| DayBridge::setDragAxis(env, h.0.as_obj(), code));
6451 }
6452
6453 fn set_subtree_enabled(&mut self, h: &AHandle, _node: NodeId, enabled: bool) {
6454 bridge(|env| DayBridge::setSubtreeEnabled(env, h.0.as_obj(), enabled));
6455 }
6456
6457 fn primary_pointer(&self) -> day_spec::PointerKind {
6458 with_env(|env| java_string(env, DayBridge::primaryPointer))
6461 .and_then(|name| day_spec::PointerKind::from_name(&name))
6462 .unwrap_or_else(day_spec::PointerKind::platform_default)
6463 }
6464
6465 fn set_context_menu_fn(&mut self, h: &AHandle, _node: NodeId, f: day_spec::ContextMenuFn) {
6466 let key = h.0.as_obj().as_raw() as usize;
6467 CONTEXT_MENU_FNS.with(|menus| menus.insert(key, f));
6468 bridge(|env| DayBridge::setContextMenuFn(env, h.0.as_obj(), key as i64));
6469 }
6470
6471 fn set_button_menu(&mut self, h: &AHandle, _node: NodeId, f: day_spec::ContextMenuFn) {
6472 let key = h.0.as_obj().as_raw() as usize;
6475 BUTTON_MENU_FNS.with(|menus| menus.insert(key, f));
6476 bridge(|env| DayBridge::setButtonMenu(env, h.0.as_obj(), key as i64));
6477 }
6478
6479 fn set_context_menu(&mut self, h: &AHandle, _node: NodeId, items: &[day_spec::MenuItem]) {
6480 CONTEXT_MENU_FNS.with(|menus| menus.remove(h.0.as_obj().as_raw() as usize));
6481 let mut spec = String::new();
6482 serialize_menu(items, &mut spec);
6483 with_env(|env| {
6484 let jspec = jstr(env, &spec);
6485 let _ = java_in(env, |env| {
6486 DayBridge::setContextMenu(env, h.0.as_obj(), &jspec)
6487 });
6488 });
6489 }
6490
6491 fn edit_toolbar(&mut self, h: &AHandle, ops: &[day_spec::ToolbarOp]) -> bool {
6492 let key = h.0.as_obj().as_raw() as usize;
6499 let spec = WINDOW_BARS.with(|m| {
6500 let mut m = m.borrow_mut();
6501 let bar = m.entry(key).or_default();
6502 for op in ops {
6503 bar.apply(op);
6504 }
6505 serialize_toolbar(bar.items())
6506 });
6507 with_env(|env| {
6508 let jspec = jstr(env, &spec);
6509 let _ = java_in(env, |env| {
6510 DayBridge::setWindowToolbar(env, h.0.as_obj(), &jspec)
6511 });
6512 if env.exception_check() {
6513 env.exception_clear();
6514 }
6515 });
6516 true
6517 }
6518
6519 fn update_toolbar(&mut self, h: &AHandle, patch: &day_spec::ToolbarPatch) {
6520 use day_spec::ToolbarPatch as P;
6521 let key = h.0.as_obj().as_raw() as usize;
6523 WINDOW_BARS.with(|m| {
6524 if let Some(bar) = m.borrow_mut().get_mut(&key) {
6525 bar.patch(patch);
6526 }
6527 });
6528 let (item, op, num) = match patch {
6529 P::Enabled { item, on } => (item, 0, f64::from(u8::from(*on))),
6530 P::On { item, on } => (item, 1, f64::from(u8::from(*on))),
6531 P::Selected { item, index } => (item, 2, *index as f64),
6532 P::Focus { item } => (item, 3, 0.0),
6534 P::Text { item, text } => {
6537 with_env(|env| {
6538 let jid = jstr(env, item);
6539 let jtext = jstr(env, text);
6540 let _ = java_in(env, |env| {
6541 DayBridge::updateWindowToolbarText(env, h.0.as_obj(), &jid, &jtext)
6542 });
6543 if env.exception_check() {
6544 env.exception_clear();
6545 }
6546 });
6547 return;
6548 }
6549 P::Suggestions { .. } => return,
6551 P::Label { item, label, .. }
6557 if WINDOW_BARS.with(|m| {
6558 m.borrow().get(&key).is_some_and(|bar| {
6559 bar.items().iter().any(|i| {
6560 i.id == *item
6561 && i.placement == day_spec::ToolbarPlacement::Bottom
6562 && matches!(i.kind, day_spec::ToolbarItemKind::Label)
6563 })
6564 })
6565 }) =>
6566 {
6567 with_env(|env| {
6568 let jid = jstr(env, item);
6569 let jtext = jstr(env, label);
6570 let _ = java_in(env, |env| {
6571 DayBridge::updateWindowToolbarText(env, h.0.as_obj(), &jid, &jtext)
6572 });
6573 if env.exception_check() {
6574 env.exception_clear();
6575 }
6576 });
6577 return;
6578 }
6579 P::Label { .. } | P::Placeholder { .. } => {
6580 let spec = WINDOW_BARS.with(|m| {
6581 m.borrow()
6582 .get(&key)
6583 .map(|bar| serialize_toolbar(bar.items()))
6584 });
6585 if let Some(spec) = spec {
6586 with_env(|env| {
6587 let jspec = jstr(env, &spec);
6588 let _ = java_in(env, |env| {
6589 DayBridge::setWindowToolbar(env, h.0.as_obj(), &jspec)
6590 });
6591 if env.exception_check() {
6592 env.exception_clear();
6593 }
6594 });
6595 }
6596 return;
6597 }
6598 };
6599 with_env(|env| {
6600 let jid = jstr(env, item);
6601 let _ = java_in(env, |env| {
6602 DayBridge::updateWindowToolbar(env, h.0.as_obj(), &jid, op, num)
6603 });
6604 if env.exception_check() {
6605 env.exception_clear();
6606 }
6607 });
6608 }
6609
6610 fn set_app_menu(&mut self, items: &[day_spec::MenuItem]) {
6611 let mut spec = String::new();
6614 serialize_menu(items, &mut spec);
6615 with_env(|env| {
6616 let jspec = jstr(env, &spec);
6617 let _ = java_in(env, |env| DayBridge::setAppMenu(env, &jspec));
6618 });
6619 }
6620
6621 fn supports_lifecycle(&self, phase: day_spec::Lifecycle) -> bool {
6622 lifecycle_supported(phase)
6623 }
6624
6625 fn attach_tree(&mut self, host: &AHandle, source: day_spec::TreeSource) {
6626 if let Some(id) = LIST_NODE.with(|m| {
6627 m.borrow()
6628 .get(&(host.0.as_obj().as_raw() as usize))
6629 .copied()
6630 }) {
6631 TREE_SOURCES.with(|m| m.borrow_mut().insert(id, (source, Vec::new(), Vec::new())));
6632 tree_reload(host);
6633 }
6634 }
6635 fn attach_list(&mut self, host: &AHandle, source: ListSource) {
6636 let viewport = source.viewport.is_some();
6639 if !viewport && let Some(report) = &source.first_visible {
6640 report(0);
6641 }
6642 let reader = source.reader_scroll.is_some();
6643 let supplements = source.is_supplement.is_some();
6644 bridge(|env| {
6645 DayBridge::listConfigure(env, host.0.as_obj(), viewport, reader, supplements)
6646 });
6647 let key = host.0.as_obj().as_raw() as usize;
6648 if let Some(nid) = LIST_NODE.with(|m| m.borrow().get(&key).copied()) {
6649 LIST_SOURCES.with(|m| {
6650 m.borrow_mut().insert(nid, source);
6651 });
6652 }
6653 bridge(|env| DayBridge::listReload(env, host.0.as_obj()));
6654 }
6655
6656 fn adopt(&mut self, raw: RawHandle) -> AHandle {
6657 with_env(|env| {
6659 let obj = unsafe { JObject::from_raw(env, raw as jni::sys::jobject) };
6660 AHandle(std::sync::Arc::new(
6661 env.new_global_ref(&obj).expect("adopt: global ref"),
6664 ))
6665 })
6666 }
6667
6668 fn native_document_tabs(&self) -> bool {
6669 true
6670 }
6671
6672 fn open_window(
6673 &mut self,
6674 id: NodeId,
6675 options: &day_spec::WindowOptions,
6676 kind: day_spec::WindowKind,
6677 ) -> day_spec::WindowOpenReply<AHandle> {
6678 if kind.is_panel() {
6681 return day_spec::WindowOpenReply::Unsupported;
6682 }
6683 let ok = with_env(|env| {
6684 let Ok(title) = env.new_string(&options.title) else {
6685 return false;
6686 };
6687 java_in(env, |env| DayBridge::openWindow(env, id.0 as i64, &title)).is_some()
6688 });
6689 if ok {
6690 day_spec::WindowOpenReply::Pending
6691 } else {
6692 day_spec::WindowOpenReply::Unsupported
6693 }
6694 }
6695
6696 fn close_window(&mut self, host: &AHandle) {
6697 with_env(|env| {
6698 if let Some(node) = secondary_node_of(env, host) {
6699 let _ = java_in(env, |env| DayBridge::closeWindow(env, node as i64));
6700 }
6701 });
6702 }
6703
6704 fn focus_window(&mut self, host: &AHandle) {
6705 with_env(|env| {
6706 if let Some(node) = secondary_node_of(env, host) {
6707 let _ = java_in(env, |env| DayBridge::focusWindow(env, node as i64));
6708 }
6709 });
6710 }
6711
6712 fn apply_window(&mut self, host: &AHandle, change: &day_spec::WindowChange) {
6717 use day_spec::WindowChange as C;
6718 with_env(|env| {
6719 let node = secondary_node_of(env, host).unwrap_or(0) as i64;
6720 match change {
6721 C::State(state) => {
6722 let _ = java_in(env, |env| {
6723 DayBridge::setWindowState(env, node, state.code())
6724 });
6725 }
6726 C::ContentProtected(on) => {
6727 let _ = java_in(env, |env| DayBridge::setWindowSecure(env, node, *on));
6728 }
6729 _ => {}
6735 }
6736 });
6737 }
6738
6739 fn monitors(&self) -> Vec<day_spec::Monitor> {
6742 let line = with_env(|env| {
6743 let info = DayBridge::displayInfo(env).ok()?;
6744 if info.is_null() {
6745 return None;
6746 }
6747 string_of(env, &info).ok()
6748 });
6749 line.and_then(|l| parse_display_info(&l))
6750 .into_iter()
6751 .collect()
6752 }
6753
6754 fn set_launcher_shortcuts(&mut self, shortcuts: &[day_spec::LauncherShortcut]) {
6757 let packed = shortcuts
6759 .iter()
6760 .map(|sc| {
6761 let clean = |s: &str| s.replace(['\u{1e}', '\u{1f}'], " ");
6762 format!("{}\u{1f}{}", clean(&sc.route), clean(&sc.label))
6763 })
6764 .collect::<Vec<_>>()
6765 .join("\u{1e}");
6766 with_env(|env| {
6767 let jpacked = jstr(env, &packed);
6768 let _ = java_in(env, |env| DayBridge::setLauncherShortcuts(env, &jpacked));
6769 });
6770 }
6771
6772 fn set_window_title(&mut self, host: &AHandle, title: &str) {
6773 with_env(|env| {
6774 let Ok(jtitle) = env.new_string(title) else {
6775 return;
6776 };
6777 match secondary_node_of(env, host) {
6778 Some(node) => {
6779 let _ = java_in(env, |env| {
6780 DayBridge::setWindowTitle(env, node as i64, &jtitle)
6781 });
6782 }
6783 None => {
6787 let _ = java_in(env, |env| DayBridge::setPrimaryWindowTitle(env, &jtitle));
6788 }
6789 }
6790 });
6791 }
6792
6793 fn set_a11y(&mut self, h: &AHandle, a11y: &A11yProps) {
6794 let (role, level) = match a11y.role {
6798 Role::None => (0, 0),
6799 Role::Button => (1, 0),
6800 Role::Toggle => (2, 0),
6801 Role::Slider => (3, 0),
6802 Role::TextInput => (4, 0),
6803 Role::Heading(level) => (5, i32::from(level)),
6804 Role::Image => (6, 0),
6805 Role::Meter => (7, 0),
6806 Role::Group => (8, 0),
6807 Role::Tree => (9, 0),
6808 Role::TreeItem => (10, 0),
6809 Role::Tab => (11, 0),
6810 Role::TabList => (12, 0),
6811 };
6812 with_env(|env| {
6813 let label = jstr(env, a11y.label.as_deref().unwrap_or(""));
6814 let hint = jstr(env, a11y.hint.as_deref().unwrap_or(""));
6815 let value = jstr(env, a11y.value.as_deref().unwrap_or(""));
6816 let id = jstr(env, a11y.identifier.as_deref().unwrap_or(""));
6817 let selected = a11y.selected.map_or(-1, i32::from);
6819 let _ = java_in(env, |env| {
6820 DayBridge::setA11y(
6821 env,
6822 h.0.as_obj(),
6823 &label,
6824 &hint,
6825 &value,
6826 &id,
6827 role,
6828 level,
6829 a11y.hidden,
6830 selected,
6831 )
6832 });
6833 });
6834 }
6835
6836 fn read_native(&self, h: &AHandle) -> day_spec::NativeSnapshot {
6839 if !vm_ready() {
6840 return day_spec::NativeSnapshot::default();
6841 }
6842 let slots: Vec<Option<String>> = java(|env| {
6843 let arr = DayBridge::readNative(env, h.0.as_obj())?;
6844 let len = arr.len(env)?;
6845 let mut slots = Vec::with_capacity(len);
6846 for i in 0..len {
6847 let s = arr.get_element(env, i)?;
6848 slots.push(read_jstring(env, &s));
6849 }
6850 Ok(slots)
6851 })
6852 .unwrap_or_default();
6853 let slot = |i: usize| slots.get(i).cloned().flatten();
6854 let flag = |i: usize| slot(i).map(|s| s == "1");
6855 let found = flag(0) == Some(true);
6856 let role = match slot(1).and_then(|s| s.parse::<i32>().ok()) {
6858 Some(1) => Role::Button,
6859 Some(2) => Role::Toggle,
6860 Some(3) => Role::Slider,
6861 Some(4) => Role::TextInput,
6862 Some(5) => Role::Heading(1),
6863 Some(6) => Role::Image,
6864 Some(7) => Role::Meter,
6865 Some(8) => Role::Group,
6866 _ => Role::None,
6867 };
6868 let frame = slot(10).and_then(|s| {
6869 let v: Vec<f64> = s.split(',').filter_map(|n| n.parse().ok()).collect();
6870 match v[..] {
6871 [x, y, w, h] => Some(Rect::new(x, y, w, h)),
6872 _ => None,
6873 }
6874 });
6875 day_spec::NativeSnapshot {
6876 found,
6877 role,
6878 label: found.then(|| slot(2)).flatten(),
6879 value: found.then(|| slot(3)).flatten(),
6880 identifier: found.then(|| slot(4)).flatten().filter(|s| !s.is_empty()),
6881 text: slot(5),
6882 number: slot(6).and_then(|s| s.parse().ok()),
6883 checked: flag(7),
6884 enabled: flag(8),
6885 visible: flag(9),
6886 frame,
6887 }
6888 }
6889
6890 fn announce(&mut self, text: &str, urgent: bool) {
6891 with_env(|env| {
6892 let text = jstr(env, text);
6893 let _ = java_in(env, |env| DayBridge::announce(env, &text, urgent));
6894 });
6895 }
6896
6897 fn request_frame(
6898 &mut self,
6899 _host: &AHandle,
6900 cb: day_spec::FrameCallback,
6901 ) -> day_spec::CancelFrame {
6902 let token = day_core::frame::native::register(cb);
6903 bridge(|env| DayBridge::requestFrame(env, token as i64));
6904 Box::new(move || {
6905 day_core::frame::native::cancel(token);
6906 bridge(|env| DayBridge::cancelFrame(env, token as i64));
6907 })
6908 }
6909
6910 fn replay(&mut self, h: &AHandle, ops: &[DrawOp], _size: Size) {
6914 let (nums, texts, geometry) = day_spec::encode_ops_with_geometry(ops);
6915 with_env(|env| {
6916 let Ok(arr) = env.new_double_array(nums.len()) else {
6919 return;
6920 };
6921 if arr.set_region(env, 0, &nums).is_err() {
6922 return;
6923 }
6924 let Ok(geo) = env.new_double_array(geometry.len()) else {
6925 return;
6926 };
6927 if geo.set_region(env, 0, &geometry).is_err() {
6928 return;
6929 }
6930 let joined = jstr(env, &texts.join("\u{1f}"));
6931 let _ = java_in(env, |env| {
6932 DayBridge::setCanvasOps(env, h.0.as_obj(), &arr, &joined, &geo)
6933 });
6934 });
6935 }
6936
6937 fn snapshot_origin(&mut self, root: &AHandle) -> Option<Point> {
6941 if !vm_ready() {
6942 return None;
6943 }
6944 let text = with_env(|env| {
6945 let obj = DayBridge::snapshotOrigin(env, root.0.as_obj()).ok()?;
6946 if obj.is_null() {
6947 return None;
6948 }
6949 string_of(env, &obj).ok()
6950 })?;
6951 let (x, y) = text.split_once(',')?;
6952 Some(Point::new(x.parse().ok()?, y.parse().ok()?))
6953 }
6954
6955 fn font_families(&mut self) -> Vec<day_spec::FontFamilyInfo> {
6956 if !vm_ready() {
6957 return Vec::new();
6958 }
6959 let text = with_env(|env| {
6960 let obj = DayBridge::fontFamilies(env).ok()?;
6961 if obj.is_null() {
6962 return None;
6963 }
6964 string_of(env, &obj).ok()
6965 });
6966 day_spec::parse_font_list(&text.unwrap_or_default())
6967 }
6968
6969 fn measure_text(
6972 &mut self,
6973 text: &str,
6974 size: f64,
6975 font: &day_spec::CanvasFont,
6976 ) -> Option<day_spec::TextMetrics> {
6977 if !vm_ready() {
6978 return None;
6979 }
6980 let reply = with_env(|env| {
6981 let jtext = jstr(env, text);
6982 let jfamily = jstr(env, font.family_str());
6983 let weight = i32::from(font.css_weight());
6984 java_string(env, |env| {
6985 DayBridge::measureText(env, &jtext, size, weight, font.italic, &jfamily)
6986 })
6987 })?;
6988 let mut out = [0.0f64; 8];
6990 let mut it = reply.split(',');
6991 for slot in &mut out {
6992 *slot = it.next()?.trim().parse::<f64>().ok()?;
6993 }
6994 Some(day_spec::TextMetrics::from_slots(&out))
6995 }
6996
6997 fn decode_image(&mut self, req: u64, id: day_spec::BitmapId, bytes: &[u8]) {
7003 let reply = if vm_ready() {
7004 with_env(|env| {
7005 let arr = env.byte_array_from_slice(bytes).ok()?;
7006 java_string(env, |env| DayBridge::imageDecode(env, id.0 as i64, &arr))
7007 })
7008 } else {
7009 None
7010 };
7011 let parsed = reply.and_then(|r| {
7014 let mut it = r.split(',');
7015 let w = it.next()?.trim().parse::<f64>().ok()?;
7016 let h = it.next()?.trim().parse::<f64>().ok()?;
7017 let alpha = it.next()?.trim().parse::<i32>().ok()?;
7018 Some((w, h, alpha != 0))
7019 });
7020 let event = match parsed {
7021 Some((w, h, has_alpha)) => {
7022 let info = day_spec::BitmapInfo {
7023 pixels: Size::new(w, h),
7024 scale: 1.0,
7026 format: day_spec::ImageFormat::sniff(bytes),
7027 has_alpha,
7028 };
7029 BITMAP_INFO.with(|m| m.borrow_mut().insert(id.0, info));
7030 Event::ImageDecoded {
7031 req,
7032 result: Ok(info),
7033 }
7034 }
7035 None => Event::ImageDecoded {
7036 req,
7037 result: Err(day_spec::ImageError::Decode),
7038 },
7039 };
7040 emit(day_spec::WINDOW_NODE, event);
7041 }
7042
7043 fn image_info(&mut self, id: day_spec::BitmapId) -> Option<day_spec::BitmapInfo> {
7044 BITMAP_INFO.with(|m| m.borrow().get(&id.0).copied())
7045 }
7046
7047 fn encode_image(&mut self, req: u64, id: day_spec::BitmapId, spec: &day_spec::EncodeSpec) {
7048 let result = encode_bitmap(id, spec);
7049 emit(day_spec::WINDOW_NODE, Event::ImageEncoded { req, result });
7050 }
7051
7052 fn encode_formats(&mut self) -> Vec<day_spec::ImageFormat> {
7056 use day_spec::ImageFormat::{Jpeg, Png};
7057 vec![Png, Jpeg]
7058 }
7059
7060 fn release_image(&mut self, id: day_spec::BitmapId) {
7061 BITMAP_INFO.with(|m| {
7062 m.borrow_mut().remove(&id.0);
7063 });
7064 if vm_ready() {
7065 with_env(|env| {
7066 let _ = DayBridge::imageRelease(env, id.0 as i64);
7067 });
7068 }
7069 }
7070
7071 fn render_bitmap(
7082 &mut self,
7083 req: u64,
7084 id: day_spec::BitmapId,
7085 ops: &[DrawOp],
7086 size: Size,
7087 scale: f64,
7088 ) {
7089 if !vm_ready() {
7090 let result = Err(day_spec::ExportError::Unsupported);
7091 emit(day_spec::WINDOW_NODE, Event::BitmapRendered { req, result });
7092 return;
7093 }
7094 let (pw, ph) = day_spec::export_pixels(size, scale);
7095 let ops = ops.to_vec();
7096 day_spec::offscreen::spawn(move || {
7097 let result = day_spec::ffi_guard::contain(
7098 Err(day_spec::ExportError::Failed(
7099 "the offscreen painter panicked".into(),
7100 )),
7101 || export_bitmap(id, &ops, pw, ph, scale),
7102 );
7103 <Material as Platform>::post(Box::new(move || {
7104 if let Ok(info) = result {
7105 BITMAP_INFO.with(|m| m.borrow_mut().insert(id.0, info));
7106 }
7107 emit(day_spec::WINDOW_NODE, Event::BitmapRendered { req, result });
7108 }));
7109 });
7110 }
7111
7112 fn render_pdf(&mut self, req: u64, pages: &[day_spec::PdfPage], _info: &day_spec::PdfInfo) {
7116 let result = export_pdf(pages);
7117 emit(day_spec::WINDOW_NODE, Event::PdfRendered { req, result });
7118 }
7119
7120 fn snapshot_window(&mut self) -> Result<Vec<u8>, String> {
7121 android_window_image(false)
7122 }
7123
7124 fn snapshot_window_chrome(&mut self) -> Result<Vec<u8>, String> {
7127 android_window_image(true)
7128 }
7129
7130 fn set_appearance(&mut self, dark: Option<bool>) {
7135 let mode = match dark {
7136 Some(false) => 0i32,
7137 Some(true) => 1,
7138 None => 2,
7139 };
7140 with_env(|env| {
7141 let _ = DayBridge::setAppearance(env, mode);
7142 });
7143 }
7144
7145 fn system_color(&mut self, role: day_spec::SystemColor) -> day_spec::Color {
7150 use day_spec::SystemColor;
7151 if matches!(role, SystemColor::Success | SystemColor::Warning) {
7152 return role.fallback(self.dark_mode());
7153 }
7154 let index = i32::from(role.wire());
7155 let argb = with_env(|env| DayBridge::systemColor(env, index).unwrap_or(0)) as u32;
7156 if argb == 0 {
7157 return role.fallback(self.dark_mode());
7158 }
7159 let channel = |shift: u32| f64::from((argb >> shift) & 0xff) / 255.0;
7160 day_spec::Color::rgba(channel(16), channel(8), channel(0), channel(24))
7161 }
7162
7163 fn dark_mode(&mut self) -> bool {
7165 match std::env::var("DAY_THEME").ok().as_deref() {
7166 Some("dark") => return true,
7167 Some("light") => return false,
7168 _ => {}
7169 }
7170 with_env(|env| DayBridge::isDarkMode(env).unwrap_or(false))
7171 }
7172
7173 fn reduce_motion(&mut self) -> bool {
7178 with_env(|env| DayBridge::reduceMotion(env).unwrap_or(false))
7179 }
7180
7181 fn text_scale(&mut self, style: Font) -> f64 {
7188 let sp = font_style(style).0;
7189 let scale = java(|env| DayBridge::textScale(env, sp)).map_or(1.0, f64::from);
7190 if scale.is_finite() && scale > 0.0 {
7191 scale
7192 } else {
7193 1.0
7194 }
7195 }
7196
7197 fn set_layout_direction(
7202 &mut self,
7203 h: &AHandle,
7204 kind: PieceKind,
7205 direction: day_spec::LayoutDirection,
7206 ) {
7207 if matches!(
7208 kind,
7209 kinds::CONTAINER
7210 | kinds::SCROLL
7211 | kinds::NAV
7212 | kinds::NAV_PAGE
7213 | kinds::LIST
7214 | kinds::LIST_CELL
7215 | kinds::TREE
7216 | kinds::COVER
7217 | kinds::INSPECTOR
7218 | kinds::INSPECTOR_PANE
7219 | kinds::SPLIT
7220 | kinds::SPLIT_PANE
7221 ) {
7222 return;
7223 }
7224 let rtl = direction == day_spec::LayoutDirection::Rtl;
7225 bridge(|env| DayBridge::setViewDirection(env, h.0.as_obj(), rtl));
7226 }
7227
7228 fn native_back(&mut self) -> bool {
7233 with_env(|env| DayBridge::nativeBack(env).unwrap_or(false))
7234 }
7235
7236 fn set_system_back(&mut self, armed: bool) {
7241 with_env(|env| {
7242 let _ = java_in(env, |env| DayBridge::setAppBack(env, armed));
7243 });
7244 }
7245
7246 fn prepare_snapshot(
7250 &mut self,
7251 host: Option<&Self::Handle>,
7252 revision: u32,
7253 ) -> Result<day_spec::capture::Readiness, String> {
7254 with_env(|env| {
7255 let null = JObject::null();
7256 let obj = host.map_or(&null, |h| h.0.as_obj());
7257 let ready = DayBridge::prepareSnapshot(env, obj, i64::from(revision))
7258 .map_err(|e| format!("frame commit: {e}"))?;
7259 Ok(if ready == 1 {
7260 day_spec::capture::Readiness::Ready
7261 } else {
7262 day_spec::capture::Readiness::Pending
7263 })
7264 })
7265 }
7266
7267 fn ui_idle(&mut self) -> bool {
7268 with_env(|env| DayBridge::uiIdle(env).unwrap_or(true))
7269 }
7270 }
7271
7272 const REMOUNT_ROUTE_KEY: &str = "day.route";
7276
7277 fn save_route_for_remount(env: &mut Env) {
7286 let Some(route) = day_core::current_route() else {
7287 return;
7288 };
7289 let k = jstr(env, REMOUNT_ROUTE_KEY);
7290 let v = jstr(env, &route);
7291 let _ = java_in(env, |env| DayBridge::navSave(env, &k, &v));
7292 }
7293
7294 fn nav_take(env: &mut Env, key: &str) -> Option<String> {
7296 let k = jstr(env, key);
7297 java_string(env, |env| DayBridge::navTake(env, &k))
7298 }
7299
7300 pub fn mount_settled(remount: bool) {
7312 day_reactive::on_main(move || {
7313 if remount {
7314 let saved = with_env(|env| nav_take(env, REMOUNT_ROUTE_KEY));
7315 if let Some(route) = saved {
7316 if day_core::has_launch_deeplink() {
7317 log::info!(
7318 "day-toolkit-material: re-mount keeps the launch deep link over {route:?}"
7319 );
7320 } else if day_core::current_route().as_deref() != Some(route.as_str())
7321 && !day_core::navigate(&route)
7322 {
7323 log::warn!(
7324 "day-toolkit-material: re-mount could not restore route {route:?}"
7325 );
7326 }
7327 }
7328 }
7329 note_text_scale_of_mount();
7330 with_env(|env| {
7331 let _ = DayBridge::mountSettled(env);
7332 });
7333 });
7334 }
7335
7336 thread_local! {
7337 static MOUNT_TEXT_SCALE: std::cell::Cell<Option<f64>> = const { std::cell::Cell::new(None) };
7341 }
7342
7343 fn note_text_scale_of_mount() {
7350 let now = day_core::text_scale_of(Font::Body);
7351 let before = MOUNT_TEXT_SCALE.with(|c| c.replace(Some(now)));
7352 if let Some(b) = before.filter(|b| (b - now).abs() > 1e-6) {
7353 log::info!("day-toolkit-material: text scale {b:.2} -> {now:.2}, re-notifying");
7354 day_core::note_text_size_changed();
7355 }
7356 }
7357
7358 struct InstanceNavStore;
7365
7366 impl day_core::NavStore for InstanceNavStore {
7367 fn load(&self, key: &str) -> Option<String> {
7368 if !vm_ready() {
7369 return None;
7370 }
7371 with_env(|env| {
7372 let k = jstr(env, key);
7373 java_string(env, |env| DayBridge::navLoad(env, &k))
7374 })
7375 }
7376
7377 fn save(&self, key: &str, value: &str) {
7378 if !vm_ready() {
7379 return;
7380 }
7381 with_env(|env| {
7382 let k = jstr(env, key);
7383 let v = jstr(env, value);
7384 let _ = java_in(env, |env| DayBridge::navSave(env, &k, &v));
7385 });
7386 }
7387 }
7388
7389 impl Platform for Material {
7390 const TARGET: &'static str = "android-material";
7391 const TOOLKIT: &'static str = "material";
7392 const RUN_ENDS_APP: bool = false;
7394
7395 fn run(self, _options: WindowOptions, ready: Box<dyn FnOnce(Self, AHandle, Size)>) {
7396 let (root, size) = ROOT
7398 .with(|r| r.borrow_mut().take())
7399 .expect("day-toolkit-material: init() not called");
7400 day_core::set_nav_store(std::rc::Rc::new(InstanceNavStore));
7406 ready(self, root, size);
7407 }
7408
7409 fn locale_hints(&self) -> Vec<String> {
7410 if !vm_ready() {
7415 return Vec::new();
7416 }
7417 let joined = with_env(|env| {
7418 let obj = DayBridge::localeTags(env).ok()?;
7419 if obj.is_null() {
7420 return None;
7421 }
7422 string_of(env, &obj).ok()
7423 });
7424 joined
7425 .unwrap_or_default()
7426 .split(',')
7427 .map(str::trim)
7428 .filter(|t| !t.is_empty())
7429 .map(str::to_string)
7430 .collect()
7431 }
7432
7433 fn post(f: Box<dyn FnOnce() + Send>) {
7434 let token = Box::into_raw(Box::new(f)) as i64;
7435 bridge(|env| DayBridge::postMain(env, token));
7438 }
7439
7440 fn post_delayed(ms: u32, f: Box<dyn FnOnce() + Send>) {
7441 let token = Box::into_raw(Box::new(f)) as i64;
7445 bridge(|env| DayBridge::postMainDelayed(env, token, i64::from(ms)));
7446 }
7447 }
7448}