Xorg input driver (#53)

* add xf86 input driver.

* cleanup.

* rewrite to unix socket PoC.

* add input rebuild.

* lint & docs.

* add input driver struct.

* comments, lint, socket name from config.

* add touch events to webrtc.

* switch to uint32.

* misc update logging & linting,

* fix screen size

* set touchscreen as core pointer.

* add touch to ws control.

* SendCoreEvents.

* extract to own xinput folder.

* add debounce.

* switch pressure to uint8.

* check buffer size.

* send touch events with system init.

internal/desktop/manager.go

@@ -1,7 +1,6 @@
 package desktop
 
 import (
-	"fmt"
 	"sync"
 	"time"
 
@@ -10,26 +9,39 @@ import (
 	"github.com/rs/zerolog/log"
 
 	"github.com/demodesk/neko/internal/config"
+	"github.com/demodesk/neko/pkg/types"
 	"github.com/demodesk/neko/pkg/xevent"
+	"github.com/demodesk/neko/pkg/xinput"
 	"github.com/demodesk/neko/pkg/xorg"
 )
 
 var mu = sync.Mutex{}
 
 type DesktopManagerCtx struct {
-	logger   zerolog.Logger
-	wg       sync.WaitGroup
-	shutdown chan struct{}
-	emmiter  events.EventEmmiter
-	config   *config.Desktop
+	logger     zerolog.Logger
+	wg         sync.WaitGroup
+	shutdown   chan struct{}
+	emmiter    events.EventEmmiter
+	config     *config.Desktop
+	screenSize types.ScreenSize // cached screen size
+	input      xinput.Driver
 }
 
 func New(config *config.Desktop) *DesktopManagerCtx {
+	var input xinput.Driver
+	if config.UseInputDriver {
+		input = xinput.NewDriver(config.InputSocket)
+	} else {
+		input = xinput.NewDummy()
+	}
+
 	return &DesktopManagerCtx{
-		logger:   log.With().Str("module", "desktop").Logger(),
-		shutdown: make(chan struct{}),
-		emmiter:  events.New(),
-		config:   config,
+		logger:     log.With().Str("module", "desktop").Logger(),
+		shutdown:   make(chan struct{}),
+		emmiter:    events.New(),
+		config:     config,
+		screenSize: config.ScreenSize,
+		input:      input,
 	}
 }
 
@@ -40,10 +52,24 @@ func (manager *DesktopManagerCtx) Start() {
 
 	xorg.GetScreenConfigurations()
 
-	width, height, rate, err := xorg.ChangeScreenSize(manager.config.ScreenWidth, manager.config.ScreenHeight, manager.config.ScreenRate)
-	manager.logger.Err(err).
-		Str("screen_size", fmt.Sprintf("%dx%d@%d", width, height, rate)).
-		Msgf("setting initial screen size")
+	screenSize, err := xorg.ChangeScreenSize(manager.config.ScreenSize)
+	if err != nil {
+		manager.logger.Err(err).
+			Str("screen_size", screenSize.String()).
+			Msgf("unable to set initial screen size")
+	} else {
+		// cache screen size
+		manager.screenSize = screenSize
+		manager.logger.Info().
+			Str("screen_size", screenSize.String()).
+			Msgf("setting initial screen size")
+	}
+
+	err = manager.input.Connect()
+	if err != nil {
+		// TODO: fail silently to dummy driver?
+		manager.logger.Panic().Err(err).Msg("unable to connect to input driver")
+	}
 
 	xevent.Unminimize = manager.config.Unminimize
 	go xevent.EventLoop(manager.config.Display)
@@ -68,12 +94,15 @@ func (manager *DesktopManagerCtx) Start() {
 		ticker := time.NewTicker(1 * time.Second)
 		defer ticker.Stop()
 
+		const debounceDuration = 10 * time.Second
+
 		for {
 			select {
 			case <-manager.shutdown:
 				return
 			case <-ticker.C:
-				xorg.CheckKeys(time.Second * 10)
+				xorg.CheckKeys(debounceDuration)
+				manager.input.Debounce(debounceDuration)
 			}
 		}
 	}()

internal/desktop/xinput.go

@@ -0,0 +1,36 @@
+package desktop
+
+import "github.com/demodesk/neko/pkg/xinput"
+
+func (manager *DesktopManagerCtx) inputRelToAbs(x, y int) (int, int) {
+	return (x * xinput.AbsX) / manager.screenSize.Width, (y * xinput.AbsY) / manager.screenSize.Height
+}
+
+func (manager *DesktopManagerCtx) HasTouchSupport() bool {
+	// we assume now, that if the input driver is enabled, we have touch support
+	return manager.config.UseInputDriver
+}
+
+func (manager *DesktopManagerCtx) TouchBegin(touchId uint32, x, y int, pressure uint8) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	x, y = manager.inputRelToAbs(x, y)
+	return manager.input.TouchBegin(touchId, x, y, pressure)
+}
+
+func (manager *DesktopManagerCtx) TouchUpdate(touchId uint32, x, y int, pressure uint8) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	x, y = manager.inputRelToAbs(x, y)
+	return manager.input.TouchUpdate(touchId, x, y, pressure)
+}
+
+func (manager *DesktopManagerCtx) TouchEnd(touchId uint32, x, y int, pressure uint8) error {
+	mu.Lock()
+	defer mu.Unlock()
+
+	x, y = manager.inputRelToAbs(x, y)
+	return manager.input.TouchEnd(touchId, x, y, pressure)
+}

internal/desktop/xorg.go

@@ -85,7 +85,7 @@ func (manager *DesktopManagerCtx) ScreenConfigurations() []types.ScreenSize {
 	return configs
 }
 
-func (manager *DesktopManagerCtx) SetScreenSize(size types.ScreenSize) (types.ScreenSize, error) {
+func (manager *DesktopManagerCtx) SetScreenSize(screenSize types.ScreenSize) (types.ScreenSize, error) {
 	mu.Lock()
 	manager.emmiter.Emit("before_screen_size_change")
 
@@ -94,12 +94,13 @@ func (manager *DesktopManagerCtx) SetScreenSize(size types.ScreenSize) (types.Sc
 		mu.Unlock()
 	}()
 
-	w, h, r, err := xorg.ChangeScreenSize(size.Width, size.Height, size.Rate)
-	return types.ScreenSize{
-		Width:  w,
-		Height: h,
-		Rate:   r,
-	}, err
+	screenSize, err := xorg.ChangeScreenSize(screenSize)
+	if err == nil {
+		// cache the new screen size
+		manager.screenSize = screenSize
+	}
+
+	return screenSize, err
 }
 
 func (manager *DesktopManagerCtx) GetScreenSize() types.ScreenSize {