BlueGit

timfa posprint

Files

posprint / src / print / mod.rs

mod.rs

mod.rs 16.7 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/// Match a printer from `list_printers()` by `"auto"`, device `id`, preference key (`usb:vid:pid`), or `display_name`.
190pub fn find_matching_printer<'a>(
191 printers: &'a [PrinterDevice],
192 name: &str,
193) -> Option<&'a PrinterDevice> {
194 let name = name.trim();
195 if name.is_empty() {
196 return None;
197 }
198 if name.eq_ignore_ascii_case("auto") {
199 return printers.first();
200 }
201 printers.iter().find(|p| {
202 p.id == name || printer_preference_key(&p.target) == name || p.display_name == name
203 })
204}
205
206/// Open by manual name: tries discovered printers (`id`, `usb:vid:pid`, `"auto"`), then serial/COM, then Windows spooler queue name.
207pub fn open_printer_by_name(name: &str) -> Result<Box<dyn PrinterTransport>, PrintError> {
208 let name = name.trim();
209 if name.is_empty() {
210 return Err(PrintError::NotFound);
211 }
212
213 if let Ok(printers) = list_printers() {
214 if let Some(matched) = find_matching_printer(&printers, name) {
215 return open_printer(&matched.target);
216 }
217 }
218
219 let serial_name = name.strip_prefix("serial:").unwrap_or(name);
220 if let Ok(transport) = SerialTransport::open(serial_name) {
221 return Ok(Box::new(transport));
222 }
223
224 #[cfg(windows)]
225 {
226 return Ok(Box::new(win_spool::WinSpoolerTransport::new(
227 name.to_string(),
228 )));
229 }
230
231 #[cfg(not(windows))]
232 Err(PrintError::Open(format!(
233 "could not open serial port '{name}'"
234 )))
235}
236
237/// IEEE 1284 device ID if the printer exposes one (USB direct only).
238pub fn printer_device_id(target: &PrinterTarget) -> Option<String> {
239 match target {
240 PrinterTarget::UsbDirect { vid, pid, bus, address } => {
241 usb_direct::read_device_id(*vid, *pid, *bus, *address)
242 }
243 _ => None,
244 }
245}
246
247/// Detect the command language of a printer (ESC/POS unless clearly TSPL).
248pub fn detect_printer(target: &PrinterTarget) -> crate::protocol::Detection {
249 let id = printer_device_id(target);
250 crate::protocol::detect(target, id.as_deref())
251}
252
253/// Ask a bidirectional USB printer something and return its raw reply.
254pub fn query_printer(target: &PrinterTarget, request: &[u8]) -> Option<Vec<u8>> {
255 match target {
256 PrinterTarget::UsbDirect { vid, pid, bus, address } => usb_direct::query(
257 *vid,
258 *pid,
259 *bus,
260 *address,
261 request,
262 Duration::from_millis(800),
263 ),
264 _ => None,
265 }
266}
267
268fn fmt_vid_pid(v: u16) -> String {
269 format!("{v:04x}")
270}
271
272impl PrinterTransport for Box<dyn PrinterTransport> {
273 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
274 (**self).write_all(data)
275 }
276
277 fn flush(&mut self) -> io::Result<()> {
278 (**self).flush()
279 }
280}
281
282pub fn print_bytes<T: PrinterTransport + ?Sized>(transport: &mut T, data: &[u8]) -> Result<(), PrintError> {
283 transport
284 .write_all(data)
285 .map_err(|e| PrintError::Write(e.to_string()))?;
286 transport
287 .flush()
288 .map_err(|e| PrintError::Write(e.to_string()))?;
289 Ok(())
290}
291
292/// Stable key for remembering the last successful printer across reconnects.
293/// USB uses vid:pid only (bus/address change when replugged).
294pub fn printer_preference_key(target: &PrinterTarget) -> String {
295 match target {
296 PrinterTarget::Serial(port) => format!("serial:{port}"),
297 PrinterTarget::WinSpooler(name) => format!("winspool:{name}"),
298 PrinterTarget::UsbDirect { vid, pid, .. } => {
299 format!("usb:{vid:04x}:{pid:04x}")
300 }
301 }
302}
303
304pub fn manual_printer_preference_key(name: &str) -> String {
305 format!("manual:{}", name.trim())
306}
307
308/// Index of a discovered printer matching a stored preference key, if still connected.
309pub fn find_preferred_printer_index(printers: &[PrinterDevice], key: &str) -> Option<usize> {
310 let key = key.trim();
311 if key.is_empty() || key.starts_with("manual:") {
312 return None;
313 }
314 printers
315 .iter()
316 .position(|p| printer_preference_key(&p.target) == key)
317}
318
319pub struct MockTransport {
320 pub written: Vec<u8>,
321}
322
323impl MockTransport {
324 pub fn new() -> Self {
325 Self { written: Vec::new() }
326 }
327}
328
329impl Default for MockTransport {
330 fn default() -> Self {
331 Self::new()
332 }
333}
334
335impl PrinterTransport for MockTransport {
336 fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
337 self.written.extend_from_slice(data);
338 Ok(())
339 }
340
341 fn flush(&mut self) -> io::Result<()> {
342 Ok(())
343 }
344}
345
346#[cfg(test)]
347mod tests {
348 use super::*;
349 use serialport::{SerialPortInfo, UsbPortInfo};
350
351 #[test]
352 fn mock_transport_records_bytes() {
353 let mut mock = MockTransport::new();
354 print_bytes(&mut mock, &[1, 2, 3]).unwrap();
355 assert_eq!(mock.written, vec![1, 2, 3]);
356 }
357
358 #[test]
359 fn list_printers_returns_vec() {
360 let list = list_printers();
361 assert!(list.is_ok());
362 }
363
364 fn sample_usb_port_type() -> SerialPortType {
365 SerialPortType::UsbPort(UsbPortInfo {
366 vid: 0x0416,
367 pid: 0x5011,
368 serial_number: None,
369 manufacturer: None,
370 product: Some("POS-58".into()),
371 })
372 }
373
374 #[test]
375 fn pci_and_unknown_serial_ports_are_not_candidates() {
376 assert!(!is_serial_printer_candidate(&SerialPortType::PciPort));
377 assert!(!is_serial_printer_candidate(&SerialPortType::Unknown));
378 assert!(!is_usb_serial_candidate(&SerialPortType::BluetoothPort));
379 assert!(!is_usb_serial_candidate(&SerialPortType::PciPort));
380 assert!(!is_usb_serial_candidate(&SerialPortType::Unknown));
381 }
382
383 #[test]
384 fn usb_and_bluetooth_serial_ports_are_candidates() {
385 let usb = sample_usb_port_type();
386 assert!(is_usb_serial_candidate(&usb));
387 assert!(is_serial_printer_candidate(&usb));
388 assert!(is_bluetooth_serial_candidate(&SerialPortType::BluetoothPort));
389 assert!(is_serial_printer_candidate(&SerialPortType::BluetoothPort));
390 }
391
392 #[test]
393 fn bluetooth_serial_device_is_labeled() {
394 let port = SerialPortInfo {
395 port_name: "COM5".into(),
396 port_type: SerialPortType::BluetoothPort,
397 };
398 let device = serial_device_from_port(&port).expect("bluetooth candidate");
399 assert_eq!(device.id, "serial:COM5");
400 assert_eq!(device.display_name, "COM5 — Bluetooth");
401 assert_eq!(device.target, PrinterTarget::Serial("COM5".into()));
402 }
403
404 #[test]
405 fn linux_rfcomm_is_listed_even_if_type_unknown() {
406 let port = SerialPortInfo {
407 port_name: "/dev/rfcomm0".into(),
408 port_type: SerialPortType::Unknown,
409 };
410 let device = serial_device_from_port(&port).expect("rfcomm candidate");
411 assert_eq!(device.display_name, "/dev/rfcomm0 — Bluetooth");
412 assert_eq!(device.target, PrinterTarget::Serial("/dev/rfcomm0".into()));
413 }
414
415 #[test]
416 fn empty_pci_ttys_ports_are_not_listed() {
417 let pci = SerialPortInfo {
418 port_name: "/dev/ttyS0".into(),
419 port_type: SerialPortType::PciPort,
420 };
421 assert!(serial_device_from_port(&pci).is_none());
422 let unknown = SerialPortInfo {
423 port_name: "/dev/ttyS1".into(),
424 port_type: SerialPortType::Unknown,
425 };
426 assert!(serial_device_from_port(&unknown).is_none());
427 }
428
429 #[test]
430 fn usb_serial_device_keeps_vid_pid_label() {
431 let port = SerialPortInfo {
432 port_name: "/dev/ttyUSB0".into(),
433 port_type: sample_usb_port_type(),
434 };
435 let device = serial_device_from_port(&port).expect("usb candidate");
436 assert!(device.display_name.contains("POS-58"));
437 assert!(device.display_name.contains("0416:5011"));
438 assert!(!device.display_name.contains("Bluetooth"));
439 }
440
441 #[test]
442 fn preference_key_ignores_usb_bus_address() {
443 let a = PrinterTarget::UsbDirect {
444 vid: 0x0416,
445 pid: 0x5011,
446 bus: 1,
447 address: 2,
448 };
449 let b = PrinterTarget::UsbDirect {
450 vid: 0x0416,
451 pid: 0x5011,
452 bus: 3,
453 address: 9,
454 };
455 assert_eq!(printer_preference_key(&a), printer_preference_key(&b));
456 assert_eq!(printer_preference_key(&a), "usb:0416:5011");
457 }
458
459 #[test]
460 fn finds_preferred_printer_by_key() {
461 let printers = vec![
462 PrinterDevice {
463 id: "serial:COM1".into(),
464 display_name: "COM1".into(),
465 target: PrinterTarget::Serial("COM1".into()),
466 },
467 PrinterDevice {
468 id: "winspool:POS".into(),
469 display_name: "POS".into(),
470 target: PrinterTarget::WinSpooler("POS".into()),
471 },
472 ];
473 assert_eq!(
474 find_preferred_printer_index(&printers, "winspool:POS"),
475 Some(1)
476 );
477 assert_eq!(find_preferred_printer_index(&printers, "serial:COM9"), None);
478 assert_eq!(
479 find_preferred_printer_index(&printers, "manual:COM3"),
480 None
481 );
482 }
483
484 #[test]
485 fn matches_discovered_printer_by_id_key_or_auto() {
486 let printers = vec![
487 PrinterDevice {
488 id: "usb:28e9:0289:0:1".into(),
489 display_name: "micro-printer — USB 28e9:0289 (direct)".into(),
490 target: PrinterTarget::UsbDirect {
491 vid: 0x28e9,
492 pid: 0x0289,
493 bus: 0,
494 address: 1,
495 },
496 },
497 PrinterDevice {
498 id: "serial:/dev/cu.usbserial-1410".into(),
499 display_name: "/dev/cu.usbserial-1410 — POS-58 (serial 0416:5011)".into(),
500 target: PrinterTarget::Serial("/dev/cu.usbserial-1410".into()),
501 },
502 ];
503 assert_eq!(
504 find_matching_printer(&printers, "auto").map(|p| p.id.as_str()),
505 Some("usb:28e9:0289:0:1")
506 );
507 assert_eq!(
508 find_matching_printer(&printers, "usb:28e9:0289:0:1").map(|p| p.id.as_str()),
509 Some("usb:28e9:0289:0:1")
510 );
511 assert_eq!(
512 find_matching_printer(&printers, "usb:28e9:0289").map(|p| p.id.as_str()),
513 Some("usb:28e9:0289:0:1")
514 );
515 assert_eq!(
516 find_matching_printer(&printers, "serial:/dev/cu.usbserial-1410").map(|p| p.id.as_str()),
517 Some("serial:/dev/cu.usbserial-1410")
518 );
519 assert!(find_matching_printer(&printers, "usb:9999:9999").is_none());
520 assert!(find_matching_printer(&[], "auto").is_none());
521 }
522}