Files
beatglow/context.go
T
2026-10-29 17:29:54 +01:00

196 lines
4.8 KiB
Go

package beatglow
import (
"image"
"github.com/sirupsen/logrus"
"github.com/BeatGlow/audio"
"github.com/BeatGlow/display"
"github.com/BeatGlow/beatglow/app"
"github.com/BeatGlow/beatglow/config"
"github.com/BeatGlow/beatglow/hardware"
"github.com/BeatGlow/beatglow/player"
"github.com/BeatGlow/beatglow/sound"
)
type controllerContext struct {
display display.Display
player player.Player
status *player.Status
track *player.Track
audio sound.Source
layouts []app.Layout
active app.Layout
previous app.Layout
settingsLayout app.Layout
settings *config.Settings
}
func (c controllerContext) Display() display.Display {
return c.display
}
func (c controllerContext) Player() player.Player {
return c.player
}
func (c controllerContext) Track() *player.Track {
return c.track
}
func (c controllerContext) TrackImage(track *player.Track) (image.Image, bool) {
if a, ok := c.player.(player.AlbumArt); ok {
return a.AlbumArt(track)
}
return nil, false
}
func (c *controllerContext) teardown(log *logrus.Entry) {
if c.player != nil {
log.Debug("stopping player")
if err := c.player.Halt(); err != nil {
log.WithError(err).Warn("stopping player failed")
}
c.player = nil
}
if c.display != nil {
log.Debug("stopping display")
if err := c.display.Close(); err != nil {
log.WithError(err).Warn("stopping display failed")
}
c.display = nil
}
if c.settings != nil {
log.Debug("saving user settings")
if err := config.SaveUserSettings(c.settings.Path, c.settings); err != nil {
log.WithError(err).Warn("saving user settings failed")
}
}
}
func (c *controllerContext) addSettings(layout app.Layout) {
c.settingsLayout = layout
c.addLayout(layout)
}
type buttonLongPressHandler interface {
OnButtonLongPress(action func(app.Context))
}
func (c *controllerContext) addLayout(layout app.Layout) {
c.layouts = append(c.layouts, layout)
if layout != c.settingsLayout {
if handler, ok := layout.(buttonLongPressHandler); ok {
handler.OnButtonLongPress(func(_ app.Context) {
c.Show(c.settingsLayout)
})
}
}
}
func (c *controllerContext) Show(layout app.Layout) {
log := logrus.NewEntry(logrus.StandardLogger())
if layout == nil {
if c.previous != nil {
log.WithField("layout", c.previous.String()).Debug("switching to previous layout")
c.Show(c.previous)
return
}
log.WithField("layout", c.layouts[0].String()).Debug("switching to default layout")
for _, layout := range c.layouts {
if /* logrus.GetLevel() >= logrus.DebugLevel || */ layout != c.settingsLayout {
c.Show(layout)
return
}
}
return
}
for _, other := range c.layouts {
if other == layout {
if layout != c.settingsLayout {
// Only store a "previous" screen if the active screen isn't the settings.
c.previous, c.active = c.active, layout
}
log.WithField("layout", layout).Debug("show layout")
layout.Show(c)
} else {
log.WithField("other", layout).Debug("hide layout")
other.Hide(c)
}
}
}
func (c *controllerContext) Settings() *config.Settings {
if c.settings == nil {
c.settings = config.LoadUserSettings("")
}
return c.settings
}
func (c *controllerContext) handleStatus(status *player.Status) {
c.status = status
for _, layout := range c.layouts {
if handler, ok := layout.(app.StatusChangeHandler); ok {
handler.StatusChanged(c, status)
}
}
}
func (c *controllerContext) handleTrack(track *player.Track) {
if c.track.Eq(track) {
return
}
c.track = track
for _, layout := range c.layouts {
if handler, ok := layout.(app.TrackChangeHandler); ok {
handler.TrackChanged(c, track)
}
}
}
func (c *controllerContext) handleAudio(buffer audio.Buffer[float64]) {
for _, layout := range c.layouts {
if handler, ok := layout.(app.BufferProcessor); ok {
handler.ProcessBuffer(buffer)
}
}
}
func (c *controllerContext) handleInput(event hardware.InputEvent) {
log := logrus.NewEntry(logrus.StandardLogger())
switch event := event.(type) {
case hardware.RotaryEvent:
for _, layout := range c.layouts {
if handler, ok := layout.(app.RotaryInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch rotary input")
handler.HandleRotary(c, event.Delta)
}
}
case hardware.RotaryPressEvent:
for _, layout := range c.layouts {
if handler, ok := layout.(app.ButtonInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch button press")
handler.HandleButtonPress(c)
}
}
case hardware.RotaryLongPressEvent:
for _, layout := range c.layouts {
if handler, ok := layout.(app.ButtonInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch button long press")
handler.HandleButtonLongPress(c)
}
}
default:
log.Warn("unhandled input event")
}
}
var _ app.Context = (*controllerContext)(nil)