Files
beatglow/context.go

244 lines
5.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
contrast uint8
contrastTarget uint8
}
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.active {
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 layout.IsVisible() {
if handler, ok := layout.(app.RotaryInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch rotary input")
handler.HandleRotary(c, event.Delta)
return
}
}
}
case hardware.RotaryPressEvent:
for _, layout := range c.layouts {
if layout.IsVisible() {
if handler, ok := layout.(app.ButtonInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch button press")
handler.HandleButtonPress(c)
return
}
}
}
c.handleRotaryPress()
case hardware.RotaryLongPressEvent:
for _, layout := range c.layouts {
if layout.IsVisible() {
if handler, ok := layout.(app.ButtonInputHandler); ok {
log.WithField("layout", layout.String()).Debug("dispatch button long press")
handler.HandleButtonLongPress(c)
return
}
}
}
c.handleRotaryLongPress()
default:
log.Warn("unhandled input event")
}
}
func (c *controllerContext) handleRotaryPress() {
log := logrus.NewEntry(logrus.StandardLogger())
log.Debug("no handler for rotary press event, switching layouts")
var activeIndex int
for i, layout := range c.layouts {
if layout == c.active {
activeIndex = i
break
}
}
if activeIndex == 0 {
// We're in settings, shouldn't be able to get here since settings handle rotary press events
log.Debug("huh? how did we get here?")
return
}
nextIndex := activeIndex + 1
if nextIndex >= len(c.layouts) {
nextIndex = 1
}
c.Show(c.layouts[nextIndex])
}
func (c *controllerContext) handleRotaryLongPress() {
log := logrus.NewEntry(logrus.StandardLogger())
log.Debug("no handler for rotary press event, switching to settings")
c.Show(c.settingsLayout)
}
func (c *controllerContext) SetContrast(level uint8) {
c.contrastTarget = level
}
var _ app.Context = (*controllerContext)(nil)