update

internal/controller/controller.go

@@ -4,6 +4,7 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
+	"AynaLivePlayer/internal/playlist"
 	"AynaLivePlayer/pkg/event"
 )
 
@@ -47,10 +48,18 @@ func handlePlayNext() {
 		events.PlayerPlayNextCmd,
 		"internal.controller.playcontrol.playnext",
 		func(event *event.Event) {
-			global.EventManager.CallA(events.PlaylistNextCmd(model.PlaylistIDPlayer),
-				events.PlaylistNextCmdEvent{
-					Remove: true,
-				})
+			if playlist.PlayerPlaylist.Size() > 0 {
+				global.EventManager.CallA(events.PlaylistNextCmd(model.PlaylistIDPlayer),
+					events.PlaylistNextCmdEvent{
+						Remove: true,
+					})
+			} else {
+				global.EventManager.CallA(events.PlaylistNextCmd(model.PlaylistIDSystem),
+					events.PlaylistNextCmdEvent{
+						Remove: true,
+					})
+			}
+
 		})
 
 	global.EventManager.RegisterA(events.PlaylistNextUpdate(model.PlaylistIDPlayer),
@@ -62,4 +71,14 @@ func handlePlayNext() {
 					Media: data.Media,
 				})
 		})
+
+	global.EventManager.RegisterA(events.PlaylistNextUpdate(model.PlaylistIDSystem),
+		"internal.controller.playcontrol.play_when_next.system_playlist", func(event *event.Event) {
+			data := event.Data.(events.PlaylistNextUpdateEvent)
+			global.EventManager.CallA(
+				events.PlayerPlayCmd,
+				events.PlayerPlayCmdEvent{
+					Media: data.Media,
+				})
+		})
 }

internal/controller/lyric.go

@@ -29,6 +29,7 @@ func createLyricLoader() {
 		if err == nil && len(lyric) > 0 {
 			lyricManager.Lyric = lyric[0]
 		} else {
+			lyricManager.Lyric = miaosic.ParseLyrics("", "")
 			log.Errorf("failed to get lyric for %s (%s): %s", data.Media.Info.Title, data.Media.Info.Meta.ID(), err)
 		}
 		global.EventManager.CallA(events.PlayerLyricReload, events.PlayerLyricReloadEvent{

internal/controller/search.go

@@ -31,8 +31,4 @@ func handleSearch() {
 					Medias: medias,
 				})
 		})
-	global.EventManager.CallA(
-		events.SearchProviderUpdate, events.SearchProviderUpdateEvent{
-			Providers: miaosic.ListAvailableProviders(),
-		})
 }

internal/init.go

@@ -1,8 +0,0 @@
-package internal
-
-import (
-	_ "github.com/AynaLivePlayer/miaosic/providers/bilibili"
-	_ "github.com/AynaLivePlayer/miaosic/providers/bilivideo"
-	_ "github.com/AynaLivePlayer/miaosic/providers/kuwo"
-	_ "github.com/AynaLivePlayer/miaosic/providers/netease"
-)

internal/internal.go

@@ -5,10 +5,12 @@ import (
 	"AynaLivePlayer/internal/liveroom"
 	"AynaLivePlayer/internal/player"
 	"AynaLivePlayer/internal/playlist"
+	"AynaLivePlayer/internal/source"
 )
 
 func Initialize() {
 	player.SetupMpvPlayer()
+	source.Initialize()
 	playlist.Initialize()
 	controller.Initialize()
 	liveroom.Initialize()
@@ -16,5 +18,6 @@ func Initialize() {
 
 func Stop() {
 	liveroom.StopAndSave()
+	playlist.Close()
 	player.StopMpvPlayer()
 }

internal/player/mpv/mpv.go

@@ -1,13 +1,13 @@
 package mpv
 
 import (
-	"AynaLivePlayer/common/util"
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
 	"AynaLivePlayer/pkg/event"
 	"AynaLivePlayer/pkg/logger"
+	"AynaLivePlayer/pkg/util"
 	"fmt"
 	"github.com/AynaLivePlayer/miaosic"
 	"github.com/aynakeya/go-mpv"

internal/playlist/playlist.go

@@ -6,6 +6,8 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
 	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/logger"
+	"github.com/AynaLivePlayer/miaosic"
 )
 
 var PlayerPlaylist *playlist = nil
@@ -15,27 +17,41 @@ var PlaylistsPlaylist *playlist = nil
 
 type playlistConfig struct {
 	SystemPlaylistMode model.PlaylistMode
+	SystemPlaylistID   string
+	PlaylistsPath      string
+	playlists          []miaosic.Playlist
 }
 
 func (p *playlistConfig) Name() string {
-	return "playlist"
+	return "Playlist"
 }
 
 func (p *playlistConfig) OnLoad() {
-	return
+	err := config.LoadJson(p.PlaylistsPath, &p.playlists)
+	if err != nil {
+		log.Errorf("Failed to load playlists: %s", err.Error())
+	}
+	log.Infof("Loaded %d playlists", len(p.playlists))
 }
 
 func (p *playlistConfig) OnSave() {
+	_ = config.SaveJson(p.PlaylistsPath, p.playlists)
 	return
 }
 
-var cfg = &playlistConfig{}
+var cfg = &playlistConfig{
+	SystemPlaylistMode: model.PlaylistModeNormal,
+	PlaylistsPath:      "playlists.json",
+	playlists:          make([]miaosic.Playlist, 0),
+}
+
+var log logger.ILogger = nil
 
 func Initialize() {
+	log = global.Logger.WithPrefix("Playlists")
 	PlayerPlaylist = newPlaylist(model.PlaylistIDPlayer)
 	SystemPlaylist = newPlaylist(model.PlaylistIDSystem)
 	HistoryPlaylist = newPlaylist(model.PlaylistIDHistory)
-	PlaylistsPlaylist = newPlaylist(model.PlaylistIDPlaylists)
 	config.LoadConfig(cfg)
 
 	global.EventManager.RegisterA(events.PlaylistModeChangeCmd(model.PlaylistIDSystem), "internal.playlist.system_init", func(event *event.Event) {
@@ -45,4 +61,26 @@ func Initialize() {
 	global.EventManager.CallA(events.PlaylistModeChangeUpdate(model.PlaylistIDSystem), events.PlaylistModeChangeUpdateEvent{
 		Mode: cfg.SystemPlaylistMode,
 	})
+
+	global.EventManager.RegisterA(
+		events.PlayerPlayingUpdate,
+		"internal.playlist.player_playing_update",
+		func(event *event.Event) {
+			if event.Data.(events.PlayerPlayingUpdateEvent).Removed {
+				return
+			}
+			global.EventManager.CallA(events.PlaylistInsertCmd(model.PlaylistIDHistory), events.PlaylistInsertCmdEvent{
+				Media:    event.Data.(events.PlayerPlayingUpdateEvent).Media,
+				Position: -1,
+			})
+		})
+
+	createPlaylistManager()
+}
+
+func Close() {
+	cfg.playlists = make([]miaosic.Playlist, 0)
+	for _, v := range allPlaylists {
+		cfg.playlists = append(cfg.playlists, *v)
+	}
 }

internal/playlist/playlists.go

@@ -1,3 +1,233 @@
 package playlist
 
+import (
+	"AynaLivePlayer/core/events"
+	"AynaLivePlayer/core/model"
+	"AynaLivePlayer/global"
+	"AynaLivePlayer/pkg/event"
+	"errors"
+	"github.com/AynaLivePlayer/miaosic"
+)
+
 // todo: implement the playlist controller
+
+var allPlaylists = make(map[string]*miaosic.Playlist)
+var currentSelected string = ""
+
+func createPlaylistManager() {
+	allPlaylists = make(map[string]*miaosic.Playlist)
+	for _, pl := range cfg.playlists {
+		value := pl.Copy()
+		allPlaylists[pl.Meta.ID()] = &value
+	}
+	currentSelected = ""
+	if len(cfg.playlists) > 0 {
+		currentSelected = cfg.playlists[0].Meta.ID()
+	}
+
+	global.EventManager.CallA(
+		events.PlaylistManagerCurrentUpdate,
+		events.PlaylistManagerCurrentUpdateEvent{
+			Medias: make([]model.Media, 0),
+		})
+
+	global.EventManager.CallA(
+		events.PlaylistManagerSetSystemCmd,
+		events.PlaylistManagerSetSystemCmdEvent{
+			PlaylistID: cfg.SystemPlaylistID,
+		})
+
+	global.EventManager.RegisterA(events.PlaylistManagerSetSystemCmd,
+		"internal.playlist.system_playlist.set",
+		func(event *event.Event) {
+			data := event.Data.(events.PlaylistManagerSetSystemCmdEvent)
+			// default case
+			if data.PlaylistID == "" {
+				return
+			}
+			log.Infof("try to set system playlist %s", data.PlaylistID)
+			pl, ok := allPlaylists[data.PlaylistID]
+			if !ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("playlist not found"),
+					})
+				return
+			}
+			cfg.SystemPlaylistID = pl.Meta.ID()
+			global.EventManager.CallA(
+				events.PlaylistManagerSystemUpdate,
+				events.PlaylistManagerSystemUpdateEvent{
+					Info: model.PlaylistInfo{
+						Meta:  pl.Meta,
+						Title: pl.DisplayName(),
+					},
+				})
+			log.Infof("replace system playlist with %d medias", len(pl.Medias))
+			medias := make([]model.Media, len(pl.Medias))
+			for i, v := range pl.Medias {
+				medias[i] = model.Media{
+					Info: v,
+					User: model.SystemUser,
+				}
+			}
+			SystemPlaylist.Replace(medias)
+
+		})
+	global.EventManager.RegisterA(
+		events.PlaylistManagerRefreshCurrentCmd,
+		"internal.playlist.current_playlist.refresh",
+		func(event *event.Event) {
+			data := event.Data.(events.PlaylistManagerRefreshCurrentCmdEvent)
+			log.Infof("try to refresh playlist %s", data.PlaylistID)
+			currentSelected = data.PlaylistID
+			// default case
+			if currentSelected == "" {
+				return
+			}
+			pl, ok := allPlaylists[data.PlaylistID]
+			if !ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("playlist not found"),
+					})
+				return
+			}
+			getPlaylist, err := miaosic.GetPlaylist(pl.Meta)
+			if err != nil {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: err,
+					})
+				return
+			}
+			allPlaylists[pl.Meta.ID()] = getPlaylist
+			updateCurrenMedias(getPlaylist)
+			updatePlaylistManagerInfos()
+		})
+
+	global.EventManager.RegisterA(
+		events.PlaylistManagerGetCurrentCmd,
+		"internal.playlist.current_playlist.get",
+		func(event *event.Event) {
+			data := event.Data.(events.PlaylistManagerGetCurrentCmdEvent)
+			log.Infof("try to get playlist %s", data.PlaylistID)
+			currentSelected = data.PlaylistID
+			// default case
+			if currentSelected == "" {
+				return
+			}
+			pl, ok := allPlaylists[data.PlaylistID]
+			if !ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("playlist not found"),
+					})
+				return
+			}
+			updateCurrenMedias(pl)
+		})
+
+	global.EventManager.RegisterA(
+		events.PlaylistManagerAddPlaylistCmd,
+		"internal.playlist.add_playlist",
+		func(event *event.Event) {
+			data := event.Data.(events.PlaylistManagerAddPlaylistCmdEvent)
+			log.Info("try to add playlist", data)
+			meta, ok := miaosic.MatchPlaylistByProvider(data.Provider, data.URL)
+			if !ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("not proper url"),
+					})
+				return
+			}
+			_, ok = allPlaylists[meta.ID()]
+			if ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("playlist already exists"),
+					})
+				return
+			}
+			pl, err := miaosic.GetPlaylist(meta)
+			if err != nil {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: err,
+					})
+				return
+			}
+			allPlaylists[meta.ID()] = pl
+			updatePlaylistManagerInfos()
+		})
+
+	global.EventManager.RegisterA(
+		events.PlaylistManagerRemovePlaylistCmd,
+		"internal.playlist.remove_playlist",
+		func(event *event.Event) {
+			data := event.Data.(events.PlaylistManagerRemovePlaylistCmdEvent)
+			if data.PlaylistID == cfg.SystemPlaylistID {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("cannot remove system playlist"),
+					})
+				return
+			}
+			_, ok := allPlaylists[data.PlaylistID]
+			if !ok {
+				global.EventManager.CallA(
+					events.ErrorUpdate,
+					events.ErrorUpdateEvent{
+						Error: errors.New("playlist not found"),
+					})
+				return
+			}
+			delete(allPlaylists, data.PlaylistID)
+			updatePlaylistManagerInfos()
+		})
+	updatePlaylistManagerInfos()
+}
+
+func updateCurrenMedias(pl *miaosic.Playlist) {
+	medias := make([]model.Media, len(pl.Medias))
+	for i, v := range pl.Medias {
+		medias[i] = model.Media{
+			Info: v,
+			User: model.SystemUser,
+		}
+	}
+	global.EventManager.CallA(
+		events.PlaylistManagerCurrentUpdate,
+		events.PlaylistManagerCurrentUpdateEvent{
+			Medias: medias,
+		})
+}
+
+func updatePlaylistManagerInfos() {
+	playlists := make([]model.PlaylistInfo, 0)
+	keys := make([]string, 0)
+	for k := range allPlaylists {
+		keys = append(keys, k)
+	}
+	for _, k := range keys {
+		playlists = append(playlists, model.PlaylistInfo{
+			Meta:  allPlaylists[k].Meta,
+			Title: allPlaylists[k].DisplayName(),
+		})
+	}
+	log.InfoW("update playlist manager infos")
+	global.EventManager.CallA(
+		events.PlaylistManagerInfoUpdate,
+		events.PlaylistManagerInfoUpdateEvent{
+			Playlists: playlists,
+		})
+}

internal/source/source.go

@@ -0,0 +1,41 @@
+package source
+
+import (
+	"AynaLivePlayer/core/events"
+	"AynaLivePlayer/global"
+	"AynaLivePlayer/pkg/config"
+	"github.com/AynaLivePlayer/miaosic"
+	_ "github.com/AynaLivePlayer/miaosic/providers/bilibili"
+	_ "github.com/AynaLivePlayer/miaosic/providers/bilivideo"
+	_ "github.com/AynaLivePlayer/miaosic/providers/kuwo"
+	"github.com/AynaLivePlayer/miaosic/providers/local"
+	_ "github.com/AynaLivePlayer/miaosic/providers/netease"
+)
+
+type _sourceConfig struct {
+	LocalSourcePath string
+}
+
+func (_ _sourceConfig) Name() string {
+	return "Source"
+}
+
+func (_ _sourceConfig) OnLoad() {
+}
+
+func (_ _sourceConfig) OnSave() {
+}
+
+var sourceCfg = &_sourceConfig{
+	LocalSourcePath: "./music",
+}
+
+func Initialize() {
+	config.LoadConfig(sourceCfg)
+	miaosic.RegisterProvider(local.NewLocal(sourceCfg.LocalSourcePath))
+
+	global.EventManager.CallA(
+		events.MediaProviderUpdate, events.MediaProviderUpdateEvent{
+			Providers: miaosic.ListAvailableProviders(),
+		})
+}