core/cli: expose QR code CLI

port 1.5

core/internal/qrcode/qrcode.go

@@ -0,0 +1,282 @@
+package qrcode
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"image/color"
+	_ "image/jpeg"
+	_ "image/png"
+	"os"
+	"strings"
+
+	qr "github.com/yeqown/go-qrcode/v2"
+	"github.com/yeqown/go-qrcode/writer/standard"
+)
+
+type TermOptions struct {
+	ECC       string
+	Version   int
+	QuietZone int
+	Invert    bool
+	Fg        string
+	Bg        string
+}
+
+type ImageOptions struct {
+	ECC         string
+	Version     int
+	ModuleSize  int
+	Fg          string
+	Bg          string
+	Transparent bool
+	Border      int
+	Shape       string
+	Logo        string
+	LogoScale   int
+}
+
+var wifiEscaper = strings.NewReplacer(`\`, `\\`, `;`, `\;`, `,`, `\,`, `:`, `\:`, `"`, `\"`)
+
+func WiFiString(security, ssid, password string, hidden bool) string {
+	if security == "" {
+		security = "WPA"
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "WIFI:T:%s;S:%s;", security, wifiEscaper.Replace(ssid))
+	if !strings.EqualFold(security, "nopass") {
+		fmt.Fprintf(&b, "P:%s;", wifiEscaper.Replace(password))
+	}
+	if hidden {
+		b.WriteString("H:true;")
+	}
+	b.WriteString(";")
+	return b.String()
+}
+
+// Colors are painted explicitly on both halves of each ▀ cell so polarity
+// does not depend on the terminal theme.
+func RenderTerminal(text string, opt TermOptions) (string, error) {
+	fg, err := parseColor(opt.Fg, color.RGBA{A: 255})
+	if err != nil {
+		return "", err
+	}
+	bg, err := parseColor(opt.Bg, color.RGBA{R: 255, G: 255, B: 255, A: 255})
+	if err != nil {
+		return "", err
+	}
+	if opt.Invert {
+		fg, bg = bg, fg
+	}
+
+	mat, err := encode(text, opt.ECC, opt.Version)
+	if err != nil {
+		return "", err
+	}
+	grid := bitmapWithQuietZone(mat, opt.QuietZone)
+
+	var b strings.Builder
+	for y := 0; y < len(grid); y += 2 {
+		for x := range grid[y] {
+			top := moduleColor(grid[y][x], fg, bg)
+			bottom := bg
+			if y+1 < len(grid) {
+				bottom = moduleColor(grid[y+1][x], fg, bg)
+			}
+			fmt.Fprintf(&b, "\x1b[38;2;%d;%d;%dm\x1b[48;2;%d;%d;%dm▀", top.R, top.G, top.B, bottom.R, bottom.G, bottom.B)
+		}
+		b.WriteString("\x1b[0m\n")
+	}
+	return b.String(), nil
+}
+
+func RenderPNG(text string, opt ImageOptions) ([]byte, error) {
+	encOpts, err := encodeOptions(opt.ECC, opt.Version)
+	if err != nil {
+		return nil, err
+	}
+	imgOpts, err := imageOptions(opt)
+	if err != nil {
+		return nil, err
+	}
+
+	q, err := qr.NewWith(text, encOpts...)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	w := standard.NewWithWriter(nopCloser{&buf}, imgOpts...)
+	if err := q.Save(w); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func encodeOptions(ecc string, version int) ([]qr.EncodeOption, error) {
+	eccOpt, err := eccOption(ecc)
+	if err != nil {
+		return nil, err
+	}
+	opts := []qr.EncodeOption{eccOpt}
+	switch {
+	case version == 0:
+	case version >= 1 && version <= 40:
+		opts = append(opts, qr.WithVersion(version))
+	default:
+		return nil, fmt.Errorf("QR version must be 1-40, got %d", version)
+	}
+	return opts, nil
+}
+
+func eccOption(level string) (qr.EncodeOption, error) {
+	switch strings.ToUpper(level) {
+	case "", "M":
+		return qr.WithErrorCorrectionLevel(qr.ErrorCorrectionMedium), nil
+	case "L":
+		return qr.WithErrorCorrectionLevel(qr.ErrorCorrectionLow), nil
+	case "Q":
+		return qr.WithErrorCorrectionLevel(qr.ErrorCorrectionQuart), nil
+	case "H":
+		return qr.WithErrorCorrectionLevel(qr.ErrorCorrectionHighest), nil
+	default:
+		return nil, fmt.Errorf("invalid error correction level %q (want L, M, Q, or H)", level)
+	}
+}
+
+func imageOptions(opt ImageOptions) ([]standard.ImageOption, error) {
+	if opt.ModuleSize < 0 || opt.ModuleSize > 255 {
+		return nil, fmt.Errorf("module size must be 0-255, got %d", opt.ModuleSize)
+	}
+
+	opts := []standard.ImageOption{standard.WithBuiltinImageEncoder(standard.PNG_FORMAT)}
+	if opt.ModuleSize > 0 {
+		opts = append(opts, standard.WithQRWidth(uint8(opt.ModuleSize)))
+	}
+	if opt.Border >= 0 {
+		opts = append(opts, standard.WithBorderWidth(opt.Border))
+	}
+
+	switch {
+	case opt.Transparent:
+		opts = append(opts, standard.WithBgTransparent())
+	case opt.Bg != "":
+		c, err := parseColor(opt.Bg, color.RGBA{})
+		if err != nil {
+			return nil, err
+		}
+		opts = append(opts, standard.WithBgColor(c))
+	}
+	if opt.Fg != "" {
+		c, err := parseColor(opt.Fg, color.RGBA{})
+		if err != nil {
+			return nil, err
+		}
+		opts = append(opts, standard.WithFgColor(c))
+	}
+
+	switch strings.ToLower(opt.Shape) {
+	case "", "square":
+	case "circle":
+		opts = append(opts, standard.WithCircleShape())
+	default:
+		return nil, fmt.Errorf("invalid shape %q (want square or circle)", opt.Shape)
+	}
+
+	if opt.Logo != "" {
+		img, err := loadImage(opt.Logo)
+		if err != nil {
+			return nil, err
+		}
+		opts = append(opts, standard.WithLogoImage(img))
+		if opt.LogoScale > 0 {
+			opts = append(opts, standard.WithLogoSizeMultiplier(opt.LogoScale))
+		}
+	}
+	return opts, nil
+}
+
+func encode(text, ecc string, version int) (qr.Matrix, error) {
+	opts, err := encodeOptions(ecc, version)
+	if err != nil {
+		return qr.Matrix{}, err
+	}
+	q, err := qr.NewWith(text, opts...)
+	if err != nil {
+		return qr.Matrix{}, err
+	}
+	mw := &matrixWriter{}
+	if err := q.Save(mw); err != nil {
+		return qr.Matrix{}, err
+	}
+	return mw.mat, nil
+}
+
+func bitmapWithQuietZone(mat qr.Matrix, quiet int) [][]bool {
+	if quiet < 0 {
+		quiet = 0
+	}
+	src := mat.Bitmap()
+	h := len(src)
+	w := 0
+	if h > 0 {
+		w = len(src[0])
+	}
+	out := make([][]bool, h+quiet*2)
+	for y := range out {
+		out[y] = make([]bool, w+quiet*2)
+	}
+	for y := range h {
+		for x := range w {
+			out[y+quiet][x+quiet] = src[y][x]
+		}
+	}
+	return out
+}
+
+func moduleColor(dark bool, fg, bg color.RGBA) color.RGBA {
+	if dark {
+		return fg
+	}
+	return bg
+}
+
+func parseColor(hex string, def color.RGBA) (color.RGBA, error) {
+	hex = strings.TrimPrefix(strings.TrimSpace(hex), "#")
+	if hex == "" {
+		return def, nil
+	}
+	if len(hex) == 3 {
+		hex = fmt.Sprintf("%c%c%c%c%c%c", hex[0], hex[0], hex[1], hex[1], hex[2], hex[2])
+	}
+	var r, g, b int
+	if len(hex) != 6 {
+		return def, fmt.Errorf("invalid color %q (want #RGB or #RRGGBB)", hex)
+	}
+	if _, err := fmt.Sscanf(hex, "%02x%02x%02x", &r, &g, &b); err != nil {
+		return def, fmt.Errorf("invalid color %q (want #RGB or #RRGGBB)", hex)
+	}
+	return color.RGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: 255}, nil
+}
+
+func loadImage(path string) (image.Image, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	img, _, err := image.Decode(f)
+	if err != nil {
+		return nil, fmt.Errorf("decode %s: %w", path, err)
+	}
+	return img, nil
+}
+
+type matrixWriter struct{ mat qr.Matrix }
+
+func (w *matrixWriter) Write(m qr.Matrix) error { w.mat = m; return nil }
+func (w *matrixWriter) Close() error            { return nil }
+
+type nopCloser struct{ *bytes.Buffer }
+
+func (nopCloser) Close() error { return nil }

core/internal/server/network/handlers.go

@@ -43,6 +43,8 @@ func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 		handleGetNetworkInfo(conn, req, manager)
 	case "network.qrcode":
 		handleGetNetworkQRCode(conn, req, manager)
+	case "network.qrcode-content":
+		handleGetNetworkQRCodeContent(conn, req, manager)
 	case "network.delete-qrcode":
 		handleDeleteQRCode(conn, req, manager)
 	case "network.ethernet.info":
@@ -341,6 +343,22 @@ func handleGetNetworkQRCode(conn net.Conn, req models.Request, manager *Manager)
 	models.Respond(conn, req.ID, content)
 }
 
+func handleGetNetworkQRCodeContent(conn net.Conn, req models.Request, manager *Manager) {
+	ssid, err := params.String(req.Params, "ssid")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	content, err := manager.GetWiFiQRContent(ssid)
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+
+	models.Respond(conn, req.ID, content)
+}
+
 func handleDeleteQRCode(conn net.Conn, req models.Request, _ *Manager) {
 	path, err := params.String(req.Params, "path")
 	if err != nil {

core/internal/server/network/manager.go

@@ -473,6 +473,10 @@ func (m *Manager) GetNetworkInfoDetailed(ssid string) (*NetworkInfoResponse, err
 	return m.backend.GetWiFiNetworkDetails(ssid)
 }
 
+func (m *Manager) GetWiFiQRContent(ssid string) (string, error) {
+	return m.backend.GetWiFiQRCodeContent(ssid)
+}
+
 func (m *Manager) GetNetworkQRCode(ssid string) ([2]string, error) {
 	content, err := m.backend.GetWiFiQRCodeContent(ssid)
 	if err != nil {

core/internal/server/network/wifi_qrcode.go

@@ -5,12 +5,14 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/qrcode"
 )
 
 const qrCodeTmpPrefix = "/tmp/dank-wifi-qrcode-"
 
 func FormatWiFiQRString(securityType, ssid, password string) string {
-	return fmt.Sprintf("WIFI:T:%s;S:%s;P:%s;;", securityType, ssid, password)
+	return qrcode.WiFiString(securityType, ssid, password, false)
 }
 
 func qrCodePaths(ssid string) (themed, normal string) {