1use crate::canvas::TextService;
9use crate::geometry::{RectF, SizeF};
10
11#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
13pub struct WindowId(pub u64);
14
15#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
17pub struct TimerId(pub u64);
18
19pub trait WindowService {
21 fn create_window(&mut self, title: &str, size: SizeF) -> WindowId;
22 fn close_window(&mut self, window: WindowId);
23 fn set_title(&mut self, window: WindowId, title: &str);
24 fn set_size(&mut self, window: WindowId, size: SizeF);
25 fn request_redraw(&mut self, window: WindowId);
27 fn scale_factor(&self, window: WindowId) -> f32;
29}
30
31pub trait TimerService {
33 fn start_timer(&mut self, interval_ms: u32, repeat: bool) -> TimerId;
34 fn stop_timer(&mut self, timer: TimerId);
35 fn request_frame(&mut self);
37 fn now(&self) -> f64;
39}
40
41pub trait ClipboardService {
44 fn get_text(&mut self) -> Option<String>;
45 fn set_text(&mut self, text: &str);
46
47 fn set_content(&mut self, content: &crate::clipboard::ClipboardContent) {
49 self.set_text(content.text.as_deref().unwrap_or(""));
50 }
51
52 fn get_html(&mut self) -> Option<String> {
53 None
54 }
55
56 fn get_image(&mut self) -> Option<crate::Image> {
57 None
58 }
59
60 fn get_data(&mut self, _format: &str) -> Option<Vec<u8>> {
62 None
63 }
64
65 fn has(&mut self, format: &str) -> bool {
67 match format {
68 crate::clipboard::HTML => self.get_html().is_some(),
69 crate::clipboard::IMAGE => self.get_image().is_some(),
70 _ => self.get_data(format).is_some(),
71 }
72 }
73
74 fn sequence(&mut self) -> Option<u64> {
77 None
78 }
79}
80
81#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
82pub enum CursorShape {
83 #[default]
84 Default,
85 Pointer,
86 Text,
87 Wait,
88 Crosshair,
89 Move,
90 NotAllowed,
91 ResizeHorizontal,
92 ResizeVertical,
93 ResizeNeSw,
94 ResizeNwSe,
95 Grab,
97 Grabbing,
98 None,
100}
101
102impl CursorShape {
103 pub const ALL: [CursorShape; 14] = [
104 CursorShape::Default,
105 CursorShape::Pointer,
106 CursorShape::Text,
107 CursorShape::Wait,
108 CursorShape::Crosshair,
109 CursorShape::Move,
110 CursorShape::NotAllowed,
111 CursorShape::ResizeHorizontal,
112 CursorShape::ResizeVertical,
113 CursorShape::ResizeNeSw,
114 CursorShape::ResizeNwSe,
115 CursorShape::Grab,
116 CursorShape::Grabbing,
117 CursorShape::None,
118 ];
119}
120
121impl crate::prop::PropEnum for CursorShape {
122 const NAMES: &'static [&'static str] = &[
123 "default",
124 "pointer",
125 "text",
126 "wait",
127 "crosshair",
128 "move",
129 "not_allowed",
130 "resize_horizontal",
131 "resize_vertical",
132 "resize_ne_sw",
133 "resize_nw_se",
134 "grab",
135 "grabbing",
136 "none",
137 ];
138
139 fn from_index(index: usize) -> Option<Self> {
140 CursorShape::ALL.get(index).copied()
141 }
142
143 fn index(self) -> usize {
144 self as usize
145 }
146}
147
148pub trait CursorService {
150 fn set_cursor(&mut self, shape: CursorShape);
151}
152
153#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
155pub enum Appearance {
156 #[default]
157 Light,
158 Dark,
159}
160
161pub trait ScreenService {
163 fn screen_size(&self) -> SizeF;
164 fn scale_factor(&self) -> f32;
165 fn appearance(&self) -> Appearance;
167}
168
169#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
171pub enum KeyboardKind {
172 #[default]
173 Text,
174 Number,
175 Decimal,
176 Phone,
177 Email,
178 Url,
179}
180
181pub trait TextInputService {
183 fn show_keyboard(&mut self, kind: KeyboardKind);
184 fn hide_keyboard(&mut self);
185 fn set_ime_rect(&mut self, rect: RectF);
187}
188
189#[derive(Clone, Debug, PartialEq)]
191pub struct LocaleInfo {
192 pub decimal_separator: char,
193 pub thousand_separator: char,
194 pub short_date_format: String,
195 pub long_time_format: String,
196 pub currency_symbol: String,
197 pub month_names: [&'static str; 12],
200 pub short_day_names: [&'static str; 7],
201 pub first_day_of_week: u8,
203}
204
205const MONTHS_EN: [&str; 12] = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
206const DAYS_EN: [&str; 7] = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
207
208impl Default for LocaleInfo {
209 fn default() -> Self {
210 Self {
211 decimal_separator: '.',
212 thousand_separator: ',',
213 short_date_format: "yyyy-mm-dd".into(),
214 long_time_format: "hh:nn:ss".into(),
215 currency_symbol: "$".into(),
216 month_names: MONTHS_EN,
217 short_day_names: DAYS_EN,
218 first_day_of_week: 0,
219 }
220 }
221}
222
223impl LocaleInfo {
224 pub fn pt_br() -> Self {
226 Self {
227 decimal_separator: ',',
228 thousand_separator: '.',
229 short_date_format: "dd/mm/yyyy".into(),
230 long_time_format: "hh:nn:ss".into(),
231 currency_symbol: "R$".into(),
232 month_names: ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"],
233 short_day_names: ["dom", "seg", "ter", "qua", "qui", "sex", "sáb"],
234 first_day_of_week: 0,
235 }
236 }
237
238 pub fn es() -> Self {
240 Self {
241 decimal_separator: ',',
242 thousand_separator: '.',
243 short_date_format: "dd/mm/yyyy".into(),
244 long_time_format: "hh:nn:ss".into(),
245 currency_symbol: "€".into(),
246 month_names: ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"],
247 short_day_names: ["dom", "lun", "mar", "mié", "jue", "vie", "sáb"],
248 first_day_of_week: 1,
249 }
250 }
251
252 pub fn en_us() -> Self {
254 Self {
255 decimal_separator: '.',
256 thousand_separator: ',',
257 short_date_format: "mm/dd/yyyy".into(),
258 long_time_format: "hh:nn:ss".into(),
259 currency_symbol: "$".into(),
260 month_names: MONTHS_EN,
261 short_day_names: DAYS_EN,
262 first_day_of_week: 0,
263 }
264 }
265}
266
267pub trait LocaleService {
268 fn locale(&self) -> LocaleInfo;
269}
270
271impl LocaleService for LocaleInfo {
273 fn locale(&self) -> LocaleInfo {
274 self.clone()
275 }
276}
277
278#[derive(Clone, Copy, Debug, PartialEq, Eq)]
280pub enum LifecycleEvent {
281 Resumed,
282 Suspended,
283 LowMemory,
284 SurfaceLost,
286}
287
288pub trait ResourceService {
292 fn read(&self, path: &str) -> Option<Vec<u8>>;
293}
294
295pub trait FormFactory {
298 fn create_form(&mut self, ui: &mut crate::Ui, name: &str) -> Result<crate::ComponentId, String>;
300 fn form_names(&self) -> Vec<String>;
302}
303
304#[derive(Clone, Debug, Default)]
306pub struct FileDialogOptions {
307 pub title: String,
308 pub filters: Vec<(String, Vec<String>)>,
310 pub directory: String,
311 pub file_name: String,
312 pub save: bool,
314 pub multiple: bool,
316 pub folder: bool,
319 pub owner: Option<crate::ComponentId>,
321}
322
323pub trait FileDialogService {
326 fn show(&mut self, options: FileDialogOptions, done: Box<dyn FnOnce(Vec<String>) + Send>);
327}
328
329#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
332pub enum Permission {
333 Camera,
334 Microphone,
335 Location,
337 Notifications,
338 Photos,
340 Contacts,
341 Calendar,
342 Bluetooth,
343}
344
345impl Permission {
346 pub const ALL: [Permission; 8] = [
347 Permission::Camera,
348 Permission::Microphone,
349 Permission::Location,
350 Permission::Notifications,
351 Permission::Photos,
352 Permission::Contacts,
353 Permission::Calendar,
354 Permission::Bluetooth,
355 ];
356
357 pub fn name(self) -> &'static str {
359 match self {
360 Permission::Camera => "camera",
361 Permission::Microphone => "microphone",
362 Permission::Location => "location",
363 Permission::Notifications => "notifications",
364 Permission::Photos => "photos",
365 Permission::Contacts => "contacts",
366 Permission::Calendar => "calendar",
367 Permission::Bluetooth => "bluetooth",
368 }
369 }
370
371 pub fn parse(name: &str) -> Option<Permission> {
372 let name = name.trim();
373 Permission::ALL.into_iter().find(|p| p.name().eq_ignore_ascii_case(name))
374 }
375
376 pub fn parse_list(list: &str) -> Vec<Permission> {
378 let mut out = Vec::new();
379 for p in list.split([';', ',']).filter_map(Permission::parse) {
380 if !out.contains(&p) {
381 out.push(p);
382 }
383 }
384 out
385 }
386}
387
388#[derive(Clone, Copy, Debug, PartialEq, Eq)]
390pub enum PermissionState {
391 Granted,
393 Denied,
395 Prompt,
397 Unavailable,
399}
400
401impl PermissionState {
402 pub fn name(self) -> &'static str {
403 match self {
404 PermissionState::Granted => "granted",
405 PermissionState::Denied => "denied",
406 PermissionState::Prompt => "prompt",
407 PermissionState::Unavailable => "unavailable",
408 }
409 }
410}
411
412impl crate::prop::PropEnum for Permission {
416 const NAMES: &'static [&'static str] = &["camera", "microphone", "location", "notifications", "photos", "contacts", "calendar", "bluetooth"];
417 fn from_index(index: usize) -> Option<Self> {
418 Permission::ALL.get(index).copied()
419 }
420 fn index(self) -> usize {
421 Permission::ALL.iter().position(|p| *p == self).unwrap_or(0)
422 }
423}
424
425impl crate::prop::PropEnum for PermissionState {
426 const NAMES: &'static [&'static str] = &["granted", "denied", "prompt", "unavailable"];
427 fn from_index(index: usize) -> Option<Self> {
428 [PermissionState::Granted, PermissionState::Denied, PermissionState::Prompt, PermissionState::Unavailable].get(index).copied()
429 }
430 fn index(self) -> usize {
431 self as usize
432 }
433}
434
435impl crate::prop::PropEnum for Biometry {
436 const NAMES: &'static [&'static str] = &["none", "fingerprint", "face", "iris", "any"];
437 fn from_index(index: usize) -> Option<Self> {
438 [Biometry::None, Biometry::Fingerprint, Biometry::Face, Biometry::Iris, Biometry::Any].get(index).copied()
439 }
440 fn index(self) -> usize {
441 self as usize
442 }
443}
444
445pub trait PermissionService {
446 fn state(&self, permission: Permission) -> PermissionState;
447 fn request(&mut self, permissions: Vec<Permission>, done: Box<dyn FnOnce(Vec<(Permission, PermissionState)>) + Send>);
448}
449
450#[derive(Clone, Copy, Debug, PartialEq, Eq)]
452pub enum Biometry {
453 None,
455 Fingerprint,
456 Face,
457 Iris,
458 Any,
460}
461
462impl Biometry {
463 pub fn name(self) -> &'static str {
464 match self {
465 Biometry::None => "none",
466 Biometry::Fingerprint => "fingerprint",
467 Biometry::Face => "face",
468 Biometry::Iris => "iris",
469 Biometry::Any => "any",
470 }
471 }
472}
473
474#[derive(Clone, Debug, PartialEq, Eq)]
476pub enum BiometricResult {
477 Success,
478 Cancelled,
480 Failed(String),
482}
483
484pub trait BiometricService {
487 fn availability(&self) -> Biometry;
488 fn authenticate(&mut self, reason: &str, allow_device_credential: bool, done: Box<dyn FnOnce(BiometricResult) + Send>);
491}
492
493pub trait PrintService {
497 fn print(&mut self, title: &str, pages: crate::pages::PageSet, done: Box<dyn FnOnce(Result<bool, String>) + Send>);
498
499 fn wants_pdf(&self) -> bool {
502 false
503 }
504
505 fn print_pdf(&mut self, title: &str, pdf: Vec<u8>, done: Box<dyn FnOnce(Result<bool, String>) + Send>) {
507 let _ = (title, pdf);
508 done(Err("esta plataforma não imprime PDF".into()));
509 }
510}
511
512pub trait HttpService {
516 fn get(&mut self, url: &str, done: Box<dyn FnOnce(Result<Vec<u8>, String>) + Send>);
517}
518
519#[derive(Clone, Debug, Default, PartialEq)]
521pub struct SystemNotification {
522 pub app_id: String,
524 pub app_name: String,
526 pub title: String,
527 pub body: String,
528 pub image: String,
530 pub image_png: Vec<u8>,
532 pub big_image: bool,
534 pub id: u32,
536 pub channel: String,
538 pub channel_name: String,
539 pub priority: NotificationPriority,
540 pub actions: Vec<(String, String)>,
542 pub ongoing: bool,
544 pub progress: Option<f32>,
546 pub full_screen: bool,
549 pub component: Option<crate::ComponentId>,
551}
552
553#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
555pub enum NotificationPriority {
556 Low,
558 #[default]
559 Default,
560 High,
562}
563
564impl crate::PropEnum for NotificationPriority {
565 const NAMES: &'static [&'static str] = &["low", "default", "high"];
566 fn from_index(index: usize) -> Option<Self> {
567 [Self::Low, Self::Default, Self::High].get(index).copied()
568 }
569 fn index(self) -> usize {
570 self as usize
571 }
572}
573
574pub trait NotificationService {
576 fn notify(&mut self, notification: &SystemNotification) -> Result<(), String>;
577 fn cancel(&mut self, id: u32) -> Result<(), String> {
579 let _ = id;
580 Ok(())
581 }
582}
583
584pub trait LinkService {
587 fn open_url(&mut self, url: &str) -> Result<(), String>;
589 fn open_app(&mut self, app: &str) -> Result<(), String> {
591 Err(format!("abrir outro app não existe aqui ({app})"))
592 }
593 fn share(&mut self, text: &str, files: &[String]) -> Result<(), String> {
595 let _ = (text, files);
596 Err("compartilhar não existe aqui".into())
597 }
598 fn request(&mut self, action: &str, data: &str, done: Box<dyn FnOnce(Result<String, String>) + Send>) {
601 let _ = data;
602 done(Err(format!("pedir a outro app não existe aqui ({action})")));
603 }
604 fn can_register_schemes(&self) -> bool {
607 false
608 }
609 fn register_scheme(&mut self, scheme: &str, description: &str) -> Result<(), String> {
613 let _ = description;
614 Err(format!("registrar o prefixo {scheme}:// em execução não existe aqui (vai na publicação)"))
615 }
616 fn unregister_scheme(&mut self, scheme: &str) -> Result<(), String> {
618 Err(format!("tirar o registro do prefixo {scheme}:// não existe aqui"))
619 }
620 fn scheme_registered(&mut self, scheme: &str) -> bool {
622 let _ = scheme;
623 false
624 }
625 fn receive_links(&mut self, on_link: Box<dyn Fn(String) + Send>) {
628 let _ = on_link;
629 }
630}
631
632const RESERVED_SCHEMES: &[&str] = &[
634 "http", "https", "file", "ftp", "ftps", "mailto", "tel", "sms", "data", "javascript", "vbscript", "about", "blob", "ws", "wss", "shell", "search",
635 "search-ms", "res", "its", "mk", "hcp", "callto", "news", "nntp", "telnet", "ldap", "ssh", "sftp", "smb", "git", "magnet", "steam", "zoommtg",
636];
637
638pub fn check_scheme(scheme: &str) -> Result<String, String> {
642 let s = scheme.trim().trim_end_matches("://").trim_end_matches(':').to_ascii_lowercase();
643 let valid = s.len() >= 3
644 && s.len() <= 64
645 && s.starts_with(|c: char| c.is_ascii_lowercase())
646 && s.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '+' | '-' | '.'));
647 if !valid {
648 return Err(crate::messages::tf("prefixo inválido: {0} (letras, números, + - ., de 3 a 64)", &[&scheme]));
649 }
650 if RESERVED_SCHEMES.contains(&s.as_str()) || s.starts_with("ms-") || s.starts_with("microsoft") || s.starts_with("windows") {
651 return Err(crate::messages::tf("o prefixo {0} é do sistema", &[&s]));
652 }
653 Ok(s)
654}
655
656static STARTUP_LINKS: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
659
660pub fn push_startup_link(url: String) {
662 if let Ok(mut list) = STARTUP_LINKS.lock() {
663 list.push(url);
664 }
665}
666
667pub fn take_startup_links(scheme: &str) -> Vec<String> {
669 let Ok(mut list) = STARTUP_LINKS.lock() else { return Vec::new() };
670 let (mine, rest): (Vec<String>, Vec<String>) = std::mem::take(&mut *list).into_iter().partition(|url| link_scheme(url).as_deref() == Some(scheme));
671 *list = rest;
672 mine
673}
674
675pub fn link_scheme(url: &str) -> Option<String> {
677 let (scheme, _) = url.split_once(':')?;
678 (!scheme.is_empty()).then(|| scheme.to_ascii_lowercase())
679}
680
681#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
683pub enum Sensor {
684 Location,
686 Battery,
688 Network,
690 Motion,
692 Compass,
694 Proximity,
696 Light,
698}
699
700pub trait SensorService {
703 fn available(&self, sensor: Sensor) -> bool;
705 fn set_active(&mut self, sensor: Sensor, on: bool);
707 fn read(&mut self, sensor: Sensor) -> Option<Vec<f64>>;
709 fn vibrate(&mut self, ms: u32) -> bool {
711 let _ = ms;
712 false
713 }
714}
715
716pub const GAMEPAD_BUTTONS: [&str; 17] =
720 ["a", "b", "x", "y", "lb", "rb", "lt", "rt", "back", "start", "l3", "r3", "up", "down", "left", "right", "guide"];
721
722#[derive(Clone, Debug, Default, PartialEq)]
724pub struct GamepadState {
725 pub name: String,
726 pub buttons: u32,
728 pub axes: [f32; 6],
731}
732
733impl GamepadState {
734 pub fn set_button(&mut self, name: &str, down: bool) {
736 if let Some(i) = GAMEPAD_BUTTONS.iter().position(|b| *b == name) {
737 if down {
738 self.buttons |= 1 << i;
739 } else {
740 self.buttons &= !(1 << i);
741 }
742 }
743 }
744
745 pub fn pressed(&self, name: &str) -> bool {
746 GAMEPAD_BUTTONS.iter().position(|b| *b == name).is_some_and(|i| self.buttons & (1 << i) != 0)
747 }
748}
749
750pub trait GamepadService {
752 fn pads(&mut self) -> Vec<GamepadState>;
754 fn rumble(&mut self, index: usize, strength: f32, ms: u32) -> bool {
756 let _ = (index, strength, ms);
757 false
758 }
759}
760
761pub trait PhoneService {
763 fn dial(&mut self, number: &str) -> Result<(), String>;
765 fn call(&mut self, number: &str) -> Result<(), String>;
767 fn watch(&mut self, on: bool);
769 fn state(&mut self) -> (String, String);
772 fn request_dialer(&mut self) -> Result<(), String> {
774 Err("não existe aqui".into())
775 }
776 fn answer(&mut self) -> bool {
778 false
779 }
780 fn reject(&mut self) -> bool {
781 false
782 }
783 fn hang_up(&mut self) -> bool {
784 false
785 }
786 fn history(&mut self, max: u32) -> Result<String, String> {
788 let _ = max;
789 Err("não existe aqui".into())
790 }
791 fn lock_screen(&mut self, show_when_locked: bool, turn_screen_on: bool);
793 fn dismiss_keyguard(&mut self);
795}
796
797pub trait BackgroundHost {
802 fn start(&mut self, title: &str, text: &str, kind: &str, keep_alive: bool) -> Result<(), String>;
803 fn stop(&mut self);
804}
805
806#[derive(Clone, Debug, PartialEq, Eq)]
809pub enum Incoming {
810 Link(String),
811 Shared(String),
812}
813
814static INCOMING: std::sync::Mutex<Vec<Incoming>> = std::sync::Mutex::new(Vec::new());
815
816pub fn push_incoming(item: Incoming) {
819 if let Ok(mut list) = INCOMING.lock() {
820 list.push(item);
821 }
822}
823
824pub fn take_incoming() -> Vec<Incoming> {
826 INCOMING.lock().map(|mut list| std::mem::take(&mut *list)).unwrap_or_default()
827}
828
829pub trait OffscreenService {
832 fn render_png(&self, width: u32, height: u32, scale: f32, background: crate::Color, paint: &mut dyn FnMut(&mut dyn crate::Canvas)) -> Option<Vec<u8>>;
834
835 fn render_rgba(&self, _width: u32, _height: u32, _scale: f32, _background: crate::Color, _paint: &mut dyn FnMut(&mut dyn crate::Canvas)) -> Option<Vec<u8>> {
840 None
841 }
842
843 fn render_area_rgba(
848 &self,
849 _width: u32,
850 _height: u32,
851 _background: crate::Color,
852 _over: Option<(&[u8], crate::geometry::RectF)>,
853 _paint: &mut dyn FnMut(&mut dyn crate::Canvas),
854 ) -> Option<Vec<u8>> {
855 None
856 }
857}
858
859pub trait WindowCaptureService {
862 fn capture(&mut self, form: crate::ComponentId) -> Option<(u32, u32, Vec<u8>)>;
864}
865
866#[derive(Default)]
868pub struct Services {
869 pub window_capture: Option<Box<dyn WindowCaptureService>>,
871 pub offscreen: Option<Box<dyn OffscreenService>>,
872 pub window: Option<Box<dyn WindowService>>,
873 pub timer: Option<Box<dyn TimerService>>,
874 pub clipboard: Option<Box<dyn ClipboardService>>,
875 pub clipboard_local: crate::clipboard::LocalClipboard,
877 pub cursor: Option<Box<dyn CursorService>>,
878 pub screen: Option<Box<dyn ScreenService>>,
879 pub text_input: Option<Box<dyn TextInputService>>,
880 pub locale: Option<Box<dyn LocaleService>>,
881 pub text: Option<Box<dyn TextService>>,
882 pub resources: Option<Box<dyn ResourceService>>,
883 pub forms: Option<Box<dyn FormFactory>>,
884 pub file_dialogs: Option<Box<dyn FileDialogService>>,
885 pub permissions: Option<Box<dyn PermissionService>>,
887 pub biometrics: Option<Box<dyn BiometricService>>,
889 pub http: Option<Box<dyn HttpService>>,
890 pub notifications: Option<Box<dyn NotificationService>>,
891 pub links: Option<Box<dyn LinkService>>,
893 pub sensors: Option<Box<dyn SensorService>>,
895 pub background: Option<Box<dyn BackgroundHost>>,
898 pub phone: Option<Box<dyn PhoneService>>,
900 pub gamepads: Option<Box<dyn GamepadService>>,
902 pub printer: Option<Box<dyn PrintService>>,
903 pub pdf: Option<Box<dyn crate::providers::PdfProvider>>,
906 pub text_assist: Option<Box<dyn crate::textassist::TextAssist>>,
909 pub nfc: Option<Box<dyn NfcService>>,
911 pub bluetooth: Option<Box<dyn BluetoothService>>,
913 pub push: Option<Box<dyn PushService>>,
915 pub media_session: Option<Box<dyn MediaSessionService>>,
918 pub actions: Option<Box<dyn ActionService>>,
922 pub ole: Option<Box<dyn OleService>>,
924 pub wmi: Option<Box<dyn WmiService>>,
926}
927
928#[derive(Clone, Debug, Default, PartialEq, Eq)]
930pub struct NfcTag {
931 pub id: String,
933 pub tech: String,
935 pub records: Vec<crate::ndef::NdefRecord>,
937 pub writable: bool,
939}
940
941#[derive(Clone, Debug, PartialEq, Eq)]
943pub enum NfcEvent {
944 Tag(NfcTag),
945 Written,
947 Error(String),
948}
949
950pub trait NfcService {
953 fn available(&self) -> bool;
955 fn enabled(&self) -> bool {
957 self.available()
958 }
959 fn set_reading(&mut self, on: bool);
961 fn write(&mut self, message: Vec<u8>);
964 fn cancel_write(&mut self) {}
966 fn poll(&mut self) -> Vec<NfcEvent>;
968}
969
970#[derive(Clone, Debug, Default, PartialEq, Eq)]
972pub struct BleDevice {
973 pub id: String,
976 pub name: String,
977 pub rssi: i32,
979}
980
981#[derive(Clone, Debug, Default, PartialEq, Eq)]
983pub struct BleCharacteristic {
984 pub service: String,
985 pub characteristic: String,
986 pub properties: Vec<String>,
988}
989
990#[derive(Clone, Debug, PartialEq, Eq)]
992pub enum BluetoothEvent {
993 Found(BleDevice),
994 ScanStopped,
996 Connected { device: String, services: Vec<BleCharacteristic> },
998 Disconnected(String),
999 Value { device: String, characteristic: String, data: Vec<u8> },
1001 Written { device: String, characteristic: String },
1002 Received { device: String, data: Vec<u8> },
1004 Error(String),
1005}
1006
1007pub trait BluetoothService {
1011 fn available(&self) -> bool;
1012 fn enabled(&self) -> bool {
1014 self.available()
1015 }
1016 fn scan(&mut self, on: bool, services: Vec<String>, name: String);
1019 fn connect(&mut self, device: &str);
1020 fn disconnect(&mut self, device: &str);
1021 fn read(&mut self, device: &str, service: &str, characteristic: &str);
1022 fn write(&mut self, device: &str, service: &str, characteristic: &str, data: Vec<u8>, with_response: bool);
1023 fn subscribe(&mut self, device: &str, service: &str, characteristic: &str, on: bool);
1025 fn paired(&mut self) -> Vec<(String, String)> {
1027 Vec::new()
1028 }
1029 fn open_serial(&mut self, device: &str) -> Result<(), String> {
1031 let _ = device;
1032 Err(crate::messages::t("o Bluetooth clássico não está disponível aqui"))
1033 }
1034 fn send_serial(&mut self, device: &str, data: Vec<u8>) -> Result<(), String> {
1035 let _ = (device, data);
1036 Err(crate::messages::t("o Bluetooth clássico não está disponível aqui"))
1037 }
1038 fn close_serial(&mut self, device: &str) {
1039 let _ = device;
1040 }
1041 fn poll(&mut self) -> Vec<BluetoothEvent>;
1043}
1044
1045pub fn ble_uuid(text: &str) -> String {
1048 let t = text.trim().trim_start_matches("0x").trim_start_matches("0X").to_ascii_lowercase();
1049 if (t.len() == 4 || t.len() == 8) && t.chars().all(|c| c.is_ascii_hexdigit()) {
1050 format!("{t:0>8}-0000-1000-8000-00805f9b34fb")
1051 } else {
1052 t
1053 }
1054}
1055
1056#[derive(Clone, Debug, Default, PartialEq, Eq)]
1058pub struct PushMessage {
1059 pub id: String,
1061 pub title: String,
1063 pub body: String,
1064 pub data: String,
1066}
1067
1068#[derive(Clone, Debug, PartialEq, Eq)]
1070pub enum PushEvent {
1071 Token(String),
1075 Message(PushMessage),
1077 Opened(PushMessage),
1079 Error(String),
1080}
1081
1082#[derive(Clone, Debug, Default, PartialEq, Eq)]
1085pub struct PushConfig {
1086 pub sender_id: String,
1088 pub project_id: String,
1090 pub app_id: String,
1092 pub api_key: String,
1094 pub vapid_key: String,
1096 pub show_in_foreground: bool,
1099}
1100
1101pub trait PushService {
1105 fn available(&self) -> bool;
1108 fn provider(&self) -> &'static str;
1111 fn register(&mut self, config: &PushConfig);
1114 fn unregister(&mut self) {}
1116 fn shows_notifications(&self) -> bool {
1120 true
1121 }
1122 fn poll(&mut self) -> Vec<PushEvent> {
1124 Vec::new()
1125 }
1126}
1127
1128#[derive(Clone, Debug, Default, PartialEq)]
1131pub struct NowPlaying {
1132 pub title: String,
1133 pub artist: String,
1134 pub album: String,
1135 pub duration: f64,
1137 pub position: f64,
1139 pub playing: bool,
1140 pub cover: Option<Vec<u8>>,
1142 pub can_next: bool,
1144 pub can_previous: bool,
1145}
1146
1147#[derive(Clone, Copy, Debug, PartialEq)]
1149pub enum MediaCommand {
1150 Play,
1151 Pause,
1152 Toggle,
1154 Stop,
1155 Next,
1156 Previous,
1157 Seek(f64),
1159}
1160
1161impl MediaCommand {
1162 pub fn name(self) -> &'static str {
1164 match self {
1165 MediaCommand::Play => "play",
1166 MediaCommand::Pause => "pause",
1167 MediaCommand::Toggle => "toggle",
1168 MediaCommand::Stop => "stop",
1169 MediaCommand::Next => "next",
1170 MediaCommand::Previous => "previous",
1171 MediaCommand::Seek(_) => "seek",
1172 }
1173 }
1174}
1175
1176pub type MediaCommandSink = std::sync::Arc<dyn Fn(MediaCommand) + Send + Sync>;
1178
1179pub trait MediaSessionService {
1182 fn start(&mut self, owner: Option<crate::ComponentId>, commands: MediaCommandSink) -> Result<(), String>;
1185 fn update(&mut self, now: &NowPlaying);
1187 fn stop(&mut self);
1189}
1190
1191static PUSH_EVENTS: std::sync::Mutex<Vec<PushEvent>> = std::sync::Mutex::new(Vec::new());
1192
1193pub fn push_event(event: PushEvent) {
1196 if let Ok(mut list) = PUSH_EVENTS.lock() {
1197 list.push(event);
1198 }
1199}
1200
1201pub fn take_push_events() -> Vec<PushEvent> {
1203 PUSH_EVENTS.lock().map(|mut list| std::mem::take(&mut *list)).unwrap_or_default()
1204}
1205
1206pub fn parse_push_line(line: &str) -> Option<PushEvent> {
1210 let mut f = line.split('\t');
1211 let kind = f.next()?;
1212 let mut next = || f.next().unwrap_or_default().to_string();
1213 match kind {
1214 "token" => Some(PushEvent::Token(next())),
1215 "error" => Some(PushEvent::Error(next())),
1216 "message" | "opened" => {
1217 let mut m = PushMessage { id: next(), title: next(), body: next(), data: next() };
1218 if m.data.trim().is_empty() {
1219 m.data = "{}".into();
1220 }
1221 Some(if kind == "message" { PushEvent::Message(m) } else { PushEvent::Opened(m) })
1222 }
1223 _ => None,
1224 }
1225}
1226
1227pub fn json_field(json: &str, key: &str) -> Option<String> {
1230 let chars: Vec<char> = json.chars().collect();
1231 let mut i = 0;
1232 let skip_ws = |i: &mut usize| {
1233 while *i < chars.len() && chars[*i].is_whitespace() {
1234 *i += 1;
1235 }
1236 };
1237 let read_string = |i: &mut usize| -> Option<String> {
1239 if chars.get(*i) != Some(&'"') {
1240 return None;
1241 }
1242 *i += 1;
1243 let mut out = String::new();
1244 while *i < chars.len() {
1245 let c = chars[*i];
1246 *i += 1;
1247 match c {
1248 '"' => return Some(out),
1249 '\\' => {
1250 let e = *chars.get(*i)?;
1251 *i += 1;
1252 match e {
1253 'n' => out.push('\n'),
1254 't' => out.push('\t'),
1255 'r' => out.push('\r'),
1256 'b' => out.push('\u{8}'),
1257 'f' => out.push('\u{c}'),
1258 'u' => {
1259 let hex: String = chars.get(*i..*i + 4)?.iter().collect();
1260 *i += 4;
1261 let mut code = u32::from_str_radix(&hex, 16).ok()?;
1262 if (0xD800..0xDC00).contains(&code) && chars.get(*i) == Some(&'\\') && chars.get(*i + 1) == Some(&'u') {
1264 let low: String = chars.get(*i + 2..*i + 6)?.iter().collect();
1265 if let Ok(low) = u32::from_str_radix(&low, 16) {
1266 *i += 6;
1267 code = 0x10000 + ((code - 0xD800) << 10) + (low.wrapping_sub(0xDC00) & 0x3FF);
1268 }
1269 }
1270 out.push(char::from_u32(code).unwrap_or('\u{FFFD}'));
1271 }
1272 other => out.push(other),
1273 }
1274 }
1275 c => out.push(c),
1276 }
1277 }
1278 None
1279 };
1280 skip_ws(&mut i);
1281 if chars.get(i) != Some(&'{') {
1282 return None;
1283 }
1284 i += 1;
1285 loop {
1286 skip_ws(&mut i);
1287 if chars.get(i) == Some(&'}') || i >= chars.len() {
1288 return None;
1289 }
1290 let name = read_string(&mut i)?;
1291 skip_ws(&mut i);
1292 if chars.get(i) != Some(&':') {
1293 return None;
1294 }
1295 i += 1;
1296 skip_ws(&mut i);
1297 let value = if chars.get(i) == Some(&'"') {
1298 read_string(&mut i)?
1299 } else {
1300 let start = i;
1302 let (mut depth, mut quoted) = (0i32, false);
1303 while i < chars.len() {
1304 let c = chars[i];
1305 if quoted {
1306 if c == '\\' {
1307 i += 1;
1308 } else if c == '"' {
1309 quoted = false;
1310 }
1311 } else {
1312 match c {
1313 '"' => quoted = true,
1314 '{' | '[' => depth += 1,
1315 '}' | ']' if depth == 0 => break,
1316 '}' | ']' => depth -= 1,
1317 ',' if depth == 0 => break,
1318 _ => {}
1319 }
1320 }
1321 i += 1;
1322 }
1323 chars[start..i.min(chars.len())].iter().collect::<String>().trim().to_string()
1324 };
1325 if name == key {
1326 return Some(value);
1327 }
1328 skip_ws(&mut i);
1329 if chars.get(i) == Some(&',') {
1330 i += 1;
1331 }
1332 }
1333}
1334
1335pub fn push_message_from_payload(text: &str) -> PushMessage {
1339 let text = text.trim();
1340 if !text.starts_with('{') {
1341 return PushMessage { body: text.to_string(), data: "{}".into(), ..Default::default() };
1342 }
1343 let notification = json_field(text, "notification").unwrap_or_default();
1344 let pick = |key: &str| json_field(text, key).or_else(|| json_field(¬ification, key)).unwrap_or_default();
1345 let data = json_field(text, "data").filter(|d| d.trim_start().starts_with('{')).unwrap_or_else(|| "{}".into());
1346 PushMessage { id: pick("id"), title: pick("title"), body: pick("body"), data }
1347}
1348
1349pub fn render_template(template: &str, data: &str) -> String {
1352 let mut out = String::new();
1353 let mut rest = template;
1354 while let Some(i) = rest.find(['{', '}']) {
1355 out.push_str(&rest[..i]);
1356 let tail = &rest[i..];
1357 if tail.starts_with("{{") || tail.starts_with("}}") {
1358 out.push_str(&tail[..1]);
1359 rest = &tail[2..];
1360 } else if let (true, Some(end)) = (tail.starts_with('{'), tail.find('}')) {
1361 out.push_str(&json_field(data, tail[1..end].trim()).unwrap_or_default());
1362 rest = &tail[end + 1..];
1363 } else {
1364 out.push_str(&tail[..1]);
1365 rest = &tail[1..];
1366 }
1367 }
1368 out.push_str(rest);
1369 out
1370}
1371
1372pub fn data_matches(filter: &str, data: &str) -> bool {
1375 filter.split(';').map(str::trim).filter(|c| !c.is_empty()).all(|c| {
1376 if let Some((k, v)) = c.split_once("!=") {
1377 json_field(data, k.trim()).unwrap_or_default() != v.trim()
1378 } else if let Some((k, v)) = c.split_once('=') {
1379 json_field(data, k.trim()).unwrap_or_default() == v.trim()
1380 } else {
1381 json_field(data, c).is_some_and(|v| !v.is_empty())
1382 }
1383 })
1384}
1385
1386pub fn json_quote(text: &str) -> String {
1388 let mut out = String::with_capacity(text.len() + 2);
1389 out.push('"');
1390 for c in text.chars() {
1391 match c {
1392 '"' => out.push_str("\\\""),
1393 '\\' => out.push_str("\\\\"),
1394 '\n' => out.push_str("\\n"),
1395 '\r' => out.push_str("\\r"),
1396 '\t' => out.push_str("\\t"),
1397 c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
1398 c => out.push(c),
1399 }
1400 }
1401 out.push('"');
1402 out
1403}
1404
1405#[derive(Clone, Debug, PartialEq, Eq)]
1407pub struct ActionEvent {
1408 pub kind: String,
1412 pub component: String,
1414 pub detail: String,
1416 pub data: String,
1418}
1419
1420pub fn parse_action_line(line: &str) -> Option<ActionEvent> {
1422 let mut f = line.split('\t');
1423 let kind = f.next().filter(|k| !k.is_empty())?.to_string();
1424 let component = f.next()?.to_string();
1425 let detail = f.next().unwrap_or_default().to_string();
1426 let data = f.next().filter(|d| !d.trim().is_empty()).unwrap_or("{}").to_string();
1427 Some(ActionEvent { kind, component, detail, data })
1428}
1429
1430pub trait ActionService {
1434 fn execute(&mut self, spec: &str, data: &str) -> Result<(), String>;
1435 fn stop(&mut self, component: &str);
1437 fn set_push_rules(&mut self, rules: &str);
1440 fn poll(&mut self) -> Vec<ActionEvent>;
1442}
1443
1444#[derive(Clone, Debug, PartialEq)]
1446pub enum OleValue {
1447 Null,
1448 Bool(bool),
1449 Int(i64),
1450 Float(f64),
1451 String(String),
1452 Date(f64),
1455 Object(u64),
1458 Array(Vec<Vec<OleValue>>),
1461}
1462
1463pub trait OleService {
1470 fn create(&mut self, prog_id: &str, running: bool) -> Result<u64, String>;
1473 fn invoke(&mut self, object: u64, name: &str, args: Vec<OleValue>) -> Result<OleValue, String>;
1475 fn put(&mut self, object: u64, name: &str, args: Vec<OleValue>, value: OleValue) -> Result<(), String>;
1477 fn release(&mut self, object: u64);
1479 fn set_timeout(&mut self, seconds: f64) {
1481 let _ = seconds;
1482 }
1483 fn releaser(&self) -> Option<OleReleaser> {
1485 None
1486 }
1487}
1488
1489pub type OleReleaser = std::sync::Arc<dyn Fn(u64) + Send + Sync>;
1491
1492static OLE_ALLOWED: std::sync::RwLock<Vec<String>> = std::sync::RwLock::new(Vec::new());
1496
1497pub const OLE_DEFAULT: &[&str] = &["Excel.Application", "Word.Application", "Outlook.Application", "PowerPoint.Application"];
1499
1500pub fn allow_ole(prog_id: &str) {
1502 if let Ok(mut list) = OLE_ALLOWED.write() {
1503 if !list.iter().any(|p| p.eq_ignore_ascii_case(prog_id)) {
1504 list.push(prog_id.to_string());
1505 }
1506 }
1507}
1508
1509pub fn ole_allowed(prog_id: &str) -> bool {
1512 let id = prog_id.trim();
1513 let base = match id.rsplit_once('.') {
1514 Some((head, tail)) if !tail.is_empty() && tail.chars().all(|c| c.is_ascii_digit()) => head,
1515 _ => id,
1516 };
1517 let ok = |p: &str| p.eq_ignore_ascii_case(base) || p.eq_ignore_ascii_case(id);
1518 OLE_DEFAULT.iter().any(|p| ok(p)) || OLE_ALLOWED.read().is_ok_and(|l| l.iter().any(|p| ok(p)))
1519}
1520
1521pub fn ole_date(year: i32, month: u32, day: u32, hour: u32, minute: u32, second: u32) -> f64 {
1523 let y = i64::from(year) - i64::from(month <= 2);
1525 let era = y.div_euclid(400);
1526 let yoe = y - era * 400;
1527 let m = i64::from(month);
1528 let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + i64::from(day) - 1;
1529 let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
1530 let days = era * 146_097 + doe - 719_468 + 25_569;
1531 days as f64 + f64::from(hour * 3600 + minute * 60 + second) / 86_400.0
1532}
1533
1534pub fn ole_date_parts(date: f64) -> (i32, u32, u32, u32, u32, u32) {
1536 let mut days = date.floor() as i64;
1537 let mut secs = ((date - date.floor()) * 86_400.0).round() as i64;
1538 if secs >= 86_400 {
1539 days += 1;
1540 secs -= 86_400;
1541 }
1542 let z = days - 25_569 + 719_468;
1543 let era = z.div_euclid(146_097);
1544 let doe = z - era * 146_097;
1545 let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
1546 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
1547 let mp = (5 * doy + 2) / 153;
1548 let day = (doy - (153 * mp + 2) / 5 + 1) as u32;
1549 let month = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
1550 let year = (yoe + era * 400 + i64::from(month <= 2)) as i32;
1551 (year, month, day, (secs / 3600) as u32, (secs % 3600 / 60) as u32, (secs % 60) as u32)
1552}
1553
1554#[derive(Clone, Debug, PartialEq)]
1556pub enum WmiValue {
1557 Null,
1558 Bool(bool),
1559 Int(i64),
1560 Float(f64),
1561 String(String),
1562 DateTime(String),
1564 Array(Vec<WmiValue>),
1566 Object(Vec<(String, WmiValue)>),
1568}
1569
1570#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
1572pub enum WmiType {
1573 #[default]
1574 String,
1575 Integer,
1576 Float,
1577 Boolean,
1578 DateTime,
1579 Array,
1580 Object,
1581}
1582
1583#[derive(Clone, Debug, Default, PartialEq, Eq)]
1585pub struct WmiColumn {
1586 pub name: String,
1587 pub kind: WmiType,
1588}
1589
1590#[derive(Clone, Debug, Default, PartialEq)]
1593pub struct WmiTable {
1594 pub columns: Vec<WmiColumn>,
1595 pub rows: Vec<Vec<WmiValue>>,
1596}
1597
1598pub type WmiDone = Box<dyn FnOnce(Result<WmiTable, String>) + Send>;
1601
1602pub type WmiListener = std::sync::Arc<dyn Fn(Result<Vec<(String, WmiValue)>, String>) + Send + Sync>;
1605
1606pub struct WmiWatch(Option<Box<dyn FnOnce() + Send>>);
1608
1609impl WmiWatch {
1610 pub fn new(stop: impl FnOnce() + Send + 'static) -> Self {
1612 Self(Some(Box::new(stop)))
1613 }
1614}
1615
1616impl Drop for WmiWatch {
1617 fn drop(&mut self) {
1618 if let Some(stop) = self.0.take() {
1619 stop();
1620 }
1621 }
1622}
1623
1624pub trait WmiService {
1629 fn query(&mut self, namespace: &str, wql: &str, done: WmiDone);
1631 fn watch(&mut self, namespace: &str, wql: &str, listener: WmiListener) -> Result<WmiWatch, String>;
1635}
1636
1637pub fn wmi_namespace(namespace: &str) -> Result<String, String> {
1641 let ns = namespace.trim().replace('/', "\\");
1642 let ns = if ns.is_empty() { "root\\cimv2".to_string() } else { ns };
1643 let valid = ns.split('\\').all(|p| !p.is_empty() && p.chars().all(|c| c.is_alphanumeric() || c == '_'));
1644 if !valid || !ns.split('\\').next().is_some_and(|r| r.eq_ignore_ascii_case("root")) {
1645 return Err(crate::messages::tf("namespace do WMI inválido '{0}' (só desta máquina, como root\\cimv2)", &[&namespace]));
1646 }
1647 Ok(ns)
1648}
1649
1650pub fn wmi_datetime(text: &str) -> Option<String> {
1654 let t = text.trim();
1655 let b = t.as_bytes();
1656 if b.len() < 14 || !b[..14].iter().all(u8::is_ascii_digit) || b.get(21) == Some(&b':') {
1657 return None;
1658 }
1659 let (y, mo, d, h, mi, s) = (&t[0..4], &t[4..6], &t[6..8], &t[8..10], &t[10..12], &t[12..14]);
1660 let month: u32 = mo.parse().ok()?;
1661 let day: u32 = d.parse().ok()?;
1662 if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
1663 return None;
1664 }
1665 Some(format!("{y}-{mo}-{d}T{h}:{mi}:{s}"))
1666}
1667
1668pub fn wmi_select_list(wql: &str) -> Vec<String> {
1671 let t = wql.trim();
1672 let lower = t.to_ascii_lowercase();
1673 let (Some(rest), Some(from)) = (lower.strip_prefix("select"), lower.find(" from ")) else { return Vec::new() };
1674 let start = t.len() - rest.len();
1675 if from < start {
1676 return Vec::new();
1677 }
1678 t[start..from].split(',').map(str::trim).filter(|n| !n.is_empty() && *n != "*").map(str::to_string).collect()
1679}
1680
1681
1682static LOCAL_OFFSET: std::sync::RwLock<Option<fn(i64) -> i64>> = std::sync::RwLock::new(None);
1686
1687pub fn set_local_offset_fn(f: fn(i64) -> i64) {
1688 if let Ok(mut slot) = LOCAL_OFFSET.write() {
1689 *slot = Some(f);
1690 }
1691}
1692
1693static PROJECT_OFFSET: std::sync::RwLock<Option<fn(i64) -> i64>> = std::sync::RwLock::new(None);
1696
1697pub fn set_project_offset_fn(f: Option<fn(i64) -> i64>) {
1699 if let Ok(mut slot) = PROJECT_OFFSET.write() {
1700 *slot = f;
1701 }
1702}
1703
1704pub fn local_offset(utc: i64) -> i64 {
1707 let project = PROJECT_OFFSET.read().ok().and_then(|f| *f);
1708 project.or_else(|| LOCAL_OFFSET.read().ok().and_then(|f| *f)).map_or(0, |f| f(utc))
1709}