249 lines
5.9 KiB
Go
249 lines
5.9 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)
|
|
}
|
|
}
|
|
}
|
|
case hardware.RotaryPressEvent:
|
|
var handled bool
|
|
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)
|
|
handled = true
|
|
}
|
|
}
|
|
}
|
|
if !handled {
|
|
c.handleRotaryPress()
|
|
}
|
|
case hardware.RotaryLongPressEvent:
|
|
var handled bool
|
|
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)
|
|
handled = true
|
|
}
|
|
}
|
|
}
|
|
if !handled {
|
|
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)
|