feat: independent fullscreen kiosk display foundation (#1)

Kiosk process owns its display lifecycle: waits for X11, keeps the
fullscreen black canvas below video, stops deterministically on signal.
Supervisor starts it before video, restarts only on process death, and
shuts the whole process group down; X11 downtime never restarts the
supervisor. Per-target opener/template abstractions for future MIPI.

cmd/groundstation-display/main.go

@@ -1,71 +1,47 @@
+// Command groundstation-display renders the Ground Station kiosk canvas. It
+// owns its display lifecycle independently of WFB, the transmitter and the
+// video launcher: it waits for its target to appear, redraws as needed, and
+// stops only when it receives SIGINT or SIGTERM.
 package main
 
 import (
+	"context"
+	"flag"
 	"fmt"
 	"log"
 	"os"
-	"os/exec"
+	"os/signal"
+	"syscall"
 
-	"github.com/BurntSushi/xgb"
-	"github.com/BurntSushi/xgb/xproto"
+	"git.piksar.eu/piotr/groundstation/internal/display"
 )
 
-const (
-	width  = 1920
-	height = 1080
-)
+// buildTarget selects the target-specific opener and template. Each target
+// owns its own backend and layouts; there is no shared global template.
+func buildTarget(name string) (display.Opener, display.Template, error) {
+	switch name {
+	case "x11":
+		return display.X11Opener{}, display.NewStatusTemplate("Brak polaczenia WFB"), nil
+	default:
+		return nil, nil, fmt.Errorf("unknown display target %q (supported: x11)", name)
+	}
+}
 
 func main() {
-	conn, err := xgb.NewConn()
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer conn.Close()
+	target := flag.String("target", "x11", "display target: x11 (Viture) today; mipi planned")
+	flag.Parse()
 
-	screen := xproto.Setup(conn).DefaultScreen(conn)
-	window, err := xproto.NewWindowId(conn)
+	opener, template, err := buildTarget(*target)
 	if err != nil {
 		log.Fatal(err)
 	}
-
-	values := uint32(xproto.CwBackPixel | xproto.CwEventMask)
-	xproto.CreateWindow(conn, screen.RootDepth, window, screen.Root, 0, 0, width, height, 0,
-		xproto.WindowClassInputOutput, screen.RootVisual, values,
-		[]uint32{screen.BlackPixel, xproto.EventMaskExposure})
-	xproto.MapWindow(conn, window)
-	conn.Sync()
-
-	// XFCE owns the actual fullscreen policy; use its existing wmctrl helper.
-	_ = exec.Command("wmctrl", "-i", "-r", fmt.Sprintf("0x%08x", window), "-b", "add,fullscreen").Run()
 
-	gc, err := xproto.NewGcontextId(conn)
-	if err != nil {
-		log.Fatal(err)
-	}
-	xproto.CreateGC(conn, gc, xproto.Drawable(window), xproto.GcForeground|xproto.GcBackground,
-		[]uint32{screen.WhitePixel, screen.BlackPixel})
-	font := xproto.Font(window)
-	xproto.OpenFont(conn, font, uint16(len("fixed")), "fixed")
-	xproto.ChangeGC(conn, gc, xproto.GcFont, []uint32{uint32(font)})
-
-	draw := func() {
-		xproto.ClearArea(conn, false, window, 0, 0, width, height)
-		message := "Brak polaczenia WFB"
-		xproto.ImageText8(conn, byte(len(message)), xproto.Drawable(window), gc, 32, 56, message)
-		conn.Sync()
-	}
-	draw()
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
 
-	for {
-		event, err := conn.WaitForEvent()
-		if err != nil {
-			if os.IsTimeout(err) {
-				continue
-			}
-			return
-		}
-		if _, ok := event.(xproto.ExposeEvent); ok {
-			draw()
-		}
+	// Temporary X11 unavailability never exits this process; display.Run
+	// keeps retrying internally until the context is cancelled.
+	if err := display.Run(ctx, opener, template, display.Options{}); err != nil {
+		log.Fatalf("display: %v", err)
 	}
 }