in progress MediaItem refactor - does not build

backend/mediaprovider/model.go

@@ -139,6 +139,32 @@ type SavedPlayQueue struct {
 	TimePos  int // seconds
 }
 
+type RadioStation struct {
+	Name        string
+	ID          string
+	HomePageURL string
+	StreamURL   string
+}
+
+type MediaItem interface {
+	MediaItemName() string
+	MediaItemID() string
+	Copy() MediaItem
+}
+
+func (t Track) MediaItemName() string { return t.Name }
+func (t Track) MediaItemID() string   { return t.ID }
+func (t *Track) Copy() MediaItem {
+	new := *t
+	return &new
+}
+
+func (r RadioStation) MediaItemName() string { return r.Name }
+func (r RadioStation) MediaItemID() string   { return r.ID }
+func (r *RadioStation) Copy() MediaItem {
+	return r // no need to copy since RadioStations are immutable
+}
+
 type ContentType int
 
 const (

backend/mpmedia_mac.go

@@ -69,7 +69,7 @@ func InitMPMediaHandler(playbackManager *PlaybackManager, artURLLookup func(trac
 	mpMediaEventRecipient = mp
 	C.register_os_remote_commands()
 
-	mp.playbackManager.OnSongChange(func(track, _ *mediaprovider.Track) {
+	mp.playbackManager.OnSongChange(func(track *NowPlayingMetadata, _ *mediaprovider.Track) {
 		// Asynchronously because artwork fetching can take time
 		go mp.updateMetadata(track)
 	})
@@ -95,17 +95,17 @@ func InitMPMediaHandler(playbackManager *PlaybackManager, artURLLookup func(trac
 	return nil
 }
 
-func (mp *MPMediaHandler) updateMetadata(track *mediaprovider.Track) {
+func (mp *MPMediaHandler) updateMetadata(meta *NowPlayingMetadata) {
 	var title, artist, artURL string
 	var duration int
-	if track != nil && track.ID != "" {
+	if meta != nil && meta.ID != "" {
+		title = meta.Title
 		var err error
-		if artURL, err = mp.artURLLookup(track.CoverArtID); err != nil {
+		if artURL, err = mp.artURLLookup(meta.CoverArtID); err != nil {
 			log.Printf("error fetching art url: %s", err.Error())
 		}
-		title = track.Name
+		artist = strings.Join(meta.Artists, ", ")
-		artist = strings.Join(track.ArtistNames, ", ")
+		duration = meta.Duration
-		duration = track.Duration
 	}
 
 	cTitle := C.CString(title)

backend/mpris.go

@@ -58,7 +58,7 @@ func NewMPRISHandler(playerName string, pm *PlaybackManager) *MPRISHandler {
 			m.evt.Player.OnSeek(pos)
 		}
 	})
-	pm.OnSongChange(func(tr, _ *mediaprovider.Track) {
+	pm.OnSongChange(func(tr *NowPlayingMetadata, _ *mediaprovider.Track) {
 		if tr == nil {
 			m.curTrackPath = ""
 		} else {
@@ -252,8 +252,10 @@ func (m *MPRISHandler) Metadata() (types.Metadata, error) {
 	}
 	status := m.pm.PlayerStatus()
 	var tr mediaprovider.Track
-	if np := m.pm.NowPlaying(); np != nil && status.State != player.Stopped {
+	if np := m.pm.NowPlayingMediaItem(); np != nil && status.State != player.Stopped {
-		tr = *np
+		if track, ok := np.(*mediaprovider.Track); ok {
+			tr = *track
+		}
 	}
 	var artURL string
 	if tr.ID != "" && m.ArtURLLookup != nil {

backend/playbackengine.go

@@ -48,7 +48,7 @@ type playbackEngine struct {
 	latestTrackPosition float64 // cleared by checkScrobble
 	callbacksDisabled   bool
 
-	playQueue     []*mediaprovider.Track
+	playQueue     []mediaprovider.MediaItem
 	nowPlayingIdx int
 	wasStopped    bool // true iff player was stopped before handleOnTrackChange invocation
 	loopMode      LoopMode
@@ -60,7 +60,7 @@ type playbackEngine struct {
 	replayGainCfg ReplayGainConfig
 
 	// registered callbacks
-	onSongChange     []func(nowPlaying, justScrobbledIfAny *mediaprovider.Track)
+	onSongChange     []func(nowPlaying *NowPlayingMetadata, justScrobbledIfAny *mediaprovider.Track)
 	onPlayTimeUpdate []func(float64, float64, bool)
 	onLoopModeChange []func(LoopMode)
 	onVolumeChange   []func(int)
@@ -123,7 +123,33 @@ func (p *playbackEngine) PlayTrackAt(idx int) error {
 }
 
 // Gets the curently playing song, if any.
-func (p *playbackEngine) NowPlaying() *mediaprovider.Track {
+func (p *playbackEngine) NowPlaying() *NowPlayingMetadata {
+	if p.nowPlayingIdx < 0 || len(p.playQueue) == 0 || p.player.GetStatus().State == player.Stopped {
+		return nil
+	}
+	item := p.playQueue[p.nowPlayingIdx]
+	if tr, ok := item.(*mediaprovider.Track); ok {
+		return &NowPlayingMetadata{
+			Type:      MediaTypeTrack,
+			ID:        tr.ID,
+			Title:     tr.Name,
+			Artists:   tr.ArtistNames,
+			ArtistIDs: tr.ArtistIDs,
+			Album:     tr.Album,
+			AlbumID:   tr.AlbumID,
+			Duration:  float64(tr.Duration),
+		}
+	}
+	return &NowPlayingMetadata{
+		Type:     MediaTypeRadioStation,
+		ID:       item.MediaItemID(),
+		Title:    item.MediaItemName(),
+		Duration: 0.0,
+	}
+}
+
+// Gets the curently playing song, if any.
+func (p *playbackEngine) NowPlayingMediaItem() mediaprovider.MediaItem {
 	if p.nowPlayingIdx < 0 || len(p.playQueue) == 0 || p.player.GetStatus().State == player.Stopped {
 		return nil
 	}
@@ -216,7 +242,7 @@ func (p *playbackEngine) LoadTracks(tracks []*mediaprovider.Track, insertQueueMo
 	}
 	needToSetNext := len(tracks) > 0 && (insertQueueMode == InsertNext || (insertQueueMode == Append && p.nowPlayingIdx == len(p.playQueue)-1))
 
-	newTracks := p.deepCopyTrackSlice(tracks)
+	newTracks := p.copyTrackSliceToMediaItemSlice(tracks)
 	if shuffle {
 		rand.Shuffle(len(newTracks), func(i, j int) { newTracks[i], newTracks[j] = newTracks[j], newTracks[i] })
 	}
@@ -247,23 +273,27 @@ func (p *playbackEngine) StopAndClearPlayQueue() {
 	}
 }
 
-func (p *playbackEngine) GetPlayQueue() []*mediaprovider.Track {
+func (p *playbackEngine) GetPlayQueue() []mediaprovider.MediaItem {
 	return p.deepCopyTrackSlice(p.playQueue)
 }
 
 // Any time the user changes the favorite status of a track elsewhere in the app,
 // this should be called to ensure the in-memory track model is updated.
 func (p *playbackEngine) OnTrackFavoriteStatusChanged(id string, fav bool) {
-	if tr := sharedutil.FindTrackByID(id, p.playQueue); tr != nil {
+	if item := sharedutil.FindMediaItemByID(id, p.playQueue); item != nil {
-		tr.Favorite = fav
+		if tr, ok := item.(*mediaprovider.Track); ok {
+			tr.Favorite = fav
+		}
 	}
 }
 
 // Any time the user changes the rating of a track elsewhere in the app,
 // this should be called to ensure the in-memory track model is updated.
 func (p *playbackEngine) OnTrackRatingChanged(id string, rating int) {
-	if tr := sharedutil.FindTrackByID(id, p.playQueue); tr != nil {
+	if item := sharedutil.FindMediaItemByID(id, p.playQueue); item != nil {
-		tr.Rating = rating
+		if tr, ok := item.(*mediaprovider.Track); ok {
+			tr.Rating = rating
+		}
 	}
 }
 
@@ -271,12 +301,12 @@ func (p *playbackEngine) OnTrackRatingChanged(id string, rating int) {
 // Does not stop playback if the currently playing track is in the new queue,
 // but updates the now playing index to point to the first instance of the track in the new queue.
 func (p *playbackEngine) UpdatePlayQueue(tracks []*mediaprovider.Track) error {
-	newQueue := p.deepCopyTrackSlice(tracks)
+	newQueue := p.copyTrackSliceToMediaItemSlice(tracks)
 	newNowPlayingIdx := -1
 	if p.nowPlayingIdx >= 0 {
-		nowPlayingID := p.playQueue[p.nowPlayingIdx].ID
+		nowPlayingID := p.playQueue[p.nowPlayingIdx].MediaItemID()
 		for i, tr := range newQueue {
-			if tr.ID == nowPlayingID {
+			if tr.MediaItemID() == nowPlayingID {
 				newNowPlayingIdx = i
 				break
 			}
@@ -298,14 +328,14 @@ func (p *playbackEngine) UpdatePlayQueue(tracks []*mediaprovider.Track) error {
 }
 
 func (p *playbackEngine) RemoveTracksFromQueue(trackIDs []string) {
-	newQueue := make([]*mediaprovider.Track, 0, len(p.playQueue)-len(trackIDs))
+	newQueue := make([]mediaprovider.MediaItem, 0, len(p.playQueue)-len(trackIDs))
 	idSet := sharedutil.ToSet(trackIDs)
 	isPlayingTrackRemoved := false
 	isNextPlayingTrackremoved := false
 	nowPlaying := p.NowPlayingIndex()
 	newNowPlaying := nowPlaying
 	for i, tr := range p.playQueue {
-		if _, ok := idSet[tr.ID]; ok {
+		if _, ok := idSet[tr.MediaItemID()]; ok {
 			if i < nowPlaying {
 				// if removing a track earlier than the currently playing one (if any),
 				// decrement new now playing index by one to account for new position in queue
@@ -396,7 +426,10 @@ func (p *playbackEngine) handleOnTrackChange() {
 		}
 	}
 	p.wasStopped = false
-	p.curTrackTime = float64(p.playQueue[p.nowPlayingIdx].Duration)
+	p.curTrackTime = 0
+	if tr, ok := p.playQueue[p.nowPlayingIdx].(*mediaprovider.Track); ok {
+		p.curTrackTime = float64(tr.Duration)
+	}
 	p.sendNowPlayingScrobble() // Must come before invokeOnChangeCallbacks b/c track may immediately be scrobbled
 	p.invokeOnSongChangeCallbacks()
 	p.doUpdateTimePos(false)
@@ -460,7 +493,12 @@ func (p *playbackEngine) setTrack(idx int, next bool) error {
 		url := ""
 		if idx >= 0 {
 			var err error
-			url, err = p.sm.Server.GetStreamURL(p.playQueue[idx].ID, p.transcodeCfg.ForceRawFile)
+			item := p.playQueue[idx]
+			if tr, ok := item.(*mediaprovider.Track); ok {
+				url, err = p.sm.Server.GetStreamURL(tr.ID, p.transcodeCfg.ForceRawFile)
+			} else {
+				url = item.(*mediaprovider.RadioStation).StreamURL
+			}
 			if err != nil {
 				return err
 			}
@@ -472,7 +510,10 @@ func (p *playbackEngine) setTrack(idx int, next bool) error {
 	} else if trP, ok := p.player.(player.TrackPlayer); ok {
 		var track *mediaprovider.Track
 		if idx >= 0 {
-			track = p.playQueue[idx]
+			track, ok = p.playQueue[idx].(*mediaprovider.Track)
+			if !ok {
+				return errors.New("cannot play non-Track media item with TrackPlayer")
+			}
 		}
 		if next {
 			return trP.SetNextTrack(track)
@@ -491,6 +532,11 @@ func (p *playbackEngine) checkScrobble() {
 	if !p.scrobbleCfg.Enabled || len(p.playQueue) == 0 || p.nowPlayingIdx < 0 {
 		return
 	}
+	track, ok := p.playQueue[p.nowPlayingIdx].(*mediaprovider.Track)
+	if !ok {
+		return // radio stations are not scrobbled
+	}
+
 	playDur := p.playTimeStopwatch.Elapsed()
 	if playDur.Seconds() < 0.1 || p.curTrackTime < 0.1 {
 		return
@@ -499,7 +545,6 @@ func (p *playbackEngine) checkScrobble() {
 	timeThresholdMet := p.scrobbleCfg.ThresholdTimeSeconds >= 0 &&
 		playDur.Seconds() >= float64(p.scrobbleCfg.ThresholdTimeSeconds)
 
-	track := p.playQueue[p.nowPlayingIdx]
 	var submission bool
 	server := p.sm.Server
 	if server.ClientDecidesScrobble() && (timeThresholdMet || pcnt >= float64(p.scrobbleCfg.ThresholdPercent)) {
@@ -516,7 +561,11 @@ func (p *playbackEngine) sendNowPlayingScrobble() {
 	if !p.scrobbleCfg.Enabled || len(p.playQueue) == 0 || p.nowPlayingIdx < 0 {
 		return
 	}
-	track := p.playQueue[p.nowPlayingIdx]
+	track, ok := p.playQueue[p.nowPlayingIdx].(*mediaprovider.Track)
+	if !ok {
+		return // radio stations are not scrobbled
+	}
+
 	server := p.sm.Server
 	if !server.ClientDecidesScrobble() {
 		// server will count track as scrobbled as soon as it starts playing
@@ -528,11 +577,18 @@ func (p *playbackEngine) sendNowPlayingScrobble() {
 
 // creates a deep copy of the track info so that we can maintain our own state
 // (play count increases, favorite, and rating) without messing up other views' track models
-func (p *playbackEngine) deepCopyTrackSlice(tracks []*mediaprovider.Track) []*mediaprovider.Track {
+func (p *playbackEngine) deepCopyTrackSlice(tracks []mediaprovider.MediaItem) []mediaprovider.MediaItem {
-	newTracks := make([]*mediaprovider.Track, len(tracks))
+	newTracks := make([]mediaprovider.MediaItem, len(tracks))
 	for i, tr := range tracks {
-		copy := *tr
+		newTracks[i] = tr.Copy()
-		newTracks[i] = &copy
+	}
+	return newTracks
+}
+
+func (p *playbackEngine) copyTrackSliceToMediaItemSlice(tracks []*mediaprovider.Track) []mediaprovider.MediaItem {
+	newTracks := make([]mediaprovider.MediaItem, len(tracks))
+	for i, tr := range tracks {
+		newTracks[i] = tr.Copy()
 	}
 	return newTracks
 }

backend/playbackmanager.go

@@ -15,6 +15,25 @@ type PlaybackManager struct {
 	engine *playbackEngine
 }
 
+type MediaType int
+
+const (
+	MediaTypeTrack MediaType = iota
+	MediaTypeRadioStation
+)
+
+type NowPlayingMetadata struct {
+	Type       MediaType
+	ID         string
+	Title      string
+	Artists    []string
+	ArtistIDs  []string
+	Album      string
+	AlbumID    string
+	CoverArtID string
+	Duration   int
+}
+
 func NewPlaybackManager(
 	ctx context.Context,
 	s *ServerManager,
@@ -46,16 +65,20 @@ func (p *PlaybackManager) DisableCallbacks() {
 }
 
 // Gets the curently playing song, if any.
-func (p *PlaybackManager) NowPlaying() *mediaprovider.Track {
+func (p *PlaybackManager) NowPlaying() *NowPlayingMetadata {
 	return p.engine.NowPlaying()
 }
 
+func (p *PlaybackManager) NowPlayingMediaItem() mediaprovider.MediaItem {
+	return p.engine.NowPlayingMediaItem()
+}
+
 func (p *PlaybackManager) NowPlayingIndex() int {
 	return p.engine.NowPlayingIndex()
 }
 
 // Sets a callback that is notified whenever a new song begins playing.
-func (p *PlaybackManager) OnSongChange(cb func(nowPlaying *mediaprovider.Track, justScrobbledIfAny *mediaprovider.Track)) {
+func (p *PlaybackManager) OnSongChange(cb func(nowPlaying *NowPlayingMetadata, justScrobbledIfAny *mediaprovider.Track)) {
 	p.engine.onSongChange = append(p.engine.onSongChange, cb)
 }
 
@@ -194,7 +217,7 @@ func (p *PlaybackManager) fetchAndPlayTracks(fetchFn func() ([]*mediaprovider.Tr
 	}
 }
 
-func (p *PlaybackManager) GetPlayQueue() []*mediaprovider.Track {
+func (p *PlaybackManager) GetPlayQueue() []mediaprovider.MediaItem {
 	return p.engine.GetPlayQueue()
 }
 

backend/savedplayqueue.go

@@ -29,9 +29,12 @@ func SavePlayQueue(serverID string, pm *PlaybackManager, filepath string, server
 	stats := pm.PlayerStatus()
 	trackIdx := pm.NowPlayingIndex()
 
-	trackIDs := make([]string, len(queue))
+	trackIDs := make([]string, 0, len(queue))
-	for i, tr := range queue {
+	for _, item := range queue {
-		trackIDs[i] = tr.ID
+		if _, ok := item.(*mediaprovider.Track); ok {
+			// dont' save radio stations in play queue
+			trackIDs = append(trackIDs, item.MediaItemID())
+		}
 	}
 
 	saved := serializedSavedPlayQueue{

sharedutil/sharedutil.go

@@ -4,6 +4,7 @@ import (
 	"math"
 	"slices"
 
+	"github.com/dweymouth/supersonic/backend"
 	"github.com/dweymouth/supersonic/backend/mediaprovider"
 )
 
@@ -74,6 +75,15 @@ func FindTrackByID(id string, tracks []*mediaprovider.Track) *mediaprovider.Trac
 	return nil
 }
 
+func FindMediaItemByID(id string, items []mediaprovider.MediaItem) mediaprovider.MediaItem {
+	for _, tr := range items {
+		if id == tr.MediaItemID() {
+			return tr
+		}
+	}
+	return nil
+}
+
 func TrackIDOrEmptyStr(track *mediaprovider.Track) string {
 	if track == nil {
 		return ""
@@ -81,6 +91,13 @@ func TrackIDOrEmptyStr(track *mediaprovider.Track) string {
 	return track.ID
 }
 
+func TrackIDOremptyStringFromMeta(meta *backend.NowPlayingMetadata) string {
+	if meta == nil || meta.Type != backend.MediaTypeTrack {
+		return ""
+	}
+	return meta.ID
+}
+
 func AlbumIDOrEmptyStr(track *mediaprovider.Track) string {
 	if track == nil {
 		return ""

ui/browsing/browsingpane.go

@@ -42,7 +42,7 @@ type Scrollable interface {
 }
 
 type CanShowNowPlaying interface {
-	OnSongChange(song, lastScrobbledIfAny *mediaprovider.Track)
+	OnSongChange(meta *backend.NowPlayingMetadata, lastScrobbledIfAny *mediaprovider.Track)
 }
 
 type CanShowPlayTime interface {
@@ -213,7 +213,7 @@ func (b *BrowsingPane) doSetPage(p Page) bool {
 	return true
 }
 
-func (b *BrowsingPane) onSongChange(song, lastScrobbledIfAny *mediaprovider.Track) {
+func (b *BrowsingPane) onSongChange(song *backend.NowPlayingMetadata, lastScrobbledIfAny *mediaprovider.Track) {
 	if b.curPage == nil {
 		return
 	}

ui/browsing/favoritespage.go

@@ -269,7 +269,7 @@ func (a *FavoritesPage) OnSearched(query string) {
 
 var _ CanShowNowPlaying = (*FavoritesPage)(nil)
 
-func (a *FavoritesPage) OnSongChange(song, lastScrobbledIfAny *mediaprovider.Track) {
+func (a *FavoritesPage) OnSongChange(meta *backend.NowPlayingMetadata, lastScrobbledIfAny *mediaprovider.Track) {
 	a.nowPlayingID = sharedutil.TrackIDOrEmptyStr(song)
 	if tracklist := a.tracklistOrNil(); tracklist != nil {
 		tracklist.SetNowPlaying(a.nowPlayingID)

ui/browsing/nowplayingpage.go

@@ -245,12 +245,12 @@ func (a *NowPlayingPage) Route() controller.Route {
 
 var _ CanShowNowPlaying = (*NowPlayingPage)(nil)
 
-func (a *NowPlayingPage) OnSongChange(song, _ *mediaprovider.Track) {
+func (a *NowPlayingPage) OnSongChange(song *backend.NowPlayingMetadata, lastScrobbledIfAny *mediaprovider.Track) {
 	a.nowPlaying = song
 	if a.imageLoadCancel != nil {
 		a.imageLoadCancel()
 	}
-	a.nowPlayingID = sharedutil.TrackIDOrEmptyStr(song)
+	a.nowPlayingID = sharedutil.TrackIDOremptyStringFromMeta(song)
 	a.queueList.SetNowPlaying(a.nowPlayingID)
 	a.relatedList.SetNowPlaying(a.nowPlayingID)