BlueGit

timfa posprint

Files

posprint / src / print / mod.rs

mod.rs

feat: include paired Classic Bluetooth SPP printers in discovery
timfa project_84475926_bot_3b4fb417c41b9b24a7422b6452f025d2 · pushed by timfa · 8 weeks ago
8b514b7f History
mod.rs 13.3 KiB Download Raw
1use std::io::{self, Write};
2use std::time::Duration;
3
4use serialport::{SerialPortInfo, SerialPortType};
5
6mod usb_direct;
7#[cfg(windows)]
8mod win_spool;
9
10/// Common baud rates for USB POS printers (115200 first — many modern devices).
11pub const BAUD_RATES: [u32; 6] = [115200, 9600, 19200, 38400, 57600, 4800];
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub enum PrinterTarget {
15 Serial(String),
16 UsbDirect {
17 vid: u16,
18 pid: u16,
19 bus: u8,
20 address: u8,
21 },
22 WinSpooler(String),
23}
24
25#[derive(Debug, Clone, PartialEq, Eq)]
26pub struct PrinterDevice {
27 pub id: String,
28 pub display_name: String,
29 pub target: PrinterTarget,
30}
31
32#[derive(Debug)]
33pub enum PrintError {
34 NotFound,
35 Open(String),
36 Write(String),
37 Serial(serialport::Error),
38}
39
40impl From<serialport::Error> for PrintError {
41 fn from(value: serialport::Error) -> Self {
42 Self::Serial(value)
43 }
44}
45
46pub trait PrinterTransport {
47 fn write_all(&mut self, data: &[u8]) -> io::Result<()>;
48 fn flush(&mut self) -> io::Result<()>;
49}
50
51pub struct SerialTransport {
52 port: Box<dyn serialport::SerialPort>,
53 pub baud_rate: u32,
54}
55
56impl SerialTransport {
57 pub fn open(port_name: &str) -> Result<Self, PrintError> {
58 let mut last_err = String::from("no baud rate succeeded");
59 for &baud in &BAUD_RATES {
60 match serialport::new(port_name, baud)
61 .timeout(Duration::from_millis(2000))
62 .open()
63 {
64 Ok(port) => {
65 return Ok(Self { port, baud_rate: baud });
66 }
67 Err(e) => last_err = format!("{baud} baud: {e}"),
68 }
69 }
70 Err(PrintError::Open(last_err))
71 }
72}
73
74impl PrinterTransport for SerialTransport {
75 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
76 self.port.write_all(data)
77 }
78
79 fn flush(&mut self) -> io::Result<()> {
80 self.port.flush()
81 }
82}
83
84/// List POS printers: USB printer-class, Windows spooler, then USB-serial and
85/// OS-paired Classic Bluetooth SPP ports.
86pub fn list_printers() -> Result<Vec<PrinterDevice>, PrintError> {
87 let mut devices = usb_direct::list_usb_printer_devices();
88
89 #[cfg(windows)]
90 devices.extend(win_spool::list_windows_spooler_printers());
91
92 devices.extend(list_serial_devices()?);
93 Ok(devices)
94}
95
96pub fn list_usb_serial_printers() -> Result<Vec<PrinterDevice>, serialport::Error> {
97 list_serial_devices()
98}
99
100fn list_serial_devices() -> Result<Vec<PrinterDevice>, serialport::Error> {
101 let mut devices = Vec::new();
102 for port in serialport::available_ports()? {
103 if let Some(device) = serial_device_from_port(&port) {
104 devices.push(device);
105 }
106 }
107 devices.sort_by(|a, b| a.display_name.cmp(&b.display_name));
108 Ok(devices)
109}
110
111/// USB-serial or OS-paired Classic Bluetooth SPP. Skips empty PCI/`ttyS*` noise.
112pub fn is_serial_printer_candidate(port_type: &SerialPortType) -> bool {
113 is_usb_serial_candidate(port_type) || is_bluetooth_serial_candidate(port_type)
114}
115
116/// True when a serial port type is a connected USB device (possible POS printer).
117pub fn is_usb_serial_candidate(port_type: &SerialPortType) -> bool {
118 matches!(port_type, SerialPortType::UsbPort(_))
119}
120
121/// True when `serialport` reports a Classic Bluetooth SPP / RFCOMM port.
122pub fn is_bluetooth_serial_candidate(port_type: &SerialPortType) -> bool {
123 matches!(port_type, SerialPortType::BluetoothPort)
124}
125
126/// Linux RFCOMM node (`/dev/rfcomm0`) even if enumeration typed it as Unknown.
127fn is_rfcomm_device_name(port_name: &str) -> bool {
128 let base = port_name.rsplit(['/', '\\']).next().unwrap_or(port_name);
129 base.len() >= 6 && base[..6].eq_ignore_ascii_case("rfcomm")
130}
131
132/// Map an enumerated serial port to a printer entry, or skip PCI/`ttyS*` noise.
133pub fn serial_device_from_port(port: &SerialPortInfo) -> Option<PrinterDevice> {
134 if !is_serial_printer_candidate(&port.port_type) && !is_rfcomm_device_name(&port.port_name) {
135 return None;
136 }
137 Some(PrinterDevice {
138 id: format!("serial:{}", port.port_name),
139 display_name: serial_port_display_name(port),
140 target: PrinterTarget::Serial(port.port_name.clone()),
141 })
142}
143
144fn serial_port_display_name(port: &SerialPortInfo) -> String {
145 match &port.port_type {
146 SerialPortType::UsbPort(info) => {
147 let product = info
148 .product
149 .as_deref()
150 .or(info.serial_number.as_deref())
151 .unwrap_or("USB device");
152 format!(
153 "{} — {product} (serial {}:{})",
154 port.port_name,
155 fmt_vid_pid(info.vid),
156 fmt_vid_pid(info.pid)
157 )
158 }
159 SerialPortType::BluetoothPort => format!("{} — Bluetooth", port.port_name),
160 _ if is_rfcomm_device_name(&port.port_name) => {
161 format!("{} — Bluetooth", port.port_name)
162 }
163 _ => format!("{} — serial", port.port_name),
164 }
165}
166
167pub fn open_printer(target: &PrinterTarget) -> Result<Box<dyn PrinterTransport>, PrintError> {
168 match target {
169 PrinterTarget::Serial(port) => Ok(Box::new(SerialTransport::open(port)?)),
170 PrinterTarget::UsbDirect {
171 vid,
172 pid,
173 bus,
174 address,
175 } => Ok(Box::new(usb_direct::UsbDirectTransport::open(
176 *vid, *pid, *bus, *address,
177 )?)),
178 #[cfg(windows)]
179 PrinterTarget::WinSpooler(name) => Ok(Box::new(win_spool::WinSpoolerTransport::new(
180 name.clone(),
181 ))),
182 #[cfg(not(windows))]
183 PrinterTarget::WinSpooler(_) => Err(PrintError::Open(
184 "Windows spooler printing is only available on Windows".into(),
185 )),
186 }
187}
188
189/// Open by manual name: tries serial/COM first, then Windows spooler queue name.
190pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
191 let name = name.trim();
192 if name.is_empty() {
193 return Err(PrintError::NotFound);
194 }
195
196 if let Ok(transport) = SerialTransport::open(name) {
197 return Ok(Box::new(transport));
198 }
199
200 #[cfg(windows)]
201 {
202 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
203 name.to_string(),
204 )));
205 }
206
207 #[cfg(not(windows))]
208 Err(PrintError::Open(format!(
209 "could not open serial port '{name}'"
210 )))
211}
212
213fn fmt_vid_pid(v: u16) -> String {
214 format!("{v:04x}")
215}
216
217impl PrinterTransport for Box<dyn PrinterTransport> {
218 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
219 (**self).write_all(data)
220 }
221
222 fn flush(&mut self) -> io::Result<()> {
223 (**self).flush()
224 }
225}
226
227pub fn print_bytes<T: PrinterTransport + ?Sized>(transport: &mut T, data: &[u8]) -> Result<(), PrintError> {
228 transport
229 .write_all(data)
230 .map_err(|e| PrintError::Write(e.to_string()))?;
231 transport
232 .flush()
233 .map_err(|e| PrintError::Write(e.to_string()))?;
234 Ok(())
235}
236
237/// Stable key for remembering the last successful printer across reconnects.
238/// USB uses vid:pid only (bus/address change when replugged).
239pub fn printer_preference_key(target: &PrinterTarget) -> String {
240 match target {
241 PrinterTarget::Serial(port) => format!("serial:{port}"),
242 PrinterTarget::WinSpooler(name) => format!("winspool:{name}"),
243 PrinterTarget::UsbDirect { vid, pid, .. } => {
244 format!("usb:{vid:04x}:{pid:04x}")
245 }
246 }
247}
248
249pub fn manual_printer_preference_key(name: &str) -> String {
250 format!("manual:{}", name.trim())
251}
252
253/// Index of a discovered printer matching a stored preference key, if still connected.
254pub fn find_preferred_printer_index(printers: &[PrinterDevice], key: &str) -> Option<usize> {
255 let key = key.trim();
256 if key.is_empty() || key.starts_with("manual:") {
257 return None;
258 }
259 printers
260 .iter()
261 .position(|p| printer_preference_key(&p.target) == key)
262}
263
264pub struct MockTransport {
265 pub written: Vec<u8>,
266}
267
268impl MockTransport {
269 pub fn new() -> Self {
270 Self { written: Vec::new() }
271 }
272}
273
274impl Default for MockTransport {
275 fn default() -> Self {
276 Self::new()
277 }
278}
279
280impl PrinterTransport for MockTransport {
281 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
282 self.written.extend_from_slice(data);
283 Ok(())
284 }
285
286 fn flush(&mut self) -> io::Result<()> {
287 Ok(())
288 }
289}
290
291#[cfg(test)]
292mod tests {
293 use super::*;
294 use serialport::{SerialPortInfo, UsbPortInfo};
295
296 #[test]
297 fn mock_transport_records_bytes() {
298 let mut mock = MockTransport::new();
299 print_bytes(&mut mock, &[1, 2, 3]).unwrap();
300 assert_eq!(mock.written, vec![1, 2, 3]);
301 }
302
303 #[test]
304 fn list_printers_returns_vec() {
305 let list = list_printers();
306 assert!(list.is_ok());
307 }
308
309 fn sample_usb_port_type() -> SerialPortType {
310 SerialPortType::UsbPort(UsbPortInfo {
311 vid: 0x0416,
312 pid: 0x5011,
313 serial_number: None,
314 manufacturer: None,
315 product: Some("POS-58".into()),
316 })
317 }
318
319 #[test]
320 fn pci_and_unknown_serial_ports_are_not_candidates() {
321 assert!(!is_serial_printer_candidate(&SerialPortType::PciPort));
322 assert!(!is_serial_printer_candidate(&SerialPortType::Unknown));
323 assert!(!is_usb_serial_candidate(&SerialPortType::BluetoothPort));
324 assert!(!is_usb_serial_candidate(&SerialPortType::PciPort));
325 assert!(!is_usb_serial_candidate(&SerialPortType::Unknown));
326 }
327
328 #[test]
329 fn usb_and_bluetooth_serial_ports_are_candidates() {
330 let usb = sample_usb_port_type();
331 assert!(is_usb_serial_candidate(&usb));
332 assert!(is_serial_printer_candidate(&usb));
333 assert!(is_bluetooth_serial_candidate(&SerialPortType::BluetoothPort));
334 assert!(is_serial_printer_candidate(&SerialPortType::BluetoothPort));
335 }
336
337 #[test]
338 fn bluetooth_serial_device_is_labeled() {
339 let port = SerialPortInfo {
340 port_name: "COM5".into(),
341 port_type: SerialPortType::BluetoothPort,
342 };
343 let device = serial_device_from_port(&port).expect("bluetooth candidate");
344 assert_eq!(device.id, "serial:COM5");
345 assert_eq!(device.display_name, "COM5 — Bluetooth");
346 assert_eq!(device.target, PrinterTarget::Serial("COM5".into()));
347 }
348
349 #[test]
350 fn linux_rfcomm_is_listed_even_if_type_unknown() {
351 let port = SerialPortInfo {
352 port_name: "/dev/rfcomm0".into(),
353 port_type: SerialPortType::Unknown,
354 };
355 let device = serial_device_from_port(&port).expect("rfcomm candidate");
356 assert_eq!(device.display_name, "/dev/rfcomm0 — Bluetooth");
357 assert_eq!(device.target, PrinterTarget::Serial("/dev/rfcomm0".into()));
358 }
359
360 #[test]
361 fn empty_pci_ttys_ports_are_not_listed() {
362 let pci = SerialPortInfo {
363 port_name: "/dev/ttyS0".into(),
364 port_type: SerialPortType::PciPort,
365 };
366 assert!(serial_device_from_port(&pci).is_none());
367 let unknown = SerialPortInfo {
368 port_name: "/dev/ttyS1".into(),
369 port_type: SerialPortType::Unknown,
370 };
371 assert!(serial_device_from_port(&unknown).is_none());
372 }
373
374 #[test]
375 fn usb_serial_device_keeps_vid_pid_label() {
376 let port = SerialPortInfo {
377 port_name: "/dev/ttyUSB0".into(),
378 port_type: sample_usb_port_type(),
379 };
380 let device = serial_device_from_port(&port).expect("usb candidate");
381 assert!(device.display_name.contains("POS-58"));
382 assert!(device.display_name.contains("0416:5011"));
383 assert!(!device.display_name.contains("Bluetooth"));
384 }
385
386 #[test]
387 fn preference_key_ignores_usb_bus_address() {
388 let a = PrinterTarget::UsbDirect {
389 vid: 0x0416,
390 pid: 0x5011,
391 bus: 1,
392 address: 2,
393 };
394 let b = PrinterTarget::UsbDirect {
395 vid: 0x0416,
396 pid: 0x5011,
397 bus: 3,
398 address: 9,
399 };
400 assert_eq!(printer_preference_key(&a), printer_preference_key(&b));
401 assert_eq!(printer_preference_key(&a), "usb:0416:5011");
402 }
403
404 #[test]
405 fn finds_preferred_printer_by_key() {
406 let printers = vec![
407 PrinterDevice {
408 id: "serial:COM1".into(),
409 display_name: "COM1".into(),
410 target: PrinterTarget::Serial("COM1".into()),
411 },
412 PrinterDevice {
413 id: "winspool:POS".into(),
414 display_name: "POS".into(),
415 target: PrinterTarget::WinSpooler("POS".into()),
416 },
417 ];
418 assert_eq!(
419 find_preferred_printer_index(&printers, "winspool:POS"),
420 Some(1)
421 );
422 assert_eq!(find_preferred_printer_index(&printers, "serial:COM9"), None);
423 assert_eq!(
424 find_preferred_printer_index(&printers, "manual:COM3"),
425 None
426 );
427 }
428}