refactor: project structure, makefile

internal/screencapturer/wholescreencapturer.go

@@ -0,0 +1,241 @@
+// Copyright (c) 2025 Nikolai Papin
+//
+// This file is part of the Auto Attendance app that looks for
+// self-attend QR-codes during lectures and opens their URLs in your
+// browser.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+// the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+package screencapturer
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"image"
+	"image/png"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"git.weirdcat.su/weirdcat/auto-attendance/internal/config"
+	"git.weirdcat.su/weirdcat/auto-attendance/internal/constants"
+	"git.weirdcat.su/weirdcat/auto-attendance/internal/logger"
+	"github.com/kbinani/screenshot"
+	"go.uber.org/fx"
+)
+
+var (
+	ErrNotInitialized = errors.New("wholescreencapturer was not initialized")
+)
+
+type wholeScreenCapturer struct {
+	config *config.Config
+	log    *logger.Logger
+
+	displayIndex  int
+	displayBounds image.Rectangle
+	interval      int
+	bufferCount   int
+	tempDirectory string
+	initialized   bool
+	running       bool
+
+	files  []string
+	latest string
+	done   chan struct{}
+	sync.WaitGroup
+	mu sync.RWMutex
+}
+
+// Get implements ScreenCapturer.
+func (w *wholeScreenCapturer) Get() (filepath string, err error) {
+	w.mu.RLock()
+	defer w.mu.Unlock()
+    if !w.initialized {
+        return "", ErrNotInitialized
+    }
+    if w.latest == "" {
+        return "", errors.New("no screenshot captured yet")
+    }
+    return w.latest, nil
+}
+
+// Init implements ScreenCapturer.
+func (w *wholeScreenCapturer) Init() (err error) {
+
+	displayCount := screenshot.NumActiveDisplays()
+	w.displayIndex = w.config.Screenshot.ScreenIndex % displayCount
+	w.log.Debug("detected displays", "count", displayCount, "selected", w.displayIndex)
+
+	w.displayBounds = screenshot.GetDisplayBounds(w.displayIndex)
+	w.log.Debug(
+		"display bounds set",
+		"dx", w.displayBounds.Dx(),
+		"dy", w.displayBounds.Dy(),
+	)
+
+	w.interval = w.config.Screenshot.Interval
+	w.log.Debug("screenshot interval set", "interval", w.interval)
+
+	w.bufferCount = w.config.Screenshot.BufferCount
+	w.log.Debug("screenshot buffer count set", "count", w.bufferCount)
+
+	if w.tempDirectory, err = w.createTempDirectory(); err != nil {
+		w.log.Error("failed to create temporary directory", "error", err)
+		return err
+	}
+	w.log.Debug("temporary directory created", "path", w.tempDirectory)
+
+	w.files = make([]string, 0, w.bufferCount)
+	w.latest = ""
+	w.initialized = true
+	return nil
+}
+
+// Start implements ScreenCapturer.
+func (w *wholeScreenCapturer) Start() error {
+	if !w.initialized {
+		return ErrNotInitialized
+	}
+	if w.running {
+		w.log.Debug("wholescreencapturer is already running, ignoring start")
+		return nil
+	}
+	w.running = true
+	w.Go(func() {
+		w.captureLoop()
+	})
+	w.log.Debug("wholescreencapturer started")
+	return nil
+}
+
+// Stop implements ScreenCapturer.
+func (w *wholeScreenCapturer) Stop() error {
+	if !w.initialized {
+		return ErrNotInitialized
+	}
+	if !w.running {
+		w.log.Debug("wholescreencapturer is not running, ignoring stop")
+		return nil
+	}
+	w.log.Debug("stopping wholescreencapturer")
+	close(w.done)
+	w.Wait()
+	w.running = false
+	w.log.Debug("wholescreencapturer stopped")
+	return nil
+}
+
+func (w *wholeScreenCapturer) captureLoop() {
+	ticker := time.NewTicker(time.Duration(w.interval) * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-w.done:
+			w.log.Debug("capture loop stopped")
+			return
+		case <-ticker.C:
+			fp, err := w.captureAndSave()
+			if err != nil {
+				w.log.Error("screenshot capture failed", "error", err)
+				continue
+			}
+			w.addToBuffer(fp)
+		}
+	}
+}
+
+func (w *wholeScreenCapturer) captureAndSave() (string, error) {
+	img, err := screenshot.CaptureRect(w.displayBounds)
+	if err != nil {
+		w.log.Error("failed to capture screenshot", "error", err)
+		return "", err
+	}
+
+	now := time.Now().UnixMilli()
+	filename := fmt.Sprintf("%d.png", now)
+	filePath := filepath.Join(w.tempDirectory, filename)
+
+	file, err := os.Create(filePath)
+	if err != nil {
+		w.log.Error("failed to create screenshot file", "path", filePath, "error", err)
+		return "", err
+	}
+
+	defer file.Close()
+	err = png.Encode(file, img)
+	if err != nil {
+		w.log.Error("failed to encode image into file", "path", filePath, "error", err)
+		return "", err
+	}
+
+	w.log.Debug("Screenshot saved", "path", filePath)
+	return filePath, nil
+}
+
+func (w *wholeScreenCapturer) addToBuffer(fp string) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.files = append(w.files, fp)
+	w.latest = fp
+
+	if len(w.files) > w.bufferCount {
+		old := w.files[0]
+		if err := os.Remove(old); err != nil {
+			w.log.Warn("failed to remove old screenshot", "path", old, "error", err)
+		} else {
+			w.log.Debug("removed old screenshot", "path", old)
+		}
+		w.files = w.files[1:]
+	}
+}
+
+func (w *wholeScreenCapturer) createTempDirectory() (path string, err error) {
+	return os.MkdirTemp(w.config.Screenshot.Directory, constants.AppName+"-*")
+}
+
+func NewWholeScreenCapturer(
+	lc fx.Lifecycle, config *config.Config, log *logger.Logger,
+) ScreenCapturer {
+	capturer := &wholeScreenCapturer{
+		config: config,
+		log:    log,
+		done:   make(chan struct{}),
+	}
+	lc.Append(fx.StopHook(func(ctx context.Context) error {
+		if !capturer.initialized {
+			log.Debug("wholescreencapturer not initialized, nothing to do")
+			return nil
+		}
+
+		log.Debug("stopping wholescreencapturer")
+
+		err := capturer.Stop()
+		if err != nil {
+			log.Error("failed to stop wholescreencapturer gracefully")
+			return err
+		}
+
+		err = os.RemoveAll(capturer.tempDirectory)
+		if err != nil {
+			log.Error("failed to remove temp directory")
+			return err
+		}
+		return nil
+	}))
+	return capturer
+}