add CheckPrinter

build_lib.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 APP_NAME="libgofunc"
-VERSION="${1:-v0.1.11}"
+VERSION="${1:-v0.1.12}"
 OUTPUT_DIR="../assets"
 BUILD_DIR="../build"
 

printer.go

@@ -15,87 +15,54 @@ import (
 
 	"time"
 
+	"errors"
+
 	"github.com/kenshaw/escpos"
 )
-import (
-	"errors"
-)
+import "io"
 
 //export PrintImg
 func PrintImg(printer *C.char, imagePath *C.char) *C.char {
 	goPrinter := C.GoString(printer)
 	goImagePath := C.GoString(imagePath)
-	// printer := "tcp:192.168.100.151:9100"
-	// printer := "usb:/dev/usb/lp1"
-	var w *bufio.ReadWriter
-	if strings.HasPrefix(goPrinter, "tcp:") {
-		location := strings.TrimLeft(goPrinter, "tcp:")
-		conn, err := net.Dial("tcp", location)
-		if err != nil {
-			log.Println("error dialing:", err.Error())
-			return NewErr(err)
-		}
-		defer conn.Close()
-		w = bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
-	} else if strings.HasPrefix(goPrinter, "usb:") {
-		location := strings.TrimLeft(goPrinter, "usb:")
-		f, err := os.OpenFile(location, os.O_RDWR, os.ModeDevice)
-		if err != nil {
-			log.Println("error OpenFile usb:", err.Error())
-			return NewErr(err)
-		}
-		defer f.Close()
-		w = bufio.NewReadWriter(bufio.NewReader(f), bufio.NewWriter(f))
-		// } else if strings.HasPrefix(goPrinter, "int:") {
-		// 	ctx := gousb.NewContext()
-		// 	// location := strings.TrimLeft(goPrinter, "int:")
-		// 	targetBus := 1
-		// 	targetAddr := 5
-		// 	devs, err := ctx.OpenDevices(func(desc *gousb.DeviceDesc) bool {
-		// 		return int(desc.Bus) == targetBus && int(desc.Address) == targetAddr
-		// 	})
-		// 	if err != nil || len(devs) == 0 {
-		// 		log.Fatal("Could not find or open the device")
-		// 	}
-		// 	dev := devs[0]
-		// 	defer dev.Close()
-		// 	dev.SetAutoDetach(true)
-
-		// 	// 2. Claim the default interface (usually 0 for printers)
-		// 	// Note: This may require detaching the kernel driver on Linux
-		// 	intf, done, err := dev.DefaultInterface()
-		// 	if err != nil {
-		// 		log.Fatalf("Failed to claim interface: %v", err)
-		// 	}
-		// 	defer done()
-
-		// 	// 3. Open the Bulk Output Endpoint (usually endpoint #1 or #2)
-		// 	// You may need to inspect desc.Endpoints to find the correct Bulk Out ID
-		// 	out, err = intf.OutEndpoint(1)
-		// 	if err != nil {
-		// 		log.Fatalf("Failed to open OUT endpoint: %v", err)
-		// 	}
-		// 	// w = bufio.NewReadWriter(bufio.NewReader(outPort), bufio.NewWriter(f))
-		// 	rw := &USBReadWriter{out: out}
-		// 	reader := bufio.NewReader(rw)
-		// 	writer := bufio.NewWriter(rw)
-		// 	w = bufio.NewReadWriter(reader, writer)
-	} else {
-		return NewErr(errors.New("invalid printer"))
+	err := Print(goPrinter, goImagePath)
+	if err != nil {
+		return NewErr(err)
 	}
+	return NewOk(nil)
+}
+
+//export CheckPrinter
+func CheckPrinter(printer *C.char) *C.char {
+	goPrinter := C.GoString(printer)
+	err := Check(goPrinter)
+	if err != nil {
+		return NewErr(err)
+	}
+	return NewOk(nil)
+}
+
+func Print(printer, imagePath string) error {
+	conn, err := connect(printer)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+	w := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
+
 	prt := escpos.New(w)
 
 	prt.Init()
 	prt.SetSmooth(1)
 	prt.SetAlign("left")
 
-	imgBytes, err := imgData(goImagePath)
+	imgBytes, err := imgData(imagePath)
 	if err != nil {
-		return NewErr(err)
+		return err
 	}
-	err = WriteChunk(w, prt, imgBytes)
+	err = writeChunk(w, prt, imgBytes)
 	if err != nil {
-		return NewErr(err)
+		return err
 	}
 	time.Sleep(500 * time.Millisecond)
 	w.Flush()
@@ -105,17 +72,50 @@ func PrintImg(printer *C.char, imagePath *C.char) *C.char {
 	prt.End()
 	w.Flush()
 	time.Sleep(1 * time.Second)
-	return NewOk(nil)
+	return nil
 }
 
-func Print(printer, imagePath string) string {
-	result := PrintImg(C.CString(printer), C.CString(imagePath))
-	r := C.GoString(result)
-	return r
+func Check(printer string) error {
+	conn, err := connect(printer)
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	var w *bufio.ReadWriter
+	w = bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
+	prt := escpos.New(w)
+
+	prt.Init()
+	prt.SetSmooth(1)
+	prt.SetAlign("left")
+	time.Sleep(100 * time.Millisecond)
+	return w.Flush()
 }
 
-// WriteChunk breaks the large byte array into smaller chunks
-func WriteChunk(w *bufio.ReadWriter, prt *escpos.Escpos, data []byte) error {
+func connect(printer string) (io.ReadWriteCloser, error) {
+	if strings.HasPrefix(printer, "tcp:") {
+		location := strings.TrimLeft(printer, "tcp:")
+		conn, err := net.Dial("tcp", location)
+		if err != nil {
+			log.Println("error net.Dial tcp:", err.Error())
+			return nil, err
+		}
+		return conn, nil
+	} else if strings.HasPrefix(printer, "usb:") {
+		location := strings.TrimLeft(printer, "usb:")
+		f, err := os.OpenFile(location, os.O_RDWR, os.ModeDevice)
+		if err != nil {
+			log.Println("error os.OpenFile usb:", err.Error())
+			return nil, err
+		}
+		return f, nil
+	}
+	return nil, errors.New("invalid printer")
+}
+
+// writeChunk breaks the large byte array into smaller chunks
+func writeChunk(w *bufio.ReadWriter, prt *escpos.Escpos, data []byte) error {
 	chunkSize := 1024 // 1 KB chunks work best for network printers
 	for i := 0; i < len(data); i += chunkSize {
 		end := min(i+chunkSize, len(data))