367 lines
9.6 KiB
Go
367 lines
9.6 KiB
Go
package browsing
|
|
|
|
import (
|
|
"log"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"github.com/dweymouth/supersonic/backend"
|
|
"github.com/dweymouth/supersonic/backend/mediaprovider"
|
|
"github.com/dweymouth/supersonic/sharedutil"
|
|
"github.com/dweymouth/supersonic/ui/controller"
|
|
"github.com/dweymouth/supersonic/ui/layouts"
|
|
myTheme "github.com/dweymouth/supersonic/ui/theme"
|
|
"github.com/dweymouth/supersonic/ui/widgets"
|
|
|
|
"fyne.io/fyne/v2"
|
|
"fyne.io/fyne/v2/container"
|
|
"fyne.io/fyne/v2/lang"
|
|
"fyne.io/fyne/v2/layout"
|
|
"fyne.io/fyne/v2/theme"
|
|
"fyne.io/fyne/v2/widget"
|
|
)
|
|
|
|
var _ fyne.Widget = (*ArtistPage)(nil)
|
|
|
|
type RadiosPage struct {
|
|
widget.BaseWidget
|
|
|
|
contr *controller.Controller
|
|
rp mediaprovider.RadioProvider
|
|
pm *backend.PlaybackManager
|
|
radios []*mediaprovider.RadioStation
|
|
list *RadioList
|
|
|
|
nowPlayingID string
|
|
|
|
titleDisp *widget.RichText
|
|
noRadiosMsg fyne.CanvasObject
|
|
container *fyne.Container
|
|
searcher *widgets.SearchEntry
|
|
}
|
|
|
|
func NewRadiosPage(contr *controller.Controller, rp mediaprovider.RadioProvider, pm *backend.PlaybackManager) *RadiosPage {
|
|
return newRadiosPage(contr, rp, pm, "", 0)
|
|
}
|
|
|
|
func newRadiosPage(contr *controller.Controller, rp mediaprovider.RadioProvider, pm *backend.PlaybackManager, searchText string, scrollPos float32) *RadiosPage {
|
|
a := &RadiosPage{
|
|
contr: contr,
|
|
rp: rp,
|
|
pm: pm,
|
|
titleDisp: widget.NewRichTextWithText(lang.L("Internet Radio Stations")),
|
|
}
|
|
a.ExtendBaseWidget(a)
|
|
a.titleDisp.Segments[0].(*widget.TextSegment).Style.SizeName = theme.SizeNameHeadingText
|
|
a.list = NewRadioList(&a.nowPlayingID)
|
|
a.list.OnPlay = a.onPlay
|
|
a.list.OnQueue = a.onQueue
|
|
a.searcher = widgets.NewSearchEntry()
|
|
a.searcher.PlaceHolder = lang.L("Search page")
|
|
a.searcher.OnSearched = a.onSearched
|
|
a.searcher.Entry.Text = searchText
|
|
|
|
a.noRadiosMsg = container.NewCenter(widgets.NewInfoMessage(
|
|
lang.L("No radio stations available"),
|
|
lang.L("Configure your music server to add radio stations"),
|
|
))
|
|
a.noRadiosMsg.Hide()
|
|
|
|
a.buildContainer()
|
|
go a.load(searchText != "", scrollPos)
|
|
return a
|
|
}
|
|
|
|
// should be called asynchronously
|
|
func (a *RadiosPage) load(searchOnLoad bool, scrollPos float32) {
|
|
radios, err := a.rp.GetRadioStations()
|
|
if err != nil {
|
|
log.Printf("error loading radios: %v", err.Error())
|
|
}
|
|
|
|
fyne.Do(func() {
|
|
if len(radios) == 0 {
|
|
a.noRadiosMsg.Show()
|
|
} else {
|
|
a.noRadiosMsg.Hide()
|
|
}
|
|
a.radios = radios
|
|
if searchOnLoad {
|
|
a.onSearched(a.searcher.Entry.Text)
|
|
if scrollPos != 0 {
|
|
a.list.list.ScrollToOffset(scrollPos)
|
|
}
|
|
} else {
|
|
a.list.SetRadios(a.radios)
|
|
if scrollPos != 0 {
|
|
a.list.list.ScrollToOffset(scrollPos)
|
|
return
|
|
}
|
|
a.list.Refresh()
|
|
}
|
|
})
|
|
}
|
|
|
|
func (a *RadiosPage) onPlay(station *mediaprovider.RadioStation) {
|
|
a.pm.PlayRadioStation(station)
|
|
}
|
|
|
|
func (a *RadiosPage) onQueue(station *mediaprovider.RadioStation, next bool) {
|
|
queueMode := backend.Append
|
|
if next {
|
|
queueMode = backend.InsertNext
|
|
}
|
|
a.pm.LoadRadioStation(station, queueMode)
|
|
}
|
|
|
|
func (a *RadiosPage) onSearched(query string) {
|
|
// since the radios list is returned in full non-paginated, we will do our own
|
|
// simple search based on the radio name, rather than calling a server API
|
|
if query == "" {
|
|
a.list.SetRadios(a.radios)
|
|
} else {
|
|
query = strings.ToLower(query)
|
|
result := sharedutil.FilterSlice(a.radios, func(x *mediaprovider.RadioStation) bool {
|
|
return strings.Contains(strings.ToLower(x.Name), query)
|
|
})
|
|
a.list.SetRadios(result)
|
|
}
|
|
a.list.list.ScrollTo(0)
|
|
}
|
|
|
|
var _ Searchable = (*RadiosPage)(nil)
|
|
|
|
func (a *RadiosPage) SearchWidget() fyne.Focusable {
|
|
return a.searcher
|
|
}
|
|
|
|
var _ Scrollable = (*RadiosPage)(nil)
|
|
|
|
func (a *RadiosPage) Scroll(amount float32) {
|
|
a.list.list.ScrollToOffset(a.list.list.GetScrollOffset() + amount)
|
|
}
|
|
|
|
var _ CanShowNowPlaying = (*RadiosPage)(nil)
|
|
|
|
func (a *RadiosPage) OnSongChange(playing mediaprovider.MediaItem, _ *mediaprovider.Track) {
|
|
if playing != nil {
|
|
a.nowPlayingID = playing.Metadata().ID
|
|
} else {
|
|
a.nowPlayingID = ""
|
|
}
|
|
a.list.Refresh()
|
|
}
|
|
|
|
func (a *RadiosPage) Route() controller.Route {
|
|
return controller.RadiosRoute()
|
|
}
|
|
|
|
func (a *RadiosPage) Reload() {
|
|
go a.load(false, 0)
|
|
}
|
|
|
|
func (a *RadiosPage) Save() SavedPage {
|
|
return &savedrRadiosPage{
|
|
contr: a.contr,
|
|
rp: a.rp,
|
|
pm: a.pm,
|
|
searchText: a.searcher.Entry.Text,
|
|
scrollPos: a.list.list.GetScrollOffset(),
|
|
}
|
|
}
|
|
|
|
type savedrRadiosPage struct {
|
|
contr *controller.Controller
|
|
rp mediaprovider.RadioProvider
|
|
pm *backend.PlaybackManager
|
|
searchText string
|
|
scrollPos float32
|
|
}
|
|
|
|
func (s *savedrRadiosPage) Restore() Page {
|
|
return newRadiosPage(s.contr, s.rp, s.pm, s.searchText, s.scrollPos)
|
|
}
|
|
|
|
func (a *RadiosPage) buildContainer() {
|
|
searchVbox := container.NewVBox(layout.NewSpacer(), a.searcher, layout.NewSpacer())
|
|
a.container = container.New(&layout.CustomPaddedLayout{LeftPadding: 15, RightPadding: 15, TopPadding: 5, BottomPadding: 15},
|
|
container.NewBorder(
|
|
container.New(&layout.CustomPaddedLayout{LeftPadding: -5},
|
|
container.NewHBox(a.titleDisp, layout.NewSpacer(), searchVbox)),
|
|
nil, nil, nil,
|
|
container.NewStack(a.noRadiosMsg, a.list)),
|
|
)
|
|
}
|
|
|
|
func (a *RadiosPage) CreateRenderer() fyne.WidgetRenderer {
|
|
return widget.NewSimpleRenderer(a.container)
|
|
}
|
|
|
|
type RadioList struct {
|
|
widget.BaseWidget
|
|
|
|
OnPlay func(*mediaprovider.RadioStation)
|
|
OnQueue func(r *mediaprovider.RadioStation, next bool)
|
|
|
|
radios []*mediaprovider.RadioStation
|
|
selected *RadioListRow
|
|
|
|
columnsLayout *layouts.ColumnsLayout
|
|
hdr *widgets.ListHeader
|
|
list *widgets.FocusList
|
|
container *fyne.Container
|
|
playingIcon fyne.CanvasObject
|
|
menu *widget.PopUpMenu
|
|
}
|
|
|
|
type RadioListRow struct {
|
|
widgets.FocusListRowBase
|
|
|
|
Item *mediaprovider.RadioStation
|
|
IsPlaying bool
|
|
OnTappedSecondary func(*fyne.PointEvent)
|
|
|
|
nameLabel *widget.RichText
|
|
homePageLink *widget.Hyperlink
|
|
}
|
|
|
|
func NewRadioListRow(layout *layouts.ColumnsLayout) *RadioListRow {
|
|
a := &RadioListRow{
|
|
nameLabel: widget.NewRichTextWithText(""),
|
|
homePageLink: widget.NewHyperlink("", nil),
|
|
}
|
|
a.ExtendBaseWidget(a)
|
|
a.nameLabel.Truncation = fyne.TextTruncateEllipsis
|
|
a.homePageLink.Truncation = fyne.TextTruncateEllipsis
|
|
a.Content = container.New(layout, a.nameLabel, a.homePageLink)
|
|
return a
|
|
}
|
|
|
|
func (a *RadioListRow) TappedSecondary(e *fyne.PointEvent) {
|
|
if a.OnTappedSecondary != nil {
|
|
a.OnTappedSecondary(e)
|
|
}
|
|
}
|
|
|
|
func NewRadioList(nowPlayingIDPtr *string) *RadioList {
|
|
a := &RadioList{
|
|
columnsLayout: layouts.NewColumnsLayout([]float32{-1, -1}),
|
|
}
|
|
playIcon := theme.NewThemedResource(theme.MediaPlayIcon())
|
|
playIcon.ColorName = theme.ColorNamePrimary
|
|
a.playingIcon = container.NewCenter(widget.NewIcon(playIcon))
|
|
a.ExtendBaseWidget(a)
|
|
a.hdr = widgets.NewListHeader([]widgets.ListColumn{
|
|
{Text: lang.L("Name"), Alignment: fyne.TextAlignLeading, CanToggleVisible: false},
|
|
{Text: lang.L("Home Page"), Alignment: fyne.TextAlignLeading, CanToggleVisible: false},
|
|
},
|
|
a.columnsLayout)
|
|
a.hdr.DisableSorting = true
|
|
a.list = widgets.NewFocusList(
|
|
func() int { return len(a.radios) },
|
|
func() fyne.CanvasObject {
|
|
r := NewRadioListRow(a.columnsLayout)
|
|
r.OnTapped = func() {
|
|
r.Selected = true
|
|
if a.selected != nil {
|
|
// unselect old row
|
|
a.selected.Selected = false
|
|
a.selected.Refresh()
|
|
}
|
|
a.selected = r
|
|
r.Refresh()
|
|
}
|
|
r.OnDoubleTapped = func() { a.onPlayRadio(r.Item) }
|
|
r.OnTappedSecondary = func(e *fyne.PointEvent) {
|
|
r.OnTapped() // handle selection
|
|
a.showMenu(e.AbsolutePosition)
|
|
}
|
|
r.OnFocusNeighbor = func(up bool) {
|
|
a.list.FocusNeighbor(r.ItemID(), up)
|
|
}
|
|
return r
|
|
},
|
|
func(id widget.ListItemID, item fyne.CanvasObject) {
|
|
row := item.(*RadioListRow)
|
|
changed := false
|
|
if row.Item != a.radios[id] {
|
|
row.EnsureUnfocused()
|
|
row.ListItemID = id
|
|
row.Item = a.radios[id]
|
|
row.nameLabel.Segments[0].(*widget.TextSegment).Text = row.Item.Name
|
|
row.homePageLink.Text = row.Item.HomePageURL
|
|
if u, err := url.Parse(row.Item.HomePageURL); err == nil {
|
|
row.homePageLink.URL = u
|
|
}
|
|
changed = true
|
|
}
|
|
isPlaying := *nowPlayingIDPtr == row.Item.ID
|
|
if row.IsPlaying != isPlaying {
|
|
row.IsPlaying = isPlaying
|
|
row.nameLabel.Segments[0].(*widget.TextSegment).Style.TextStyle.Bold = isPlaying
|
|
if isPlaying {
|
|
row.Content.(*fyne.Container).Objects[0] = container.NewBorder(nil, nil, a.playingIcon, nil,
|
|
container.New(layout.NewCustomPaddedLayout(0, 0, -5, 0), row.nameLabel))
|
|
} else {
|
|
row.Content.(*fyne.Container).Objects[0] = row.nameLabel
|
|
}
|
|
changed = true
|
|
}
|
|
if changed {
|
|
row.Refresh()
|
|
}
|
|
},
|
|
)
|
|
a.container = container.NewBorder(a.hdr, nil, nil, nil, a.list)
|
|
return a
|
|
}
|
|
|
|
func (a *RadioList) showMenu(pos fyne.Position) {
|
|
if a.menu == nil {
|
|
play := fyne.NewMenuItem(lang.L("Play"), func() {
|
|
if a.OnPlay != nil {
|
|
a.OnPlay(a.selected.Item)
|
|
}
|
|
})
|
|
play.Icon = theme.MediaPlayIcon()
|
|
|
|
playNext := fyne.NewMenuItem(lang.L("Play next"), func() {
|
|
if a.OnQueue != nil {
|
|
a.OnQueue(a.selected.Item, true)
|
|
}
|
|
})
|
|
playNext.Icon = myTheme.PlayNextIcon
|
|
|
|
append := fyne.NewMenuItem(lang.L("Add to queue"), func() {
|
|
if a.OnQueue != nil {
|
|
a.OnQueue(a.selected.Item, false)
|
|
}
|
|
})
|
|
append.Icon = theme.ContentAddIcon()
|
|
|
|
a.menu = widget.NewPopUpMenu(fyne.NewMenu("",
|
|
play,
|
|
playNext,
|
|
append,
|
|
),
|
|
fyne.CurrentApp().Driver().CanvasForObject(a),
|
|
)
|
|
}
|
|
a.menu.ShowAtPosition(pos)
|
|
}
|
|
|
|
func (g *RadioList) SetRadios(radios []*mediaprovider.RadioStation) {
|
|
g.radios = radios
|
|
g.Refresh()
|
|
}
|
|
|
|
func (a *RadioList) onPlayRadio(item *mediaprovider.RadioStation) {
|
|
if a.OnPlay != nil {
|
|
a.OnPlay(item)
|
|
}
|
|
}
|
|
|
|
func (a *RadioList) CreateRenderer() fyne.WidgetRenderer {
|
|
return widget.NewSimpleRenderer(a.container)
|
|
}
|