upgrade event to eventbus; remove old event package

app/main.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/gui"
 	"AynaLivePlayer/internal"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	loggerRepo "AynaLivePlayer/pkg/logger/repository"
@@ -39,7 +39,8 @@ var Log = &_LogConfig{
 }
 
 func setupGlobal() {
-	global.EventManager = event.NewManger(128, 16)
+	//global.EventManager = event.NewManger(128, 16)
+	global.EventBus = eventbus.New()
 	global.Logger = loggerRepo.NewZapColoredLogger(Log.Path, !*dev)
 	global.Logger.SetLogLevel(Log.Level)
 }
@@ -57,7 +58,8 @@ func main() {
 		// temporary fix for gui not render correctly.
 		// wait until gui rendered then start event dispatching
 		time.Sleep(1 * time.Second)
-		global.EventManager.Start()
+		//global.EventManager.Start()
+		_ = global.EventBus.Start()
 	}()
 	if *headless || config.Experimental.Headless {
 		quit := make(chan os.Signal)
@@ -70,7 +72,8 @@ func main() {
 	global.Logger.Info("closing internal server")
 	internal.Stop()
 	global.Logger.Infof("closing event manager")
-	global.EventManager.Stop()
+	//global.EventManager.Stop()
+	_ = global.EventBus.Stop()
 	if *dev {
 		global.Logger.Infof("saving translation")
 		i18n.SaveTranslation()

core/events/event.go

@@ -1,13 +1,13 @@
 package events
 
 //const (
-//	EventPlay              event.EventId = "player.play"
-//	EventPlayed            event.EventId = "player.played"
-//	EventPlaylistPreInsert event.EventId = "playlist.insert.pre"
-//	EventPlaylistInsert    event.EventId = "playlist.insert.after"
-//	EventPlaylistUpdate    event.EventId = "playlist.update"
-//	EventLyricUpdate       event.EventId = "lyric.update"
-//	EventLyricReload       event.EventId = "lyric.reload"
+//	EventPlay              string = "player.play"
+//	EventPlayed            string = "player.played"
+//	EventPlaylistPreInsert string = "playlist.insert.pre"
+//	EventPlaylistInsert    string = "playlist.insert.after"
+//	EventPlaylistUpdate    string = "playlist.update"
+//	EventLyricUpdate       string = "lyric.update"
+//	EventLyricReload       string = "lyric.reload"
 //)
 
 const ErrorUpdate = "update.error"
@@ -17,8 +17,8 @@ type ErrorUpdateEvent struct {
 }
 
 //
-//func EventPlayerPropertyUpdate(property model.PlayerProperty) event.EventId {
-//	return event.EventId("player.property.update." + string(property))
+//func EventPlayerPropertyUpdate(property model.PlayerProperty) string {
+//	return string("player.property.update." + string(property))
 //}
 //
 //type PlaylistInsertEvent struct {

core/events/liveroom.go

@@ -6,8 +6,8 @@ import (
 )
 
 //const (
-//	LiveRoomStatusChange   event.EventId = "liveclient.status.change"
-//	LiveRoomMessageReceive event.EventId = "liveclient.message.receive"
+//	LiveRoomStatusChange   string = "liveclient.status.change"
+//	LiveRoomMessageReceive string = "liveclient.message.receive"
 //)
 //
 //type StatusChangeEvent struct {

core/events/mapping.go

@@ -2,13 +2,12 @@ package events
 
 import (
 	"AynaLivePlayer/core/model"
-	"AynaLivePlayer/pkg/event"
 	"encoding/json"
 	"errors"
 	"reflect"
 )
 
-var EventsMapping = map[event.EventId]any{
+var EventsMapping = map[string]any{
 	LiveRoomAddCmd:                      LiveRoomAddCmdEvent{},
 	LiveRoomProviderUpdate:              LiveRoomProviderUpdateEvent{},
 	LiveRoomRemoveCmd:                   LiveRoomRemoveCmdEvent{},
@@ -65,7 +64,7 @@ func init() {
 	}
 }
 
-func UnmarshalEventData(eventId event.EventId, data []byte) (any, error) {
+func UnmarshalEventData(eventId string, data []byte) (any, error) {
 	val, ok := EventsMapping[eventId]
 	if !ok {
 		return nil, errors.New("event id not found")

core/events/playlist.go

@@ -2,19 +2,18 @@ package events
 
 import (
 	"AynaLivePlayer/core/model"
-	"AynaLivePlayer/pkg/event"
 )
 
-func PlaylistDetailUpdate(id model.PlaylistID) event.EventId {
-	return event.EventId("update.playlist.detail." + id)
+func PlaylistDetailUpdate(id model.PlaylistID) string {
+	return string("update.playlist.detail." + id)
 }
 
 type PlaylistDetailUpdateEvent struct {
 	Medias []model.Media
 }
 
-func PlaylistMoveCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.move." + id)
+func PlaylistMoveCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.move." + id)
 }
 
 type PlaylistMoveCmdEvent struct {
@@ -22,24 +21,24 @@ type PlaylistMoveCmdEvent struct {
 	To   int
 }
 
-func PlaylistSetIndexCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.setindex." + id)
+func PlaylistSetIndexCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.setindex." + id)
 }
 
 type PlaylistSetIndexCmdEvent struct {
 	Index int
 }
 
-func PlaylistDeleteCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.delete." + id)
+func PlaylistDeleteCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.delete." + id)
 }
 
 type PlaylistDeleteCmdEvent struct {
 	Index int
 }
 
-func PlaylistInsertCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.insert." + id)
+func PlaylistInsertCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.insert." + id)
 }
 
 type PlaylistInsertCmdEvent struct {
@@ -47,8 +46,8 @@ type PlaylistInsertCmdEvent struct {
 	Media    model.Media
 }
 
-func PlaylistInsertUpdate(id model.PlaylistID) event.EventId {
-	return event.EventId("update.playlist.insert." + id)
+func PlaylistInsertUpdate(id model.PlaylistID) string {
+	return string("update.playlist.insert." + id)
 }
 
 type PlaylistInsertUpdateEvent struct {
@@ -56,32 +55,32 @@ type PlaylistInsertUpdateEvent struct {
 	Media    model.Media
 }
 
-func PlaylistNextCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.next." + id)
+func PlaylistNextCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.next." + id)
 }
 
 type PlaylistNextCmdEvent struct {
 	Remove bool // remove the media after next
 }
 
-func PlaylistNextUpdate(id model.PlaylistID) event.EventId {
-	return event.EventId("update.playlist.next." + id)
+func PlaylistNextUpdate(id model.PlaylistID) string {
+	return string("update.playlist.next." + id)
 }
 
 type PlaylistNextUpdateEvent struct {
 	Media model.Media
 }
 
-func PlaylistModeChangeCmd(id model.PlaylistID) event.EventId {
-	return event.EventId("cmd.playlist.mode." + id)
+func PlaylistModeChangeCmd(id model.PlaylistID) string {
+	return string("cmd.playlist.mode." + id)
 }
 
 type PlaylistModeChangeCmdEvent struct {
 	Mode model.PlaylistMode
 }
 
-func PlaylistModeChangeUpdate(id model.PlaylistID) event.EventId {
-	return event.EventId("update.playlist.mode." + id)
+func PlaylistModeChangeUpdate(id model.PlaylistID) string {
+	return string("update.playlist.mode." + id)
 }
 
 type PlaylistModeChangeUpdateEvent struct {

global/global.go

@@ -1,10 +1,10 @@
 package global
 
 import (
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 )
 
 var Logger logger.ILogger = nil
 
-var EventManager *event.Manager = nil
+var EventBus eventbus.Bus = nil

gui/config_basic.go

@@ -7,7 +7,7 @@ import (
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/gutil"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/container"
@@ -38,14 +38,14 @@ func (b *bascicConfig) CreatePanel() fyne.CanvasObject {
 				mode = model.PlaylistModeRandom
 			}
 			logger.Infof("Set player playlist mode to %d", mode)
-			global.EventManager.CallA(events.PlaylistModeChangeCmd(model.PlaylistIDPlayer),
+			_ = global.EventBus.Publish(events.PlaylistModeChangeCmd(model.PlaylistIDPlayer),
 				events.PlaylistModeChangeCmdEvent{
 					Mode: mode,
 				})
 		})
-	global.EventManager.RegisterA(events.PlaylistModeChangeUpdate(model.PlaylistIDPlayer),
+	global.EventBus.Subscribe("", events.PlaylistModeChangeUpdate(model.PlaylistIDPlayer),
 		"gui.config.basic.random_playlist.player",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistModeChangeUpdateEvent)
 			playerRandomCheck.SetChecked(data.Mode == model.PlaylistModeRandom)
 		}))
@@ -56,15 +56,15 @@ func (b *bascicConfig) CreatePanel() fyne.CanvasObject {
 			if b {
 				mode = model.PlaylistModeRandom
 			}
-			global.EventManager.CallA(events.PlaylistModeChangeCmd(model.PlaylistIDSystem),
+			_ = global.EventBus.Publish(events.PlaylistModeChangeCmd(model.PlaylistIDSystem),
 				events.PlaylistModeChangeCmdEvent{
 					Mode: mode,
 				})
 		})
 
-	global.EventManager.RegisterA(events.PlaylistModeChangeUpdate(model.PlaylistIDSystem),
+	global.EventBus.Subscribe("", events.PlaylistModeChangeUpdate(model.PlaylistIDSystem),
 		"gui.config.basic.random_playlist.system",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistModeChangeUpdateEvent)
 			systemRandomCheck.SetChecked(data.Mode == model.PlaylistModeRandom)
 		}))
@@ -80,14 +80,14 @@ func (b *bascicConfig) CreatePanel() fyne.CanvasObject {
 		if !ok {
 			return
 		}
-		global.EventManager.CallA(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
+		_ = global.EventBus.Publish(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
 			Device: name,
 		})
 	})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerAudioDeviceUpdate,
 		"gui.config.basic.audio_device.update",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerAudioDeviceUpdateEvent)
 			devices := make([]string, len(data.Devices))
 			deviceDesc2Name = make(map[string]string)
@@ -123,7 +123,7 @@ func (b *bascicConfig) CreatePanel() fyne.CanvasObject {
 			config.General.AutoCheckUpdate),
 	)
 	checkUpdateBtn := widget.NewButton(i18n.T("gui.config.basic.check_update"), func() {
-		global.EventManager.CallA(events.CheckUpdateCmd, events.CheckUpdateCmdEvent{})
+		_ = global.EventBus.Publish(events.CheckUpdateCmd, events.CheckUpdateCmdEvent{})
 	})
 	useSysPlaylistBtn := container.NewHBox(
 		widget.NewLabel(i18n.T("gui.config.basic.use_system_playlist")),

gui/gui.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/resource"
 	"fyne.io/fyne/v2"
@@ -72,8 +72,8 @@ func Initialize() {
 	// setupPlayerWindow()
 
 	// register error
-	global.EventManager.RegisterA(
-		events.ErrorUpdate, "gui.show_error", gutil.ThreadSafeHandler(func(e *event.Event) {
+	global.EventBus.Subscribe("",
+		events.ErrorUpdate, "gui.show_error", gutil.ThreadSafeHandler(func(e *eventbus.Event) {
 			err := e.Data.(events.ErrorUpdateEvent).Error
 			logger.Warnf("gui received error event: %v, %v", err, err == nil)
 			if err == nil {

gui/gutil/fyne.go

@@ -1,14 +1,14 @@
 package gutil
 
 import (
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"fyne.io/fyne/v2"
 )
 
 // since 2.6.1, calls to fyne API from other go routine must be wrapped in fyne.Do
-func ThreadSafeHandler(fn func(e *event.Event)) func(e *event.Event) {
+func ThreadSafeHandler(fn func(e *eventbus.Event)) func(e *eventbus.Event) {
 	//return fn
-	return func(e *event.Event) {
+	return func(e *eventbus.Event) {
 		fyne.Do(func() {
 			fn(e)
 		})

gui/handler.go

@@ -3,11 +3,11 @@ package gui
 import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 )
 
 func registerHandlers() {
-	global.EventManager.RegisterA(events.GUISetPlayerWindowOpenCmd, "gui.player.videoplayer.handleopen", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.GUISetPlayerWindowOpenCmd, "gui.player.videoplayer.handleopen", func(event *eventbus.Event) {
 		data := event.Data.(events.GUISetPlayerWindowOpenCmdEvent)
 		if data.SetOpen {
 			playerWindow.Close()

gui/history_list.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fmt"
 	"fyne.io/fyne/v2"
@@ -50,12 +50,12 @@ func createHistoryList() fyne.CanvasObject {
 			btns := object.(*fyne.Container).Objects[2].(*fyne.Container).Objects
 			m.User = model.SystemUser
 			btns[0].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
+				_ = global.EventBus.Publish(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
 					Media: m,
 				})
 			}
 			btns[1].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
+				_ = global.EventBus.Publish(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
 					Media:    m,
 					Position: -1,
 				})
@@ -75,9 +75,9 @@ func createHistoryList() fyne.CanvasObject {
 }
 
 func registerHistoryHandler() {
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistDetailUpdate(model.PlaylistIDHistory),
-		"gui.history.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+		"gui.history.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			History.mux.Lock()
 			History.Medias = event.Data.(events.PlaylistDetailUpdateEvent).Medias
 			History.List.Refresh()

gui/liverooms.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
 	"AynaLivePlayer/gui/xfyne"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/container"
@@ -80,7 +80,7 @@ func createRoomSelector() fyne.CanvasObject {
 			func(b bool) {
 				if b && len(clientNameEntry.Selected) > 0 && len(idEntry.Text) > 0 {
 					logger.Infof("Add room %s %s", clientNameEntry.Selected, idEntry.Text)
-					global.EventManager.CallA(
+					_ = global.EventBus.Publish(
 						events.LiveRoomAddCmd,
 						events.LiveRoomAddCmdEvent{
 							Title:    nameEntry.Text,
@@ -98,7 +98,7 @@ func createRoomSelector() fyne.CanvasObject {
 		if len(RoomTab.rooms) == 0 {
 			return
 		}
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.LiveRoomRemoveCmd,
 			events.LiveRoomRemoveCmdEvent{
 				Identifier: RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier(),
@@ -133,17 +133,17 @@ func createRoomSelector() fyne.CanvasObject {
 }
 
 func registerRoomHandlers() {
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomProviderUpdate,
 		"gui.liveroom.provider_update",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			RoomTab.providers = event.Data.(events.LiveRoomProviderUpdateEvent).Providers
 			RoomTab.Rooms.Refresh()
 		}))
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomRoomsUpdate,
 		"gui.liveroom.rooms_update",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			logger.Infof("Update rooms")
 			data := event.Data.(events.LiveRoomRoomsUpdateEvent)
 			RoomTab.lock.Lock()
@@ -152,10 +152,10 @@ func registerRoomHandlers() {
 			RoomTab.Rooms.Refresh()
 			RoomTab.lock.Unlock()
 		}))
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomStatusUpdate,
 		"gui.liveroom.room_status_update",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			room := event.Data.(events.LiveRoomStatusUpdateEvent).Room
 			index := -1
 			for i := 0; i < len(RoomTab.rooms); i++ {
@@ -194,7 +194,7 @@ func createRoomController() fyne.CanvasObject {
 		}
 		RoomTab.ConnectBtn.Disable()
 		logger.Infof("Connect to room %s", RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier())
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.LiveRoomOperationCmd,
 			events.LiveRoomOperationCmdEvent{
 				Identifier: RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier(),
@@ -207,17 +207,17 @@ func createRoomController() fyne.CanvasObject {
 		}
 		RoomTab.DisConnectBtn.Disable()
 		logger.Infof("Disconnect from room %s", RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier())
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.LiveRoomOperationCmd,
 			events.LiveRoomOperationCmdEvent{
 				Identifier: RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier(),
 				SetConnect: false,
 			})
 	})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomOperationFinish,
 		"gui.liveroom.operation_finish",
-		gutil.ThreadSafeHandler(func(event *event.Event) {
+		gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			RoomTab.ConnectBtn.Enable()
 			RoomTab.DisConnectBtn.Enable()
 		}))
@@ -229,7 +229,7 @@ func createRoomController() fyne.CanvasObject {
 			return
 		}
 		logger.Infof("Change room %s autoconnect to %v", RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier(), b)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.LiveRoomConfigChangeCmd,
 			events.LiveRoomConfigChangeCmdEvent{
 				Identifier: RoomTab.rooms[RoomTab.Index].LiveRoom.Identifier(),

gui/player_controller.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/util"
 	"AynaLivePlayer/resource"
@@ -45,16 +45,16 @@ var PlayController = &PlayControllerContainer{}
 
 func registerPlayControllerHandler() {
 	PlayController.ButtonPrev.OnTapped = func() {
-		global.EventManager.CallA(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
+		_ = global.EventBus.Publish(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
 			Position: 0,
 			Absolute: true,
 		})
 	}
 	PlayController.ButtonSwitch.OnTapped = func() {
-		global.EventManager.CallA(events.PlayerToggleCmd, events.PlayerToggleCmdEvent{})
+		_ = global.EventBus.Publish(events.PlayerToggleCmd, events.PlayerToggleCmdEvent{})
 	}
 	PlayController.ButtonNext.OnTapped = func() {
-		global.EventManager.CallA(events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
+		_ = global.EventBus.Publish(events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
 	}
 
 	PlayController.ButtonLrc.OnTapped = func() {
@@ -68,7 +68,7 @@ func registerPlayControllerHandler() {
 		showPlayerWindow()
 	}
 
-	global.EventManager.RegisterA(events.PlayerPropertyPauseUpdate, "gui.player.controller.paused", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyPauseUpdate, "gui.player.controller.paused", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		if event.Data.(events.PlayerPropertyPauseUpdateEvent).Paused {
 			PlayController.ButtonSwitch.Icon = theme.MediaPlayIcon()
 		} else {
@@ -77,7 +77,7 @@ func registerPlayControllerHandler() {
 		PlayController.ButtonSwitch.Refresh()
 	}))
 
-	global.EventManager.RegisterA(events.PlayerPropertyPercentPosUpdate, "gui.player.controller.percent_pos", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyPercentPosUpdate, "gui.player.controller.percent_pos", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		if PlayController.Progress.Dragging {
 			return
 		}
@@ -85,7 +85,7 @@ func registerPlayControllerHandler() {
 		PlayController.Progress.Refresh()
 	}))
 
-	global.EventManager.RegisterA(events.PlayerPropertyStateUpdate, "gui.player.controller.idle_active", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyStateUpdate, "gui.player.controller.idle_active", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		state := event.Data.(events.PlayerPropertyStateUpdateEvent).State
 		if state == model.PlayerStateIdle || state == model.PlayerStateLoading {
 			PlayController.Progress.Value = 0
@@ -101,33 +101,33 @@ func registerPlayControllerHandler() {
 
 	PlayController.Progress.Max = 0
 	PlayController.Progress.OnDragEnd = func(f float64) {
-		global.EventManager.CallA(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
+		_ = global.EventBus.Publish(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
 			Position: f / 10,
 			Absolute: false,
 		})
 	}
 
-	global.EventManager.RegisterA(events.PlayerPropertyTimePosUpdate, "gui.player.controller.time_pos", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyTimePosUpdate, "gui.player.controller.time_pos", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		PlayController.CurrentTime.SetText(util.FormatTime(int(event.Data.(events.PlayerPropertyTimePosUpdateEvent).TimePos)))
 	}))
 
-	global.EventManager.RegisterA(events.PlayerPropertyDurationUpdate, "gui.player.controller.duration", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyDurationUpdate, "gui.player.controller.duration", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		PlayController.TotalTime.SetText(util.FormatTime(int(event.Data.(events.PlayerPropertyDurationUpdateEvent).Duration)))
 	}))
 
-	global.EventManager.RegisterA(events.PlayerPropertyVolumeUpdate, "gui.player.controller.volume", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyVolumeUpdate, "gui.player.controller.volume", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		PlayController.Volume.Value = event.Data.(events.PlayerPropertyVolumeUpdateEvent).Volume
 		PlayController.Volume.Refresh()
 	}))
 
 	PlayController.Volume.OnChanged = func(f float64) {
-		global.EventManager.CallA(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
+		_ = global.EventBus.Publish(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
 			Volume: f,
 		})
 	}
 
 	// todo: double check cover loading for new thread model
-	global.EventManager.RegisterA(events.PlayerPlayingUpdate, "gui.player.updateinfo", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPlayingUpdate, "gui.player.updateinfo", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		if event.Data.(events.PlayerPlayingUpdateEvent).Removed {
 			PlayController.Progress.Value = 0
 			PlayController.Progress.Max = 0

gui/player_lyric.go

@@ -4,7 +4,7 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/container"
@@ -42,9 +42,8 @@ func createLyricWindow() fyne.Window {
 	w.CenterOnScreen()
 
 	// register handlers
-	// todo: lyric not update correctly, known bug https://github.com/fyne-io/fyne/pull/5783
-	global.EventManager.RegisterA(
-		events.PlayerLyricPosUpdate, "player.lyric.current_lyric", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlayerLyricPosUpdate, "player.lyric.current_lyric", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			e := event.Data.(events.PlayerLyricPosUpdateEvent)
 			logger.Debug("lyric update", e)
 			if prevIndex >= len(fullLrc.Objects) || e.CurrentIndex >= len(fullLrc.Objects) {
@@ -70,17 +69,16 @@ func createLyricWindow() fyne.Window {
 			fullLrc.Refresh()
 		}))
 
-	global.EventManager.RegisterA(events.PlayerLyricReload, "player.lyric.current_lyric", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerLyricReload, "player.lyric.current_lyric", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		e := event.Data.(events.PlayerLyricReloadEvent)
 		fullLrc.Objects = createLyricObj(&e.Lyrics)
 		lrcWindow.Refresh()
 	}))
 
-	global.EventManager.CallA(events.PlayerLyricRequestCmd, events.PlayerLyricRequestCmdEvent{})
+	_ = global.EventBus.Publish(events.PlayerLyricRequestCmd, events.PlayerLyricRequestCmdEvent{})
 
 	w.SetOnClosed(func() {
-		global.EventManager.Unregister("player.lyric.current_lyric")
-		global.EventManager.Unregister("player.lyric.new_media")
+		global.EventBus.Unsubscribe(events.PlayerLyricReload, "player.lyric.current_lyric")
 		PlayController.LrcWindowOpen = false
 	})
 	return w

gui/player_playlist.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fmt"
 	"fyne.io/fyne/v2"
@@ -28,12 +28,12 @@ func (b *playlistOperationButton) Tapped(e *fyne.PointEvent) {
 func newPlaylistOperationButton() *playlistOperationButton {
 	b := &playlistOperationButton{Index: 0}
 	deleteItem := fyne.NewMenuItem(i18n.T("gui.player.playlist.op.delete"), func() {
-		global.EventManager.CallA(events.PlaylistDeleteCmd(model.PlaylistIDPlayer), events.PlaylistDeleteCmdEvent{
+		_ = global.EventBus.Publish(events.PlaylistDeleteCmd(model.PlaylistIDPlayer), events.PlaylistDeleteCmdEvent{
 			Index: b.Index,
 		})
 	})
 	topItem := fyne.NewMenuItem(i18n.T("gui.player.playlist.op.top"), func() {
-		global.EventManager.CallA(events.PlaylistMoveCmd(model.PlaylistIDPlayer), events.PlaylistMoveCmdEvent{
+		_ = global.EventBus.Publish(events.PlaylistMoveCmd(model.PlaylistIDPlayer), events.PlaylistMoveCmdEvent{
 			From: b.Index,
 			To:   0,
 		})
@@ -75,7 +75,7 @@ func createPlaylist() fyne.CanvasObject {
 			object.(*fyne.Container).Objects[1].(*widget.Label).SetText(fmt.Sprintf("%d", id))
 			object.(*fyne.Container).Objects[2].(*playlistOperationButton).Index = id
 		})
-	global.EventManager.RegisterA(events.PlaylistDetailUpdate(model.PlaylistIDPlayer), "gui.player.playlist.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistDetailUpdate(model.PlaylistIDPlayer), "gui.player.playlist.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		UserPlaylist.mux.Lock()
 		UserPlaylist.Medias = event.Data.(events.PlaylistDetailUpdateEvent).Medias
 		UserPlaylist.List.Refresh()

gui/player_videoplayer.go

@@ -25,7 +25,7 @@ func showPlayerWindow() {
 		playerWindowHandle = xfyne.GetWindowHandle(playerWindow)
 		logger.Infof("video output window handle: %d", playerWindowHandle)
 		if playerWindowHandle != 0 {
-			global.EventManager.CallA(events.PlayerVideoPlayerSetWindowHandleCmd,
+			_ = global.EventBus.Publish(events.PlayerVideoPlayerSetWindowHandleCmd,
 				events.PlayerVideoPlayerSetWindowHandleCmdEvent{Handle: playerWindowHandle})
 		}
 	}

gui/playlists.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
 	"AynaLivePlayer/gui/xfyne"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fmt"
 	"fyne.io/fyne/v2"
@@ -64,7 +64,7 @@ func createPlaylists() fyne.CanvasObject {
 			func(b bool) {
 				if b && len(providerEntry.Selected) > 0 && len(idEntry.Text) > 0 {
 					logger.Infof("add playlists %s %s", providerEntry.Selected, idEntry.Text)
-					global.EventManager.CallA(
+					_ = global.EventBus.Publish(
 						events.PlaylistManagerAddPlaylistCmd,
 						events.PlaylistManagerAddPlaylistCmdEvent{
 							Provider: providerEntry.Selected,
@@ -82,7 +82,7 @@ func createPlaylists() fyne.CanvasObject {
 			return
 		}
 		logger.Infof("remove playlists %s", PlaylistManager.currentPlaylists[PlaylistManager.Index].Meta.ID())
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlaylistManagerRemovePlaylistCmd,
 			events.PlaylistManagerRemovePlaylistCmdEvent{
 				PlaylistID: PlaylistManager.currentPlaylists[PlaylistManager.Index].Meta.ID(),
@@ -93,19 +93,19 @@ func createPlaylists() fyne.CanvasObject {
 			return
 		}
 		PlaylistManager.Index = id
-		global.EventManager.CallA(events.PlaylistManagerGetCurrentCmd, events.PlaylistManagerGetCurrentCmdEvent{
+		_ = global.EventBus.Publish(events.PlaylistManagerGetCurrentCmd, events.PlaylistManagerGetCurrentCmdEvent{
 			PlaylistID: PlaylistManager.currentPlaylists[id].Meta.ID(),
 		})
 	}
-	global.EventManager.RegisterA(events.MediaProviderUpdate,
-		"gui.playlists.provider.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.MediaProviderUpdate,
+		"gui.playlists.provider.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			providers := event.Data.(events.MediaProviderUpdateEvent)
 			s := make([]string, len(providers.Providers))
 			copy(s, providers.Providers)
 			PlaylistManager.providers = s
 		}))
-	global.EventManager.RegisterA(events.PlaylistManagerInfoUpdate,
-		"gui.playlists.info.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistManagerInfoUpdate,
+		"gui.playlists.info.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerInfoUpdateEvent)
 			prevLen := len(PlaylistManager.currentPlaylists)
 			PlaylistManager.currentPlaylists = data.Playlists
@@ -115,8 +115,8 @@ func createPlaylists() fyne.CanvasObject {
 				PlaylistManager.Playlists.Select(0)
 			}
 		}))
-	global.EventManager.RegisterA(events.PlaylistManagerSystemUpdate,
-		"gui.playlists.system.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistManagerSystemUpdate,
+		"gui.playlists.system.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerSystemUpdateEvent)
 			PlaylistManager.CurrentSystemPlaylist.SetText(i18n.T("gui.playlist.current") + data.Info.DisplayName())
 		}))
@@ -137,7 +137,7 @@ func createPlaylistMedias() fyne.CanvasObject {
 			if PlaylistManager.Index >= len(PlaylistManager.currentPlaylists) {
 				return
 			}
-			global.EventManager.CallA(events.PlaylistManagerRefreshCurrentCmd, events.PlaylistManagerRefreshCurrentCmdEvent{
+			_ = global.EventBus.Publish(events.PlaylistManagerRefreshCurrentCmd, events.PlaylistManagerRefreshCurrentCmdEvent{
 				PlaylistID: PlaylistManager.currentPlaylists[PlaylistManager.Index].Meta.ID(),
 			})
 		})
@@ -148,7 +148,7 @@ func createPlaylistMedias() fyne.CanvasObject {
 				return
 			}
 			logger.Infof("set playlist %s as system", PlaylistManager.currentPlaylists[PlaylistManager.Index].Meta.ID())
-			global.EventManager.CallA(events.PlaylistManagerSetSystemCmd, events.PlaylistManagerSetSystemCmdEvent{
+			_ = global.EventBus.Publish(events.PlaylistManagerSetSystemCmd, events.PlaylistManagerSetSystemCmdEvent{
 				PlaylistID: PlaylistManager.currentPlaylists[PlaylistManager.Index].Meta.ID(),
 			})
 		})
@@ -179,19 +179,19 @@ func createPlaylistMedias() fyne.CanvasObject {
 			btns := object.(*fyne.Container).Objects[2].(*fyne.Container).Objects
 			m.User = model.SystemUser
 			btns[0].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
+				_ = global.EventBus.Publish(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
 					Media: m,
 				})
 			}
 			btns[1].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
+				_ = global.EventBus.Publish(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
 					Media:    m,
 					Position: -1,
 				})
 			}
 		})
-	global.EventManager.RegisterA(events.PlaylistManagerCurrentUpdate,
-		"gui.playlists.current.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistManagerCurrentUpdate,
+		"gui.playlists.current.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			logger.Infof("receive current playlist update, try to refresh playlist medias")
 			data := event.Data.(events.PlaylistManagerCurrentUpdateEvent)
 			PlaylistManager.currentMedias = data.Medias

gui/search_bar.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/container"
@@ -35,14 +35,14 @@ func createSearchBar() fyne.CanvasObject {
 		SearchResult.Items = make([]model.Media, 0)
 		SearchResult.List.Refresh()
 		SearchResult.mux.Unlock()
-		global.EventManager.CallA(events.SearchCmd, events.SearchCmdEvent{
+		_ = global.EventBus.Publish(events.SearchCmd, events.SearchCmdEvent{
 			Keyword:  keyword,
 			Provider: pr,
 		})
 	})
 
-	global.EventManager.RegisterA(events.MediaProviderUpdate,
-		"gui.search.provider.update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.MediaProviderUpdate,
+		"gui.search.provider.update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			providers := event.Data.(events.MediaProviderUpdateEvent)
 			s := make([]string, len(providers.Providers))
 			copy(s, providers.Providers)

gui/search_list.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fmt"
 	"fyne.io/fyne/v2"
@@ -51,18 +51,18 @@ func createSearchList() fyne.CanvasObject {
 			object.(*fyne.Container).Objects[1].(*widget.Label).SetText(fmt.Sprintf("%d", id))
 			btns := object.(*fyne.Container).Objects[2].(*fyne.Container).Objects
 			btns[0].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
+				_ = global.EventBus.Publish(events.PlayerPlayCmd, events.PlayerPlayCmdEvent{
 					Media: SearchResult.Items[id],
 				})
 			}
 			btns[1].(*widget.Button).OnTapped = func() {
-				global.EventManager.CallA(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
+				_ = global.EventBus.Publish(events.PlaylistInsertCmd(model.PlaylistIDPlayer), events.PlaylistInsertCmdEvent{
 					Media:    SearchResult.Items[id],
 					Position: -1,
 				})
 			}
 		})
-	global.EventManager.RegisterA(events.SearchResultUpdate, "gui.search.update_result", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("", events.SearchResultUpdate, "gui.search.update_result", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 		items := event.Data.(events.SearchResultUpdateEvent).Medias
 		SearchResult.Items = items
 		SearchResult.mux.Lock()

gui/updater.go

@@ -4,15 +4,15 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/gui/gutil"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"fyne.io/fyne/v2/dialog"
 	"fyne.io/fyne/v2/widget"
 )
 
 func checkUpdate() {
-	global.EventManager.RegisterA(
-		events.CheckUpdateResultUpdate, "gui.updater.check_update", gutil.ThreadSafeHandler(func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.CheckUpdateResultUpdate, "gui.updater.check_update", gutil.ThreadSafeHandler(func(event *eventbus.Event) {
 			data := event.Data.(events.CheckUpdateResultUpdateEvent)
 			msg := data.Info.Version.String() + "\n\n\n" + data.Info.Info
 			if data.HasUpdate {

internal/controller/controller.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/internal/playlist"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 )
 
 func Initialize() {
@@ -22,60 +22,60 @@ func Stop() {
 func handlePlayNext() {
 	log := global.Logger.WithPrefix("Controller")
 	playerState := model.PlayerStatePlaying
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPropertyStateUpdate,
 		"internal.controller.playcontrol.idleplaynext",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyStateUpdateEvent)
 			log.Debug("[MPV PlayControl] update player to state", playerState, "->", data.State)
 			playerState = data.State
 			if playerState == model.PlayerStateIdle {
 				log.Info("mpv went idle, try play next")
-				global.EventManager.CallA(events.PlayerPlayNextCmd,
+				_ = global.EventBus.Publish(events.PlayerPlayNextCmd,
 					events.PlayerPlayNextCmdEvent{})
 			}
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPropertyStateUpdate,
-		"internal.controller.playcontrol.clear_when_idle", func(event *event.Event) {
+		"internal.controller.playcontrol.clear_when_idle", func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyStateUpdateEvent)
 			// if is idle, remove playing media
 			if data.State == model.PlayerStateIdle {
-				global.EventManager.CallA(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
+				_ = global.EventBus.Publish(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
 					Media:   model.Media{},
 					Removed: true,
 				})
 			}
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistInsertUpdate(model.PlaylistIDPlayer),
 		"internal.controller.playcontrol.playnext_when_insert.player",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			if playerState == model.PlayerStateIdle {
-				global.EventManager.CallA(events.PlayerPlayNextCmd,
+				_ = global.EventBus.Publish(events.PlayerPlayNextCmd,
 					events.PlayerPlayNextCmdEvent{})
 			}
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistInsertUpdate(model.PlaylistIDSystem),
 		"internal.controller.playcontrol.playnext_when_insert.system",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			if playerState == model.PlayerStateIdle {
-				global.EventManager.CallA(events.PlayerPlayNextCmd,
+				_ = global.EventBus.Publish(events.PlayerPlayNextCmd,
 					events.PlayerPlayNextCmdEvent{})
 			}
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayNextCmd,
 		"internal.controller.playcontrol.playnext",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			if playlist.PlayerPlaylist.Size() > 0 {
 				log.Infof("Try to play next media in player playlist")
-				global.EventManager.CallA(events.PlaylistNextCmd(model.PlaylistIDPlayer),
+				_ = global.EventBus.Publish(events.PlaylistNextCmd(model.PlaylistIDPlayer),
 					events.PlaylistNextCmdEvent{
 						Remove: true,
 					})
@@ -86,36 +86,36 @@ func handlePlayNext() {
 				return
 			}
 			log.Infof("Try to play next media in system playlist")
-			global.EventManager.CallA(events.PlaylistNextCmd(model.PlaylistIDSystem),
+			_ = global.EventBus.Publish(events.PlaylistNextCmd(model.PlaylistIDSystem),
 				events.PlaylistNextCmdEvent{
 					Remove: false,
 				})
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayErrorUpdate,
 		"internal.controller.playcontrol.playnext_on_error",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			if config.General.PlayNextOnFail {
-				global.EventManager.CallA(events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
+				_ = global.EventBus.Publish(events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
 				return
 			}
 		})
 
-	global.EventManager.RegisterA(events.PlaylistNextUpdate(model.PlaylistIDPlayer),
-		"internal.controller.playcontrol.play_when_next", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistNextUpdate(model.PlaylistIDPlayer),
+		"internal.controller.playcontrol.play_when_next", func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistNextUpdateEvent)
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayCmd,
 				events.PlayerPlayCmdEvent{
 					Media: data.Media,
 				})
 		})
 
-	global.EventManager.RegisterA(events.PlaylistNextUpdate(model.PlaylistIDSystem),
-		"internal.controller.playcontrol.play_when_next.system_playlist", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistNextUpdate(model.PlaylistIDSystem),
+		"internal.controller.playcontrol.play_when_next.system_playlist", func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistNextUpdateEvent)
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayCmd,
 				events.PlayerPlayCmdEvent{
 					Media: data.Media,

internal/controller/lyric.go

@@ -3,7 +3,7 @@ package controller
 import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"github.com/AynaLivePlayer/miaosic"
 )
 
@@ -17,7 +17,7 @@ var lyricManager = &lyricLoader{}
 
 func createLyricLoader() {
 	log := global.Logger.WithPrefix("LyricLoader")
-	global.EventManager.RegisterA(events.PlayerPlayingUpdate, "internal.lyric.update", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPlayingUpdate, "internal.lyric.update", func(event *eventbus.Event) {
 		data := event.Data.(events.PlayerPlayingUpdateEvent)
 		if data.Removed {
 			log.Debugf("current media removed, clear lyric")
@@ -32,18 +32,18 @@ func createLyricLoader() {
 			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{
+		_ = global.EventBus.Publish(events.PlayerLyricReload, events.PlayerLyricReloadEvent{
 			Lyrics: lyricManager.Lyric,
 		})
 	})
-	global.EventManager.RegisterA(events.PlayerPropertyTimePosUpdate, "internal.lyric.update_current", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyTimePosUpdate, "internal.lyric.update_current", func(event *eventbus.Event) {
 		time := event.Data.(events.PlayerPropertyTimePosUpdateEvent).TimePos
 		idx := lyricManager.Lyric.FindIndex(time)
 		if idx == lyricManager.prevIndex {
 			return
 		}
 		lyricManager.prevIndex = idx
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlayerLyricPosUpdate,
 			events.PlayerLyricPosUpdateEvent{
 				CurrentIndex: idx,
@@ -53,8 +53,8 @@ func createLyricLoader() {
 			})
 		return
 	})
-	global.EventManager.RegisterA(events.PlayerLyricRequestCmd, "internal.lyric.request", func(event *event.Event) {
-		global.EventManager.CallA(events.PlayerLyricReload, events.PlayerLyricReloadEvent{
+	global.EventBus.Subscribe("", events.PlayerLyricRequestCmd, "internal.lyric.request", func(event *eventbus.Event) {
+		_ = global.EventBus.Publish(events.PlayerLyricReload, events.PlayerLyricReloadEvent{
 			Lyrics: lyricManager.Lyric,
 		})
 	})

internal/controller/search.go

@@ -4,14 +4,14 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"github.com/AynaLivePlayer/miaosic"
 )
 
 func handleSearch() {
 	log := global.Logger.WithPrefix("Search")
-	global.EventManager.RegisterA(
-		events.SearchCmd, "internal.controller.search.handleSearchCmd", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.SearchCmd, "internal.controller.search.handleSearchCmd", func(event *eventbus.Event) {
 			data := event.Data.(events.SearchCmdEvent)
 			log.Infof("Search %s using %s", data.Keyword, data.Provider)
 			searchResult, err := miaosic.SearchByProvider(data.Provider, data.Keyword, 1, 10)
@@ -26,7 +26,7 @@ func handleSearch() {
 					User: model.SystemUser,
 				}
 			}
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.SearchResultUpdate, events.SearchResultUpdateEvent{
 					Medias: medias,
 				})

internal/liveroom/liveroom.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"errors"
 	liveroomsdk "github.com/AynaLivePlayer/liveroom-sdk"
@@ -53,7 +53,7 @@ func addLiveRoom(roomModel model.LiveRoom) {
 	// handle failed to create liveroom
 	if err != nil {
 		log.Errorf("Create live room failed: %s", err)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.ErrorUpdate, events.ErrorUpdateEvent{
 				Error: err,
 			})
@@ -61,7 +61,7 @@ func addLiveRoom(roomModel model.LiveRoom) {
 	}
 	if _, ok := liveRooms[room.Config().Identifier()]; ok {
 		log.Errorf("fail to add, room %s already exists", room.Config().Identifier())
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.ErrorUpdate, events.ErrorUpdateEvent{
 				Error: errors.New("room already exists"),
 			})
@@ -69,7 +69,7 @@ func addLiveRoom(roomModel model.LiveRoom) {
 	}
 	if err != nil {
 		log.Errorf("Create live room failed: %s", err)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.ErrorUpdate, events.ErrorUpdateEvent{
 				Error: err,
 			})
@@ -88,7 +88,7 @@ func addLiveRoom(roomModel model.LiveRoom) {
 	})
 	room.OnMessage(func(message *liveroomsdk.Message) {
 		log.Debugf("room %s receive message: %s", room.Config().Identifier(), message.Message)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.LiveRoomMessageReceive,
 			events.LiveRoomMessageReceiveEvent{
 				Message: message,
@@ -100,8 +100,8 @@ func addLiveRoom(roomModel model.LiveRoom) {
 }
 
 func registerHandlers() {
-	global.EventManager.RegisterA(
-		events.LiveRoomAddCmd, "internal.liveroom.add", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.LiveRoomAddCmd, "internal.liveroom.add", func(event *eventbus.Event) {
 			data := event.Data.(events.LiveRoomAddCmdEvent)
 			addLiveRoom(model.LiveRoom{
 				LiveRoom: liveroomsdk.LiveRoom{
@@ -116,8 +116,8 @@ func registerHandlers() {
 			})
 		})
 
-	global.EventManager.RegisterA(
-		events.LiveRoomRemoveCmd, "internal.liveroom.remove", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.LiveRoomRemoveCmd, "internal.liveroom.remove", func(event *eventbus.Event) {
 			data := event.Data.(events.LiveRoomRemoveCmdEvent)
 			room, ok := liveRooms[data.Identifier]
 			if !ok {
@@ -133,8 +133,8 @@ func registerHandlers() {
 			sendRoomsUpdateEvent()
 		})
 
-	global.EventManager.RegisterA(
-		events.LiveRoomConfigChangeCmd, "internal.liveroom.config.change", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.LiveRoomConfigChangeCmd, "internal.liveroom.config.change", func(event *eventbus.Event) {
 			data := event.Data.(events.LiveRoomConfigChangeCmdEvent)
 			if room, ok := liveRooms[data.Identifier]; ok {
 				room.model.Config = data.Config
@@ -142,8 +142,8 @@ func registerHandlers() {
 			}
 		})
 
-	global.EventManager.RegisterA(
-		events.LiveRoomOperationCmd, "internal.liveroom.operation", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.LiveRoomOperationCmd, "internal.liveroom.operation", func(event *eventbus.Event) {
 			data := event.Data.(events.LiveRoomOperationCmdEvent)
 			log.Infof("Live room operation SetConnect %v", data.SetConnect)
 			room, ok := liveRooms[data.Identifier]
@@ -159,12 +159,12 @@ func registerHandlers() {
 			}
 			if err != nil {
 				log.Errorf("Room %s operation failed: %s", data.Identifier, err)
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate, events.ErrorUpdateEvent{
 						Error: err,
 					})
 			}
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.LiveRoomOperationFinish, events.LiveRoomOperationFinishEvent{})
 			sendRoomStatusUpdateEvent(data.Identifier)
 		})
@@ -177,7 +177,7 @@ func sendRoomStatusUpdateEvent(roomId string) {
 		return
 	}
 	log.Infof("send room status update event, room %s", roomId)
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.LiveRoomStatusUpdate,
 		events.LiveRoomStatusUpdateEvent{
 			Room: room.model,
@@ -189,7 +189,7 @@ func sendRoomsUpdateEvent() {
 	for _, r := range liveRooms {
 		rooms = append(rooms, r.model)
 	}
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.LiveRoomRoomsUpdate,
 		events.LiveRoomRoomsUpdateEvent{
 			Rooms: rooms,
@@ -209,7 +209,7 @@ func callEvents() {
 	for _, roomCfg := range cfg.liveRooms {
 		addLiveRoom(roomCfg)
 	}
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.LiveRoomProviderUpdate,
 		events.LiveRoomProviderUpdateEvent{
 			Providers: providerInfo,
@@ -217,7 +217,7 @@ func callEvents() {
 	sendRoomsUpdateEvent()
 	for _, r := range liveRooms {
 		if r.model.Config.AutoConnect {
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.LiveRoomOperationCmd,
 				events.LiveRoomOperationCmdEvent{
 					Identifier: r.room.Config().Identifier(),

internal/player/mpv/config.go

@@ -3,7 +3,7 @@ package mpv
 import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 )
 
 type playerConfig struct {
@@ -30,14 +30,14 @@ var cfg = &playerConfig{
 }
 
 func restoreConfig() {
-	global.EventManager.CallA(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
+	_ = global.EventBus.Publish(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
 		Volume: cfg.Volume,
 	})
-	global.EventManager.RegisterA(events.PlayerPropertyVolumeUpdate, "player.config.volume", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyVolumeUpdate, "player.config.volume", func(evnt *eventbus.Event) {
 		data := evnt.Data.(events.PlayerPropertyVolumeUpdateEvent)
 		cfg.Volume = data.Volume
 	})
-	global.EventManager.CallA(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
+	_ = global.EventBus.Publish(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
 		Device: cfg.AudioDevice,
 	})
 }

internal/player/mpv/mpv.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"AynaLivePlayer/pkg/util"
 	"fmt"
@@ -102,7 +102,7 @@ var mpvPropertyHandler = map[string]func(value any){
 		var data events.PlayerPropertyPauseUpdateEvent
 		log.Debugf("pause property update %v %T", value, value)
 		data.Paused = value.(bool)
-		global.EventManager.CallA(events.PlayerPropertyPauseUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyPauseUpdate, data)
 	},
 	"percent-pos": func(value any) {
 		var data events.PlayerPropertyPercentPosUpdateEvent
@@ -120,7 +120,7 @@ var mpvPropertyHandler = map[string]func(value any){
 			return
 		}
 		prevPercentPos = data.PercentPos
-		global.EventManager.CallA(events.PlayerPropertyPercentPosUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyPercentPosUpdate, data)
 
 	},
 	"idle-active": func(value any) {
@@ -137,7 +137,7 @@ var mpvPropertyHandler = map[string]func(value any){
 		log.Debugf("mpv state update %v + %v = %v", currentState, data.State, currentState.NextState(data.State))
 		currentState = currentState.NextState(data.State)
 		data.State = currentState
-		global.EventManager.CallA(events.PlayerPropertyStateUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyStateUpdate, data)
 
 	},
 	"time-pos": func(value any) {
@@ -156,7 +156,7 @@ var mpvPropertyHandler = map[string]func(value any){
 			return
 		}
 		prevTimePos = data.TimePos
-		global.EventManager.CallA(events.PlayerPropertyTimePosUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyTimePosUpdate, data)
 	},
 	"duration": func(value any) {
 		var data events.PlayerPropertyDurationUpdateEvent
@@ -165,7 +165,7 @@ var mpvPropertyHandler = map[string]func(value any){
 		} else {
 			data.Duration = value.(float64)
 		}
-		global.EventManager.CallA(events.PlayerPropertyDurationUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyDurationUpdate, data)
 	},
 	"volume": func(value any) {
 		var data events.PlayerPropertyVolumeUpdateEvent
@@ -174,7 +174,7 @@ var mpvPropertyHandler = map[string]func(value any){
 		} else {
 			data.Volume = value.(float64)
 		}
-		global.EventManager.CallA(events.PlayerPropertyVolumeUpdate, data)
+		_ = global.EventBus.Publish(events.PlayerPropertyVolumeUpdate, data)
 	},
 }
 
@@ -190,9 +190,9 @@ func registerHandler() {
 }
 
 func registerCmdHandler() {
-	global.EventManager.RegisterA(events.PlayerPlayCmd, "player.play", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPlayCmd, "player.play", func(evnt *eventbus.Event) {
 		currentState = currentState.NextState(model.PlayerStateLoading)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlayerPropertyStateUpdate,
 			events.PlayerPropertyStateUpdateEvent{
 				State: currentState,
@@ -202,7 +202,7 @@ func registerCmdHandler() {
 		if m, err := miaosic.GetMediaInfo(media.Info.Meta); err == nil {
 			media.Info = m
 		}
-		global.EventManager.CallA(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
 			Media:   media,
 			Removed: false,
 		})
@@ -213,7 +213,7 @@ func registerCmdHandler() {
 			if err := libmpv.Command([]string{"stop"}); err != nil {
 				log.Error("[MPV PlayControl] failed to stop", err)
 			}
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayErrorUpdate,
 				events.PlayerPlayErrorUpdateEvent{
 					Error: err,
@@ -253,7 +253,7 @@ func registerCmdHandler() {
 		log.Debug("[MPV PlayControl] mpv command", cmd)
 		if err := libmpv.Command(cmd); err != nil {
 			log.Error("[MPV PlayControl] mpv load media failed", cmd, mediaInfo, err)
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayErrorUpdate,
 				events.PlayerPlayErrorUpdateEvent{
 					Error: err,
@@ -261,19 +261,19 @@ func registerCmdHandler() {
 			return
 		}
 		currentState = currentState.NextState(model.PlayerStatePlaying)
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlayerPropertyStateUpdate,
 			events.PlayerPropertyStateUpdateEvent{
 				State: currentState,
 			})
-		global.EventManager.CallA(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
 			TimePos: 0,
 		})
-		global.EventManager.CallA(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
 			PercentPos: 0,
 		})
 	})
-	global.EventManager.RegisterA(events.PlayerToggleCmd, "player.toggle", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerToggleCmd, "player.toggle", func(evnt *eventbus.Event) {
 		property, err := libmpv.GetProperty("pause", mpv.FORMAT_FLAG)
 		if err != nil {
 			log.Warn("[MPV PlayControl] get property pause failed", err)
@@ -284,14 +284,14 @@ func registerCmdHandler() {
 			log.Warn("[MPV PlayControl] toggle pause failed", err)
 		}
 	})
-	global.EventManager.RegisterA(events.PlayerSetPauseCmd, "player.set_paused", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSetPauseCmd, "player.set_paused", func(evnt *eventbus.Event) {
 		data := evnt.Data.(events.PlayerSetPauseCmdEvent)
 		err := libmpv.SetProperty("pause", mpv.FORMAT_FLAG, data.Pause)
 		if err != nil {
 			log.Warn("[MPV PlayControl] set pause failed", err)
 		}
 	})
-	global.EventManager.RegisterA(events.PlayerSeekCmd, "player.seek", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSeekCmd, "player.seek", func(evnt *eventbus.Event) {
 		data := evnt.Data.(events.PlayerSeekCmdEvent)
 		log.Debugf("seek to %f (absolute=%t)", data.Position, data.Absolute)
 		var err error
@@ -304,7 +304,7 @@ func registerCmdHandler() {
 			log.Warn("seek failed", err)
 		}
 	})
-	global.EventManager.RegisterA(events.PlayerVolumeChangeCmd, "player.volume", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerVolumeChangeCmd, "player.volume", func(evnt *eventbus.Event) {
 		data := evnt.Data.(events.PlayerVolumeChangeCmdEvent)
 		err := libmpv.SetProperty("volume", mpv.FORMAT_DOUBLE, data.Volume)
 		if err != nil {
@@ -312,7 +312,7 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerVideoPlayerSetWindowHandleCmd, "player.set_window_handle", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerVideoPlayerSetWindowHandleCmd, "player.set_window_handle", func(evnt *eventbus.Event) {
 		handle := evnt.Data.(events.PlayerVideoPlayerSetWindowHandleCmdEvent).Handle
 		err := SetWindowHandle(handle)
 		if err != nil {
@@ -320,11 +320,11 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerSetAudioDeviceCmd, "player.set_audio_device", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSetAudioDeviceCmd, "player.set_audio_device", func(evnt *eventbus.Event) {
 		device := evnt.Data.(events.PlayerSetAudioDeviceCmdEvent).Device
 		err := libmpv.SetPropertyString("audio-device", device)
 		if err != nil {
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.ErrorUpdate,
 				events.ErrorUpdateEvent{
 					Error: err,
@@ -359,7 +359,7 @@ func updateAudioDeviceList() {
 		return true
 	})
 	log.Infof("update audio device list %v, current %s", dl, ad)
-	global.EventManager.CallA(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
+	_ = global.EventBus.Publish(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
 		Current: ad,
 		Devices: dl,
 	})

internal/player/vlc/config.go

@@ -3,7 +3,7 @@ package vlc
 import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 )
 
 type playerConfig struct {
@@ -30,17 +30,17 @@ var cfg = &playerConfig{
 }
 
 func restoreConfig() {
-	global.EventManager.CallA(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
+	_ = global.EventBus.Publish(events.PlayerVolumeChangeCmd, events.PlayerVolumeChangeCmdEvent{
 		Volume: cfg.Volume,
 	})
-	global.EventManager.RegisterA(events.PlayerPropertyVolumeUpdate, "player.config.volume", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyVolumeUpdate, "player.config.volume", func(evnt *eventbus.Event) {
 		data := evnt.Data.(events.PlayerPropertyVolumeUpdateEvent)
 		if data.Volume < 0 {
 			return
 		}
 		cfg.Volume = data.Volume
 	})
-	global.EventManager.CallA(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
+	_ = global.EventBus.Publish(events.PlayerSetAudioDeviceCmd, events.PlayerSetAudioDeviceCmdEvent{
 		Device: cfg.AudioDevice,
 	})
 }

internal/player/vlc/vlc.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"fmt"
 	"github.com/AynaLivePlayer/miaosic"
@@ -133,10 +133,10 @@ func StopPlayer() {
 func registerEvents() {
 	// 播放结束事件
 	_, err := eventManager.Attach(vlc.MediaPlayerEndReached, func(e vlc.Event, userData interface{}) {
-		global.EventManager.CallA(events.PlayerPropertyStateUpdate, events.PlayerPropertyStateUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyStateUpdate, events.PlayerPropertyStateUpdateEvent{
 			State: model.PlayerStateIdle,
 		})
-		global.EventManager.CallA(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
 			Media:   model.Media{},
 			Removed: true,
 		})
@@ -158,10 +158,10 @@ func registerEvents() {
 			}
 			prevTimePos = timePos
 			prevPercentPos = percentPos
-			global.EventManager.CallA(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
+			_ = global.EventBus.Publish(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
 				TimePos: timePos,
 			})
-			global.EventManager.CallA(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
+			_ = global.EventBus.Publish(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
 				PercentPos: percentPos,
 			})
 		}
@@ -174,7 +174,7 @@ func registerEvents() {
 	_, err = eventManager.Attach(vlc.MediaPlayerTimeChanged, func(e vlc.Event, userData interface{}) {
 		dur, _ := player.MediaLength()
 		duration = float64(dur) / 1000.0 // 转换为秒
-		global.EventManager.CallA(events.PlayerPropertyDurationUpdate, events.PlayerPropertyDurationUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyDurationUpdate, events.PlayerPropertyDurationUpdateEvent{
 			Duration: duration,
 		})
 	}, nil)
@@ -185,7 +185,7 @@ func registerEvents() {
 	// 暂停状态改变
 	_, err = eventManager.Attach(vlc.MediaPlayerPaused, func(e vlc.Event, userData interface{}) {
 		log.Debug("VLC player paused")
-		global.EventManager.CallA(events.PlayerPropertyPauseUpdate, events.PlayerPropertyPauseUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyPauseUpdate, events.PlayerPropertyPauseUpdateEvent{
 			Paused: true,
 		})
 	}, nil)
@@ -195,7 +195,7 @@ func registerEvents() {
 
 	_, err = eventManager.Attach(vlc.MediaPlayerPlaying, func(e vlc.Event, userData interface{}) {
 		log.Debug("VLC player playing")
-		global.EventManager.CallA(events.PlayerPropertyPauseUpdate, events.PlayerPropertyPauseUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyPauseUpdate, events.PlayerPropertyPauseUpdateEvent{
 			Paused: false,
 		})
 	}, nil)
@@ -206,14 +206,14 @@ func registerEvents() {
 	_, err = eventManager.Attach(vlc.MediaPlayerAudioVolume, func(e vlc.Event, userData interface{}) {
 		volume, _ := player.Volume()
 		log.Debug("VLC player audio volume: ", volume)
-		global.EventManager.CallA(events.PlayerPropertyVolumeUpdate, events.PlayerPropertyVolumeUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyVolumeUpdate, events.PlayerPropertyVolumeUpdateEvent{
 			Volume: float64(volume),
 		})
 	}, nil)
 }
 
 func registerCmdHandler() {
-	global.EventManager.RegisterA(events.PlayerPlayCmd, "player.play", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPlayCmd, "player.play", func(evnt *eventbus.Event) {
 		lock.Lock()
 		defer lock.Unlock()
 
@@ -223,7 +223,7 @@ func registerCmdHandler() {
 		mediaUrls, err := miaosic.GetMediaUrl(mediaInfo.Meta, miaosic.QualityAny)
 		if err != nil || len(mediaUrls) == 0 {
 			log.Warn("[VLC PlayControl] get media url failed ", mediaInfo.Meta.ID(), err)
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayErrorUpdate,
 				events.PlayerPlayErrorUpdateEvent{
 					Error: err,
@@ -265,7 +265,7 @@ func registerCmdHandler() {
 		}
 		currentMedia = mediaData
 
-		global.EventManager.CallA(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPlayingUpdate, events.PlayerPlayingUpdateEvent{
 			Media:   mediaData,
 			Removed: false,
 		})
@@ -290,18 +290,18 @@ func registerCmdHandler() {
 		// 重置位置信息
 		prevPercentPos = 0
 		prevTimePos = 0
-		global.EventManager.CallA(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyTimePosUpdate, events.PlayerPropertyTimePosUpdateEvent{
 			TimePos: 0,
 		})
-		global.EventManager.CallA(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyPercentPosUpdate, events.PlayerPropertyPercentPosUpdateEvent{
 			PercentPos: 0,
 		})
-		global.EventManager.CallA(events.PlayerPropertyStateUpdate, events.PlayerPropertyStateUpdateEvent{
+		_ = global.EventBus.Publish(events.PlayerPropertyStateUpdate, events.PlayerPropertyStateUpdateEvent{
 			State: model.PlayerStatePlaying,
 		})
 	})
 
-	global.EventManager.RegisterA(events.PlayerToggleCmd, "player.toggle", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerToggleCmd, "player.toggle", func(evnt *eventbus.Event) {
 		lock.Lock()
 		defer lock.Unlock()
 		err := player.TogglePause()
@@ -311,7 +311,7 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerSetPauseCmd, "player.set_paused", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSetPauseCmd, "player.set_paused", func(evnt *eventbus.Event) {
 		lock.Lock()
 		defer lock.Unlock()
 		data := evnt.Data.(events.PlayerSetPauseCmdEvent)
@@ -322,7 +322,7 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerSeekCmd, "player.seek", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSeekCmd, "player.seek", func(evnt *eventbus.Event) {
 		lock.Lock()
 		defer lock.Unlock()
 		data := evnt.Data.(events.PlayerSeekCmdEvent)
@@ -333,7 +333,7 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerVolumeChangeCmd, "player.volume", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerVolumeChangeCmd, "player.volume", func(evnt *eventbus.Event) {
 		lock.Lock()
 		defer lock.Unlock()
 		data := evnt.Data.(events.PlayerVolumeChangeCmdEvent)
@@ -343,16 +343,16 @@ func registerCmdHandler() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerVideoPlayerSetWindowHandleCmd, "player.set_window_handle", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerVideoPlayerSetWindowHandleCmd, "player.set_window_handle", func(evnt *eventbus.Event) {
 		handle := evnt.Data.(events.PlayerVideoPlayerSetWindowHandleCmdEvent).Handle
 		setWindowHandle(handle)
 	})
 
-	global.EventManager.RegisterA(events.PlayerSetAudioDeviceCmd, "player.set_audio_device", func(evnt *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerSetAudioDeviceCmd, "player.set_audio_device", func(evnt *eventbus.Event) {
 		device := evnt.Data.(events.PlayerSetAudioDeviceCmdEvent).Device
 		if err := setAudioDevice(device); err != nil {
 			log.Warn("set audio device failed", err)
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.ErrorUpdate,
 				events.ErrorUpdateEvent{
 					Error: err,
@@ -393,7 +393,7 @@ func setAudioDevice(deviceID string) error {
 	cfg.AudioDevice = deviceID
 
 	// 发送更新事件
-	global.EventManager.CallA(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
+	_ = global.EventBus.Publish(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
 		Current: currentAudioDevice,
 		Devices: audioDevices,
 	})
@@ -437,7 +437,7 @@ func updateAudioDeviceList() {
 		len(audioDevices), currentAudioDevice)
 
 	// 发送事件通知
-	global.EventManager.CallA(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
+	_ = global.EventBus.Publish(events.PlayerAudioDeviceUpdate, events.PlayerAudioDeviceUpdateEvent{
 		Current: currentAudioDevice,
 		Devices: audioDevices,
 	})

internal/playlist/model.go

@@ -4,7 +4,7 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"math/rand"
 	"sync"
 	"time"
@@ -44,34 +44,34 @@ func newPlaylist(id model.PlaylistID) *playlist {
 		Lock:       sync.RWMutex{},
 		Index:      0,
 	}
-	global.EventManager.RegisterA(events.PlaylistMoveCmd(id), "internal.playlist.move", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistMoveCmd(id), "internal.playlist.move", func(event *eventbus.Event) {
 		e := event.Data.(events.PlaylistMoveCmdEvent)
 		pl.Move(e.From, e.To)
 	})
-	global.EventManager.RegisterA(events.PlaylistInsertCmd(id), "internal.playlist.insert", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistInsertCmd(id), "internal.playlist.insert", func(event *eventbus.Event) {
 		e := event.Data.(events.PlaylistInsertCmdEvent)
 		pl.Insert(e.Position, e.Media)
 	})
-	global.EventManager.RegisterA(events.PlaylistDeleteCmd(id), "internal.playlist.delete", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistDeleteCmd(id), "internal.playlist.delete", func(event *eventbus.Event) {
 		e := event.Data.(events.PlaylistDeleteCmdEvent)
 		pl.Delete(e.Index)
 	})
-	global.EventManager.RegisterA(events.PlaylistNextCmd(id), "internal.playlist.next", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistNextCmd(id), "internal.playlist.next", func(event *eventbus.Event) {
 		log.Infof("Playlist %s recieve next", id)
 		pl.Next(event.Data.(events.PlaylistNextCmdEvent).Remove)
 	})
-	global.EventManager.RegisterA(events.PlaylistModeChangeCmd(id), "internal.playlist.mode", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistModeChangeCmd(id), "internal.playlist.mode", func(event *eventbus.Event) {
 		pl.Lock.Lock()
 		pl.mode = event.Data.(events.PlaylistModeChangeCmdEvent).Mode
 		pl.Index = 0
 		pl.resetRandomIndex()
 		pl.Lock.Unlock()
 		log.Infof("Playlist %s mode changed to %d", id, pl.mode)
-		global.EventManager.CallA(events.PlaylistModeChangeUpdate(id), events.PlaylistModeChangeUpdateEvent{
+		_ = global.EventBus.Publish(events.PlaylistModeChangeUpdate(id), events.PlaylistModeChangeUpdateEvent{
 			Mode: pl.mode,
 		})
 	})
-	global.EventManager.RegisterA(events.PlaylistSetIndexCmd(id), "internal.playlist.setindex", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlaylistSetIndexCmd(id), "internal.playlist.setindex", func(event *eventbus.Event) {
 		index := event.Data.(events.PlaylistSetIndexCmdEvent).Index
 		if index >= pl.Size() || index < 0 {
 			index = 0
@@ -98,7 +98,7 @@ func (p *playlist) Replace(medias []model.Media) {
 	p.Index = 0
 	p.resetRandomIndex()
 	p.Lock.Unlock()
-	global.EventManager.CallA(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
 		Medias: p.CopyMedia(),
 	})
 }
@@ -118,11 +118,11 @@ func (p *playlist) Insert(index int, media model.Media) {
 	p.Medias[index] = media
 	p.resetRandomIndex()
 	p.Lock.Unlock()
-	global.EventManager.CallA(events.PlaylistInsertUpdate(p.playlistId), events.PlaylistInsertUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistInsertUpdate(p.playlistId), events.PlaylistInsertUpdateEvent{
 		Position: index,
 		Media:    media,
 	})
-	global.EventManager.CallA(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
 		Medias: p.CopyMedia(),
 	})
 }
@@ -140,7 +140,7 @@ func (p *playlist) Delete(index int) {
 	}
 	p.resetRandomIndex()
 	p.Lock.Unlock()
-	global.EventManager.CallA(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
 		Medias: p.CopyMedia(),
 	})
 }
@@ -170,7 +170,7 @@ func (p *playlist) Move(src int, dst int) {
 	}
 	p.Medias[dst] = tmp
 	p.Lock.Unlock()
-	global.EventManager.CallA(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistDetailUpdate(p.playlistId), events.PlaylistDetailUpdateEvent{
 		Medias: p.CopyMedia(),
 	})
 }
@@ -215,7 +215,7 @@ func (p *playlist) Next(delete bool) {
 	//	}
 	//}
 	p.Lock.Unlock()
-	global.EventManager.CallA(events.PlaylistNextUpdate(p.playlistId), events.PlaylistNextUpdateEvent{
+	_ = global.EventBus.Publish(events.PlaylistNextUpdate(p.playlistId), events.PlaylistNextUpdateEvent{
 		Media: m,
 	})
 	if delete {

internal/playlist/playlist.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"github.com/AynaLivePlayer/miaosic"
 )
@@ -56,22 +56,22 @@ func Initialize() {
 	HistoryPlaylist = newPlaylist(model.PlaylistIDHistory)
 	config.LoadConfig(cfg)
 
-	global.EventManager.CallA(events.PlaylistModeChangeCmd(model.PlaylistIDPlayer), events.PlaylistModeChangeCmdEvent{
+	_ = global.EventBus.Publish(events.PlaylistModeChangeCmd(model.PlaylistIDPlayer), events.PlaylistModeChangeCmdEvent{
 		Mode: cfg.PlayerPlaylistMode,
 	})
 
-	global.EventManager.CallA(events.PlaylistModeChangeCmd(model.PlaylistIDSystem), events.PlaylistModeChangeCmdEvent{
+	_ = global.EventBus.Publish(events.PlaylistModeChangeCmd(model.PlaylistIDSystem), events.PlaylistModeChangeCmdEvent{
 		Mode: cfg.SystemPlaylistMode,
 	})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayingUpdate,
 		"internal.playlist.player_playing_update",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			if event.Data.(events.PlayerPlayingUpdateEvent).Removed {
 				return
 			}
-			global.EventManager.CallA(events.PlaylistInsertCmd(model.PlaylistIDHistory), events.PlaylistInsertCmdEvent{
+			_ = global.EventBus.Publish(events.PlaylistInsertCmd(model.PlaylistIDHistory), events.PlaylistInsertCmdEvent{
 				Media:    event.Data.(events.PlayerPlayingUpdateEvent).Media,
 				Position: -1,
 			})

internal/playlist/playlists.go

@@ -4,7 +4,7 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"errors"
 	"github.com/AynaLivePlayer/miaosic"
 )
@@ -25,21 +25,21 @@ func createPlaylistManager() {
 		currentSelected = cfg.playlists[0].Meta.ID()
 	}
 
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.PlaylistManagerCurrentUpdate,
 		events.PlaylistManagerCurrentUpdateEvent{
 			Medias: make([]model.Media, 0),
 		})
 
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.PlaylistManagerSetSystemCmd,
 		events.PlaylistManagerSetSystemCmdEvent{
 			PlaylistID: cfg.SystemPlaylistID,
 		})
 
-	global.EventManager.RegisterA(events.PlaylistManagerSetSystemCmd,
+	global.EventBus.Subscribe("", events.PlaylistManagerSetSystemCmd,
 		"internal.playlist.system_playlist.set",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerSetSystemCmdEvent)
 			// default case
 			if data.PlaylistID == "" {
@@ -48,7 +48,7 @@ func createPlaylistManager() {
 			log.Infof("try to set system playlist %s", data.PlaylistID)
 			pl, ok := allPlaylists[data.PlaylistID]
 			if !ok {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("playlist not found"),
@@ -56,7 +56,7 @@ func createPlaylistManager() {
 				return
 			}
 			cfg.SystemPlaylistID = pl.Meta.ID()
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlaylistManagerSystemUpdate,
 				events.PlaylistManagerSystemUpdateEvent{
 					Info: model.PlaylistInfo{
@@ -75,10 +75,10 @@ func createPlaylistManager() {
 			SystemPlaylist.Replace(medias)
 
 		})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistManagerRefreshCurrentCmd,
 		"internal.playlist.current_playlist.refresh",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerRefreshCurrentCmdEvent)
 			log.Infof("try to refresh playlist %s", data.PlaylistID)
 			currentSelected = data.PlaylistID
@@ -88,7 +88,7 @@ func createPlaylistManager() {
 			}
 			pl, ok := allPlaylists[data.PlaylistID]
 			if !ok {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("playlist not found"),
@@ -97,7 +97,7 @@ func createPlaylistManager() {
 			}
 			getPlaylist, err := miaosic.GetPlaylist(pl.Meta)
 			if err != nil {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: err,
@@ -109,10 +109,10 @@ func createPlaylistManager() {
 			updatePlaylistManagerInfos()
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistManagerGetCurrentCmd,
 		"internal.playlist.current_playlist.get",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerGetCurrentCmdEvent)
 			log.Infof("try to get playlist %s", data.PlaylistID)
 			currentSelected = data.PlaylistID
@@ -122,7 +122,7 @@ func createPlaylistManager() {
 			}
 			pl, ok := allPlaylists[data.PlaylistID]
 			if !ok {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("playlist not found"),
@@ -132,15 +132,15 @@ func createPlaylistManager() {
 			updateCurrenMedias(pl)
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistManagerAddPlaylistCmd,
 		"internal.playlist.add_playlist",
-		func(event *event.Event) {
+		func(event *eventbus.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(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("not proper url"),
@@ -149,7 +149,7 @@ func createPlaylistManager() {
 			}
 			_, ok = allPlaylists[meta.ID()]
 			if ok {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("playlist already exists"),
@@ -158,7 +158,7 @@ func createPlaylistManager() {
 			}
 			pl, err := miaosic.GetPlaylist(meta)
 			if err != nil {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: err,
@@ -169,13 +169,13 @@ func createPlaylistManager() {
 			updatePlaylistManagerInfos()
 		})
 
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistManagerRemovePlaylistCmd,
 		"internal.playlist.remove_playlist",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlaylistManagerRemovePlaylistCmdEvent)
 			if data.PlaylistID == cfg.SystemPlaylistID {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("cannot remove system playlist"),
@@ -184,7 +184,7 @@ func createPlaylistManager() {
 			}
 			_, ok := allPlaylists[data.PlaylistID]
 			if !ok {
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.ErrorUpdate,
 					events.ErrorUpdateEvent{
 						Error: errors.New("playlist not found"),
@@ -205,7 +205,7 @@ func updateCurrenMedias(pl *miaosic.Playlist) {
 			User: model.SystemUser,
 		}
 	}
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.PlaylistManagerCurrentUpdate,
 		events.PlaylistManagerCurrentUpdateEvent{
 			Medias: medias,
@@ -225,7 +225,7 @@ func updatePlaylistManagerInfos() {
 		})
 	}
 	log.InfoW("update playlist manager infos")
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.PlaylistManagerInfoUpdate,
 		events.PlaylistManagerInfoUpdateEvent{
 			Playlists: playlists,

internal/source/nosource.go

@@ -30,7 +30,7 @@ var sourceCfg = &_sourceConfig{
 func Initialize() {
 	config.LoadConfig(sourceCfg)
 	miaosic.RegisterProvider(&dummySource{})
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.MediaProviderUpdate, events.MediaProviderUpdateEvent{
 			Providers: miaosic.ListAvailableProviders(),
 		})

internal/source/source.go

@@ -38,7 +38,7 @@ func Initialize() {
 	kugou.UseInstrumental()
 	miaosic.RegisterProvider(local.NewLocal(sourceCfg.LocalSourcePath))
 
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.MediaProviderUpdate, events.MediaProviderUpdateEvent{
 			Providers: miaosic.ListAvailableProviders(),
 		})

internal/sysmediacontrol/smtc_windows.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/core/events"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"github.com/go-ole/go-ole"
 	"github.com/saltosystems/winrt-go"
@@ -84,7 +84,7 @@ func InitSystemMediaControl() {
 		_ = updater.SetType(media.MediaPlaybackTypeMusic)
 	})
 
-	global.EventManager.RegisterA(events.PlayerPlayingUpdate, "sysmediacontrol.update_playing", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPlayingUpdate, "sysmediacontrol.update_playing", func(event *eventbus.Event) {
 		data := event.Data.(events.PlayerPlayingUpdateEvent)
 		withMusicProperties(func(updater *media.SystemMediaTransportControlsDisplayUpdater, properties *media.MusicDisplayProperties) {
 			properties.SetArtist(data.Media.Info.Artist)
@@ -106,7 +106,7 @@ func InitSystemMediaControl() {
 		}
 	})
 
-	global.EventManager.RegisterA(events.PlayerPropertyPauseUpdate, "sysmediacontrol.update_paused", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyPauseUpdate, "sysmediacontrol.update_paused", func(event *eventbus.Event) {
 		if event.Data.(events.PlayerPropertyPauseUpdateEvent).Paused {
 			smtc.SetPlaybackStatus(media.MediaPlaybackStatusPaused)
 		} else {
@@ -121,16 +121,16 @@ func InitSystemMediaControl() {
 			defer eventArgs.Release()
 			switch val, _ := eventArgs.GetButton(); val {
 			case media.SystemMediaTransportControlsButtonPlay:
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.PlayerSetPauseCmd, events.PlayerSetPauseCmdEvent{Pause: false})
 			case media.SystemMediaTransportControlsButtonPause:
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.PlayerSetPauseCmd, events.PlayerSetPauseCmdEvent{Pause: true})
 			case media.SystemMediaTransportControlsButtonNext:
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
 			case media.SystemMediaTransportControlsButtonPrevious:
-				global.EventManager.CallA(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
+				_ = global.EventBus.Publish(events.PlayerSeekCmd, events.PlayerSeekCmdEvent{
 					Position: 0,
 					Absolute: true,
 				})
@@ -146,7 +146,7 @@ func InitSystemMediaControl() {
 	lastDuration := int64(0)
 	lastTimePos := int64(0)
 	timelineProps, _ = media.NewSystemMediaTransportControlsTimelineProperties()
-	global.EventManager.RegisterA(events.PlayerPropertyDurationUpdate, "sysmediacontrol.properties.duration", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyDurationUpdate, "sysmediacontrol.properties.duration", func(event *eventbus.Event) {
 		data := event.Data.(events.PlayerPropertyDurationUpdateEvent)
 		lastDuration = int64(data.Duration * 1000)
 		_ = timelineProps.SetStartTime(foundation.TimeSpan{Duration: 0})
@@ -156,7 +156,7 @@ func InitSystemMediaControl() {
 		_ = timelineProps.SetPosition(foundation.TimeSpan{Duration: lastTimePos * TicksPerMillisecond})
 		_ = smtc.UpdateTimelineProperties(timelineProps)
 	})
-	global.EventManager.RegisterA(events.PlayerPropertyTimePosUpdate, "sysmediacontrol.properties.time_pos", func(event *event.Event) {
+	global.EventBus.Subscribe("", events.PlayerPropertyTimePosUpdate, "sysmediacontrol.properties.time_pos", func(event *eventbus.Event) {
 		data := event.Data.(events.PlayerPropertyTimePosUpdateEvent)
 		lastTimePos = int64(data.TimePos * 1000)
 		_ = timelineProps.SetStartTime(foundation.TimeSpan{Duration: 0})

internal/updater/application.go

@@ -5,7 +5,7 @@ import (
 	"AynaLivePlayer/core/model"
 	"AynaLivePlayer/global"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/logger"
 	"github.com/go-resty/resty/v2"
 	"github.com/tidwall/gjson"
@@ -22,7 +22,7 @@ func Initialize() {
 			if !hasUpdate {
 				return
 			}
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.CheckUpdateResultUpdate,
 				events.CheckUpdateResultUpdateEvent{
 					HasUpdate: hasUpdate,
@@ -30,11 +30,11 @@ func Initialize() {
 				})
 		}()
 	}
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.CheckUpdateCmd, "internal.updater.handle",
-		func(evt *event.Event) {
+		func(evt *eventbus.Event) {
 			info, hasUpdate := CheckUpdate()
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.CheckUpdateResultUpdate,
 				events.CheckUpdateResultUpdateEvent{
 					HasUpdate: hasUpdate,

pkg/event/event.go

@@ -1,165 +0,0 @@
-package event
-
-import (
-	"fmt"
-	"sync"
-)
-
-type EventId string
-
-type Event struct {
-	Id   EventId
-	Data interface{}
-	lock sync.Mutex // just placed for now, i don't know why i place it here, seems useless
-}
-
-type HandlerFunc func(event *Event)
-
-type Handler struct {
-	EventId EventId
-	Name    string
-	Handler HandlerFunc
-}
-
-type Manager struct {
-	handlers         map[EventId]map[string]*Handler
-	eventWorkerIdMap map[EventId]int
-	pendingEvents    []*Event
-	workerQueue      []chan func()
-	currentWorkerId  int
-	stopSig          chan int
-	queueSize        int
-	workerSize       int
-	dispatching      bool
-	lock             sync.RWMutex
-}
-
-func NewManger(queueSize int, workerSize int) *Manager {
-	manager := &Manager{
-		handlers:         make(map[EventId]map[string]*Handler),
-		eventWorkerIdMap: make(map[EventId]int),
-		workerQueue:      make([]chan func(), workerSize),
-		currentWorkerId:  0,
-		stopSig:          make(chan int, workerSize),
-		queueSize:        queueSize,
-		workerSize:       workerSize,
-		lock:             sync.RWMutex{},
-		dispatching:      false,
-		pendingEvents:    make([]*Event, 0),
-	}
-	for i := 0; i < workerSize; i++ {
-		queue := make(chan func(), queueSize)
-		manager.workerQueue[i] = queue
-		go func() {
-			for {
-				select {
-				case <-manager.stopSig:
-					return
-				case f := <-queue:
-					f()
-				}
-			}
-		}()
-	}
-	return manager
-}
-
-// Start for starting to dispatching events
-func (h *Manager) Start() {
-	h.dispatching = true
-	for _, event := range h.pendingEvents {
-		h.Call(event)
-	}
-}
-
-func (h *Manager) Stop() {
-	for i := 0; i < h.workerSize; i++ {
-		h.stopSig <- 0
-	}
-	h.dispatching = false
-}
-
-func (h *Manager) Register(handler *Handler) {
-	h.lock.Lock()
-	m, ok := h.handlers[handler.EventId]
-	// if not found, crate new handler map and assign a worker to this event id
-	if !ok {
-		m = make(map[string]*Handler)
-		h.handlers[handler.EventId] = m
-		// assign a worker to this event id
-		h.eventWorkerIdMap[handler.EventId] = h.currentWorkerId
-		h.currentWorkerId = (h.currentWorkerId + 1) % h.workerSize
-	}
-	if _, ok := m[handler.Name]; ok {
-		fmt.Printf("handler %s already registered, old handler is overwrittened\n", handler.Name)
-	}
-	m[handler.Name] = handler
-	h.lock.Unlock()
-}
-
-func (h *Manager) RegisterA(id EventId, name string, handler HandlerFunc) {
-	h.Register(&Handler{
-		EventId: id,
-		Name:    name,
-		Handler: handler,
-	})
-}
-
-func (h *Manager) UnregisterAll() {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-	h.handlers = make(map[EventId]map[string]*Handler)
-	h.currentWorkerId = 0
-	h.eventWorkerIdMap = make(map[EventId]int)
-}
-
-func (h *Manager) Unregister(name string) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-	for _, m := range h.handlers {
-		if _, ok := m[name]; ok {
-			delete(m, name)
-		}
-	}
-}
-
-func (h *Manager) Call(event *Event) {
-
-	// if not dispatching, put this event to pending events
-	h.lock.Lock()
-	if !h.dispatching {
-		h.pendingEvents = append(h.pendingEvents, event)
-		h.lock.Unlock()
-		return
-	}
-
-	handlers, ok := h.handlers[event.Id]
-	if !ok {
-		h.lock.Unlock()
-		return
-	}
-	workerId, ok := h.eventWorkerIdMap[event.Id]
-	if !ok {
-		// event id don't have a worker id, ignore
-		// maybe because this event id has no handler
-		h.lock.Unlock()
-		return
-	}
-
-	h.lock.Unlock()
-	for _, eh := range handlers {
-		eventHandler := eh
-		h.workerQueue[workerId] <- func() {
-			event.lock.Lock()
-			eventHandler.Handler(event)
-			event.lock.Unlock()
-		}
-	}
-}
-
-func (h *Manager) CallA(id EventId, data interface{}) {
-	h.Call(&Event{
-		Id:   id,
-		Data: data,
-	})
-}

plugin/diange/diange.go

@@ -8,7 +8,7 @@ import (
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/xfyne"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"fyne.io/fyne/v2"
@@ -131,14 +131,14 @@ func (d *Diange) Enable() error {
 	config.LoadConfig(d)
 	gui.AddConfigLayout(d)
 	gui.AddConfigLayout(&blacklist{})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomMessageReceive,
 		"plugin.diange.message",
 		d.handleMessage)
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlaylistDetailUpdate(model.PlaylistIDPlayer),
 		"plugin.diange.queue.update",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			d.currentQueueLength = len(event.Data.(events.PlaylistDetailUpdateEvent).Medias)
 			d.log.Debugf("current queue length: %d", d.currentQueueLength)
 			medias := event.Data.(events.PlaylistDetailUpdateEvent).Medias
@@ -157,10 +157,10 @@ func (d *Diange) Enable() error {
 				d.log.Debugf("user media count in player playlist %s: %d", user, count)
 			}
 		})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayingUpdate,
 		"plugin.diange.check_playing",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPlayingUpdateEvent)
 			if data.Removed {
 				d.isCurrentSystem = true
@@ -216,7 +216,7 @@ func (d *Diange) getSource(cmd string) []string {
 	return sources
 }
 
-func (d *Diange) handleMessage(event *event.Event) {
+func (d *Diange) handleMessage(event *eventbus.Event) {
 	message := event.Data.(events.LiveRoomMessageReceiveEvent).Message
 	msgs := strings.Split(message.Message, " ")
 	if len(msgs) < 2 || len(msgs[0]) == 0 {
@@ -333,7 +333,7 @@ func (d *Diange) handleMessage(event *event.Event) {
 			}
 		}
 		if d.SkipSystemPlaylist && d.isCurrentSystem {
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayCmd,
 				events.PlayerPlayCmdEvent{
 					Media: model.Media{
@@ -343,7 +343,7 @@ func (d *Diange) handleMessage(event *event.Event) {
 				})
 			return
 		}
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlaylistInsertCmd(model.PlaylistIDPlayer),
 			events.PlaylistInsertCmdEvent{
 				Position: -1,

plugin/durationmgmt/durationmgmt.go

@@ -6,7 +6,7 @@ import (
 	"AynaLivePlayer/gui"
 	"AynaLivePlayer/gui/xfyne"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"fyne.io/fyne/v2"
@@ -43,33 +43,33 @@ func (d *MaxDuration) Name() string {
 func (d *MaxDuration) Enable() error {
 	config.LoadConfig(d)
 	gui.AddConfigLayout(d)
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPropertyDurationUpdate,
 		"plugin.maxduration.duration",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyDurationUpdateEvent)
 			if int(data.Duration) > d.MaxDuration && d.SkipOnPlay {
 				d.log.Infof("Skip on reach max duration %.2f/%d (on play)", data.Duration, d.MaxDuration)
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
 			}
 		})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPropertyTimePosUpdate,
 		"plugin.maxduration.timepos",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyTimePosUpdateEvent)
 			if int(data.TimePos) > d.MaxDuration && d.SkipOnReach && !d.skipped {
 				d.log.Infof("Skip on reach max duration %.2f/%d (on time pos reach)", data.TimePos, d.MaxDuration)
 				d.skipped = true
-				global.EventManager.CallA(
+				_ = global.EventBus.Publish(
 					events.PlayerPlayNextCmd, events.PlayerPlayNextCmdEvent{})
 			}
 		})
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayingUpdate,
 		"plugin.maxduration.play",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			d.skipped = false
 		})
 	return nil

plugin/qiege/qiege.go

@@ -7,7 +7,7 @@ import (
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/xfyne"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"fyne.io/fyne/v2"
@@ -45,14 +45,14 @@ func (d *Qiege) Name() string {
 func (d *Qiege) Enable() error {
 	config.LoadConfig(d)
 	gui.AddConfigLayout(d)
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.LiveRoomMessageReceive,
 		"plugin.qiege.message",
 		d.handleMessage)
-	global.EventManager.RegisterA(
+	global.EventBus.Subscribe("",
 		events.PlayerPlayingUpdate,
 		"plugin.qiege.playing",
-		func(event *event.Event) {
+		func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPlayingUpdateEvent)
 			if data.Removed {
 				d.currentUid = ""
@@ -69,7 +69,7 @@ func (d *Qiege) Disable() error {
 	return nil
 }
 
-func (d *Qiege) handleMessage(event *event.Event) {
+func (d *Qiege) handleMessage(event *eventbus.Event) {
 	message := event.Data.(events.LiveRoomMessageReceiveEvent).Message
 	msgs := strings.Split(message.Message, " ")
 	if len(msgs) < 1 || msgs[0] != d.CustomCMD {
@@ -78,20 +78,20 @@ func (d *Qiege) handleMessage(event *event.Event) {
 	d.log.Infof("recieve qiege command")
 	if d.UserPermission {
 		if d.currentUid == message.User.Uid {
-			global.EventManager.CallA(
+			_ = global.EventBus.Publish(
 				events.PlayerPlayNextCmd,
 				events.PlayerPlayNextCmdEvent{})
 			return
 		}
 	}
 	if d.PrivilegePermission && message.User.Privilege > 0 {
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlayerPlayNextCmd,
 			events.PlayerPlayNextCmdEvent{})
 		return
 	}
 	if d.AdminPermission && message.User.Admin {
-		global.EventManager.CallA(
+		_ = global.EventBus.Publish(
 			events.PlayerPlayNextCmd,
 			events.PlayerPlayNextCmdEvent{})
 		return

plugin/sourcelogin/sourcelogin.go

@@ -124,7 +124,7 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
 		func() {
 			err := loginables[providerChoice.Selected].(miaosic.Loginable).Logout()
 			if err != nil {
-				global.EventManager.CallA(events.ErrorUpdate,
+				_ = global.EventBus.Publish(events.ErrorUpdate,
 					events.ErrorUpdateEvent{Error: err})
 				return
 			}
@@ -152,14 +152,14 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
 			provider := pvdr.(miaosic.Loginable)
 			currentLoginSession, err = provider.QrLogin()
 			if err != nil {
-				global.EventManager.CallA(events.ErrorUpdate,
+				_ = global.EventBus.Publish(events.ErrorUpdate,
 					events.ErrorUpdateEvent{Error: err})
 				return
 			}
 			w.log.Debugf("trying encode url %s to qrcode", currentLoginSession.Url)
 			data, err := qrcode.Encode(currentLoginSession.Url, qrcode.Medium, 256)
 			if err != nil {
-				global.EventManager.CallA(events.ErrorUpdate,
+				_ = global.EventBus.Publish(events.ErrorUpdate,
 					events.ErrorUpdateEvent{Error: err})
 				return
 			}
@@ -184,7 +184,7 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
 			w.log.Info("checking qr status")
 			result, err := provider.QrLoginVerify(currentLoginSession)
 			if err != nil {
-				global.EventManager.CallA(events.ErrorUpdate,
+				_ = global.EventBus.Publish(events.ErrorUpdate,
 					events.ErrorUpdateEvent{Error: err})
 				return
 			}

plugin/textinfo/textinfo.go

@@ -7,7 +7,7 @@ import (
 	"AynaLivePlayer/gui"
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"bytes"
@@ -190,8 +190,8 @@ func (t *TextInfo) OutputCover() {
 }
 
 func (t *TextInfo) registerHandlers() {
-	global.EventManager.RegisterA(
-		events.PlayerPlayingUpdate, "plugin.textinfo.playing", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlayerPlayingUpdate, "plugin.textinfo.playing", func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPlayingUpdateEvent)
 			if data.Removed {
 				t.info.Current = MediaInfo{}
@@ -201,8 +201,8 @@ func (t *TextInfo) registerHandlers() {
 			t.RenderTemplates()
 			t.OutputCover()
 		})
-	global.EventManager.RegisterA(
-		events.PlayerPropertyTimePosUpdate, "plugin.txtinfo.timepos", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlayerPropertyTimePosUpdate, "plugin.txtinfo.timepos", func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyTimePosUpdateEvent).TimePos
 			ct := int(data)
 			if ct == t.info.CurrentTime.TotalSeconds {
@@ -211,8 +211,8 @@ func (t *TextInfo) registerHandlers() {
 			t.info.CurrentTime = NewTimeFromSec(ct)
 			t.RenderTemplates()
 		})
-	global.EventManager.RegisterA(
-		events.PlayerPropertyDurationUpdate, "plugin.txtinfo.duration", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlayerPropertyDurationUpdate, "plugin.txtinfo.duration", func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerPropertyDurationUpdateEvent).Duration
 			ct := int(data)
 			if ct == t.info.TotalTime.TotalSeconds {
@@ -221,8 +221,8 @@ func (t *TextInfo) registerHandlers() {
 			t.info.TotalTime = NewTimeFromSec(ct)
 			t.RenderTemplates()
 		})
-	global.EventManager.RegisterA(
-		events.PlaylistDetailUpdate(model.PlaylistIDPlayer), "plugin.textinfo.playlist", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlaylistDetailUpdate(model.PlaylistIDPlayer), "plugin.textinfo.playlist", func(event *eventbus.Event) {
 			pl := make([]MediaInfo, 0)
 			data := event.Data.(events.PlaylistDetailUpdateEvent)
 			for index, m := range data.Medias {
@@ -232,8 +232,8 @@ func (t *TextInfo) registerHandlers() {
 			t.info.PlaylistLength = len(pl)
 			t.RenderTemplates()
 		})
-	global.EventManager.RegisterA(
-		events.PlayerLyricPosUpdate, "plugin.textinfo.lyricpos", func(event *event.Event) {
+	global.EventBus.Subscribe("",
+		events.PlayerLyricPosUpdate, "plugin.textinfo.lyricpos", func(event *eventbus.Event) {
 			data := event.Data.(events.PlayerLyricPosUpdateEvent)
 			t.info.Lyric = data.CurrentLine.Lyric
 			t.RenderTemplates()

plugin/webinfo/info.go

@@ -1,35 +0,0 @@
-package webinfo
-
-import (
-	"AynaLivePlayer/core/model"
-)
-
-type MediaInfo struct {
-	Index    int
-	Title    string
-	Artist   string
-	Album    string
-	Username string
-	Cover    model.Picture
-}
-
-type OutInfo struct {
-	Current     MediaInfo
-	CurrentTime int
-	TotalTime   int
-	Lyric       string
-	Playlist    []MediaInfo
-}
-
-const (
-	OutInfoC  = "Current"
-	OutInfoCT = "CurrentTime"
-	OutInfoTT = "TotalTime"
-	OutInfoL  = "Lyric"
-	OutInfoPL = "Playlists"
-)
-
-type WebsocketData struct {
-	Update string
-	Data   OutInfo
-}

plugin/webinfo/server.go

@@ -1,234 +0,0 @@
-package webinfo
-
-import (
-	"AynaLivePlayer/pkg/config"
-	"context"
-	"encoding/json"
-	"fmt"
-	"github.com/gorilla/websocket"
-	"net/http"
-	"sync"
-)
-
-var upgrader = websocket.Upgrader{
-	ReadBufferSize:  1024,
-	WriteBufferSize: 1024,
-	CheckOrigin: func(r *http.Request) bool {
-		return true
-	},
-}
-
-type WebInfoServer struct {
-	Info      OutInfo
-	Port      int
-	ServerMux *http.ServeMux
-	Server    *http.Server
-	Clients   map[*Client]int
-	Running   bool
-	Store     *TemplateStore
-	lock      sync.Mutex
-	log       adapter.ILogger
-}
-
-type Client struct {
-	conn  *websocket.Conn
-	Data  chan []byte
-	Close chan byte
-}
-
-func NewWebInfoServer(port int, log adapter.ILogger) *WebInfoServer {
-	server := &WebInfoServer{
-		Store:   newTemplateStore(WebTemplateStorePath),
-		Port:    port,
-		Info:    OutInfo{Playlist: make([]MediaInfo, 0)},
-		Clients: map[*Client]int{},
-		log:     log,
-	}
-	mux := http.NewServeMux()
-	mux.Handle("/", http.FileServer(http.Dir(config.GetAssetPath("webinfo"))))
-	mux.HandleFunc("/ws/info", server.handleInfo)
-	mux.HandleFunc("/api/info", server.getInfo)
-	mux.HandleFunc("/api/template/list", server.tmplList)
-	mux.HandleFunc("/api/template/get", server.tmplGet)
-	mux.HandleFunc("/api/template/save", server.tmplSave)
-	server.ServerMux = mux
-
-	return server
-}
-
-func (s *WebInfoServer) tmplList(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	//w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
-	d, _ := json.Marshal(s.Store.List())
-	_, err := w.Write(d)
-	if err != nil {
-		s.log.Warnf("/api/template/list error: %s", err)
-		return
-	}
-}
-
-func (s *WebInfoServer) tmplGet(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	name := r.URL.Query().Get("name")
-	if name == "" {
-		name = "default"
-	}
-	d, _ := json.Marshal(s.Store.Get(name))
-	_, err := w.Write(d)
-	if err != nil {
-		s.log.Warnf("/api/template/get error: %s", err)
-		return
-	}
-}
-
-func (s *WebInfoServer) tmplSave(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	w.Header().Set("Access-Control-Allow-Method", "*")
-	w.Header().Set("Access-Control-Allow-Credentials", "true")
-	w.Header().Set("Access-Control-Expose-Headers", "*")
-	w.Header().Set("Access-Control-Allow-Headers", "*")
-	s.log.Info(r.Method)
-	if r.Method == "OPTIONS" {
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-	if r.Method != "POST" {
-		w.WriteHeader(http.StatusMethodNotAllowed)
-		return
-	}
-	if err := r.ParseMultipartForm(1 << 16); err != nil {
-		s.log.Warnf("ParseForm() err: %v", err)
-		return
-	}
-	name := r.FormValue("name")
-	tmpl := r.FormValue("template")
-	if name == "" {
-		name = "default"
-	}
-	s.log.Infof("change template %s", name)
-	s.Store.Modify(name, tmpl)
-	d, _ := json.Marshal(s.Store.Get(name))
-	_, err := w.Write(d)
-	if err != nil {
-		s.log.Warnf("/api/template/save error: %s", err)
-		return
-	}
-	s.Store.Save(WebTemplateStorePath)
-}
-
-func (s *WebInfoServer) getInfo(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	//w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
-	d, _ := json.Marshal(s.Info)
-	_, err := w.Write(d)
-	if err != nil {
-		s.log.Warnf("api get info error: %s", err)
-		return
-	}
-}
-
-func (s *WebInfoServer) handleInfo(w http.ResponseWriter, r *http.Request) {
-	s.log.Debug("connection start")
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		s.log.Warnf("upgrade error: %s", err)
-		return
-	}
-	client := &Client{
-		conn:  conn,
-		Data:  make(chan []byte, 16),
-		Close: make(chan byte, 1),
-	}
-	s.addClient(client)
-	defer s.removeClient(client)
-	go func() {
-		for {
-			_, _, err := client.conn.ReadMessage()
-			if err != nil {
-				client.Close <- 1
-			}
-		}
-	}()
-	for {
-		s.log.Debug("waiting for message")
-		select {
-		case data := <-client.Data:
-			writer, err := client.conn.NextWriter(websocket.TextMessage)
-			if err != nil {
-				s.log.Warn("get writer error", err)
-				return
-			}
-
-			if _, err = writer.Write(data); err != nil {
-				s.log.Warn("send error:", err)
-				return
-			}
-			if err = writer.Close(); err != nil {
-				s.log.Warnf("can't close writer: %s", err)
-				return
-			}
-		case _ = <-client.Close:
-			s.log.Debug("client close")
-			if err := client.conn.Close(); err != nil {
-				s.log.Warnf("close connection encouter an error: %s", err)
-			}
-			return
-		}
-	}
-}
-
-func (s *WebInfoServer) SendInfo(update string, info OutInfo) {
-	for client := range s.Clients {
-		d, _ := json.Marshal(WebsocketData{Update: update, Data: info})
-		client.Data <- d
-	}
-}
-
-func (s *WebInfoServer) addClient(c *Client) {
-	s.lock.Lock()
-	s.Clients[c] = 1
-	s.lock.Unlock()
-}
-
-func (s *WebInfoServer) removeClient(c *Client) {
-	s.lock.Lock()
-	close(c.Data)
-	delete(s.Clients, c)
-	s.lock.Unlock()
-}
-
-func (s *WebInfoServer) Start() {
-	s.log.Debug("WebInfoServer starting...")
-	s.Running = true
-	go func() {
-		s.Server = &http.Server{
-			Addr:    fmt.Sprintf("localhost:%d", s.Port),
-			Handler: s.ServerMux,
-		}
-		err := s.Server.ListenAndServe()
-		s.Running = false
-		if err == http.ErrServerClosed {
-			s.log.Info("WebInfoServer closed")
-			return
-		}
-		if err != nil {
-			s.log.Warnf("Failed to start webinfo server: %s", err)
-			return
-		}
-	}()
-}
-
-func (s *WebInfoServer) Stop() error {
-	s.log.Debug("WebInfoServer stopping...")
-	s.lock.Lock()
-	s.Clients = map[*Client]int{}
-	s.lock.Unlock()
-	if s.Server != nil {
-		return s.Server.Shutdown(context.TODO())
-	}
-	return nil
-}

plugin/webinfo/template.go

@@ -1,76 +0,0 @@
-package webinfo
-
-import (
-	"AynaLivePlayer/pkg/util"
-	"encoding/json"
-	"io/ioutil"
-)
-
-const WebTemplateStorePath = "./webtemplates.json"
-
-type WebTemplate struct {
-	Name     string
-	Template string
-}
-
-type TemplateStore struct {
-	Templates map[string]*WebTemplate
-}
-
-func newTemplateStore(filename string) *TemplateStore {
-	s := &TemplateStore{Templates: map[string]*WebTemplate{}}
-	var templates []*WebTemplate
-	file, err := ioutil.ReadFile(filename)
-	if err == nil {
-		_ = json.Unmarshal(file, &templates)
-	}
-
-	for _, tmpl := range templates {
-		s.Templates[tmpl.Name] = tmpl
-	}
-	return s
-}
-
-func (s *TemplateStore) Save(filename string) {
-	templates := make([]WebTemplate, 0)
-	for _, tmp := range s.Templates {
-		templates = append(templates, *tmp)
-	}
-	unescape, err := util.MarshalIndentUnescape(templates, "", "    ")
-	if err != nil {
-		lg.Warnf("save web templates to %s failed: %s", filename, err)
-		return
-	}
-	if err := ioutil.WriteFile(filename, []byte(unescape), 0666); err != nil {
-		lg.Warnf("save web templates to %s failed: %s", filename, err)
-		return
-	}
-}
-
-func (s *TemplateStore) Get(name string) *WebTemplate {
-	if t, ok := s.Templates[name]; ok {
-		return t
-	}
-	t := &WebTemplate{Name: name, Template: "<p>Empty</p>"}
-	s.Templates[name] = t
-	return t
-}
-
-func (s *TemplateStore) Modify(name string, content string) {
-	if _, ok := s.Templates[name]; ok {
-		s.Templates[name].Template = content
-		return
-	}
-}
-
-func (s *TemplateStore) List() []string {
-	names := make([]string, 0)
-	for name, _ := range s.Templates {
-		names = append(names, name)
-	}
-	return names
-}
-
-func (s *TemplateStore) Delete(name string) {
-	delete(s.Templates, name)
-}

plugin/webinfo/template_test.go

@@ -1,22 +0,0 @@
-package webinfo
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestTemplateStore_Create(t *testing.T) {
-	s := newTemplateStore(WebTemplateStorePath)
-	s.Get("A")
-	s.Get("B")
-	s.Modify("A", "33333")
-	s.Save(WebTemplateStorePath)
-}
-
-func TestTemplateStore_Load(t *testing.T) {
-	s := newTemplateStore(WebTemplateStorePath)
-	fmt.Println(s.List())
-	for name, tmpl := range s.Templates {
-		fmt.Println(name, tmpl.Template)
-	}
-}

plugin/webinfo/webinfo.go

@@ -1,249 +0,0 @@
-package webinfo
-
-import (
-	"AynaLivePlayer/adapters/logger"
-	"AynaLivePlayer/core/adapter"
-	"AynaLivePlayer/core/events"
-	"AynaLivePlayer/core/model"
-	"AynaLivePlayer/gui"
-	"AynaLivePlayer/gui/component"
-	"AynaLivePlayer/gui/xfyne"
-	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
-	"AynaLivePlayer/pkg/i18n"
-	"AynaLivePlayer/pkg/util"
-	"fmt"
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/data/binding"
-	"fyne.io/fyne/v2/theme"
-	"fyne.io/fyne/v2/widget"
-)
-
-const MODULE_PLGUIN_WEBINFO = "plugin.webinfo"
-
-var lg adapter.ILogger = &logger.EmptyLogger{}
-
-type WebInfo struct {
-	config.BaseConfig
-	Enabled bool
-	Port    int
-	server  *WebInfoServer
-	panel   fyne.CanvasObject
-	ctr     adapter.IControlBridge
-	log     adapter.ILogger
-}
-
-func NewWebInfo(ctr adapter.IControlBridge) *WebInfo {
-	lg = ctr.Logger().WithModule(MODULE_PLGUIN_WEBINFO)
-	return &WebInfo{
-		Enabled: true,
-		Port:    4000,
-		ctr:     ctr,
-		log:     ctr.Logger().WithModule(MODULE_PLGUIN_WEBINFO),
-	}
-}
-
-func (w *WebInfo) Name() string {
-	return "WebInfo"
-}
-
-func (w *WebInfo) Title() string {
-	return i18n.T("plugin.webinfo.title")
-}
-
-func (w *WebInfo) Description() string {
-	return i18n.T("plugin.webinfo.description")
-}
-
-func (w *WebInfo) Enable() error {
-	config.LoadConfig(w)
-	w.server = NewWebInfoServer(w.Port, w.log)
-	w.registerHandlers()
-	gui.AddConfigLayout(w)
-	w.log.Info("webinfo loaded")
-	if w.Enabled {
-		w.log.Info("starting web backend server")
-		w.server.Start()
-	}
-	return nil
-}
-
-func (w *WebInfo) Disable() error {
-	w.log.Info("closing webinfo backend server")
-	if err := w.server.Stop(); err != nil {
-		w.log.Warnf("stop webinfo server encouter an error: %s", err)
-	}
-	return nil
-}
-
-func (w *WebInfo) registerHandlers() {
-	w.ctr.PlayControl().EventManager().RegisterA(events.EventPlay, "plugin.webinfo.current", func(event *event.Event) {
-		w.server.Info.Current = MediaInfo{
-			Index:    0,
-			Title:    event.Data.(events.PlayEvent).Media.Title,
-			Artist:   event.Data.(events.PlayEvent).Media.Artist,
-			Album:    event.Data.(events.PlayEvent).Media.Album,
-			Cover:    event.Data.(events.PlayEvent).Media.Cover,
-			Username: event.Data.(events.PlayEvent).Media.ToUser().Name,
-		}
-		w.server.SendInfo(
-			OutInfoC,
-			OutInfo{Current: w.server.Info.Current},
-		)
-	})
-	if w.ctr.PlayControl().GetPlayer().ObserveProperty(
-		model.PlayerPropTimePos, "plugin.webinfo.timepos", func(event *event.Event) {
-			data := event.Data.(events.PlayerPropertyUpdateEvent).Value
-			if data == nil {
-				w.server.Info.CurrentTime = 0
-				return
-			}
-			ct := int(data.(float64))
-			if ct == w.server.Info.CurrentTime {
-				return
-			}
-			w.server.Info.CurrentTime = ct
-			w.server.SendInfo(
-				OutInfoCT,
-				OutInfo{CurrentTime: w.server.Info.CurrentTime},
-			)
-		}) != nil {
-		w.log.Error("register time-pos handler failed")
-	}
-	if w.ctr.PlayControl().GetPlayer().ObserveProperty(
-		model.PlayerPropDuration, "plugin.webinfo.duration", func(event *event.Event) {
-			data := event.Data.(events.PlayerPropertyUpdateEvent).Value
-			if data == nil {
-				w.server.Info.TotalTime = 0
-				return
-			}
-			w.server.Info.TotalTime = int(data.(float64))
-			w.server.SendInfo(
-				OutInfoTT,
-				OutInfo{TotalTime: w.server.Info.TotalTime},
-			)
-		}) != nil {
-		w.log.Error("fail to register handler for total time with property duration")
-	}
-	w.ctr.Playlists().GetCurrent().EventManager().RegisterA(
-		events.EventPlaylistUpdate, "plugin.webinfo.playlist", func(event *event.Event) {
-			pl := make([]MediaInfo, 0)
-			e := event.Data.(events.PlaylistUpdateEvent)
-			for index, m := range e.Playlist.Medias {
-				pl = append(pl, MediaInfo{
-					Index:    index,
-					Title:    m.Title,
-					Artist:   m.Artist,
-					Album:    m.Album,
-					Username: m.ToUser().Name,
-				})
-			}
-			w.server.Info.Playlist = pl
-			w.server.SendInfo(
-				OutInfoPL,
-				OutInfo{Playlist: w.server.Info.Playlist},
-			)
-		})
-	w.ctr.PlayControl().GetLyric().EventManager().RegisterA(
-		events.EventLyricUpdate, "plugin.webinfo.lyric", func(event *event.Event) {
-			lrcLine := event.Data.(events.LyricUpdateEvent).Lyric
-			w.server.Info.Lyric = lrcLine.Now.Lyric
-			w.server.SendInfo(
-				OutInfoL,
-				OutInfo{Lyric: w.server.Info.Lyric},
-			)
-		})
-}
-
-func (w *WebInfo) getServerStatusText() string {
-	if w.server.Running {
-		return i18n.T("plugin.webinfo.server_status.running")
-	} else {
-		return i18n.T("plugin.webinfo.server_status.stopped")
-	}
-}
-
-func (w *WebInfo) getServerUrl() string {
-	return fmt.Sprintf("http://localhost:%d/#/previewV2", w.Port)
-}
-
-func (w *WebInfo) CreatePanel() fyne.CanvasObject {
-	if w.panel != nil {
-		return w.panel
-	}
-
-	statusText := widget.NewLabel("")
-	serverStatus := container.NewHBox(
-		widget.NewLabel(i18n.T("plugin.webinfo.server_status")),
-		statusText,
-	)
-	autoStart := container.NewHBox(
-		widget.NewLabel(i18n.T("plugin.webinfo.autostart")),
-		component.NewCheckOneWayBinding("", &w.Enabled, w.Enabled))
-	statusText.SetText(w.getServerStatusText())
-	serverPort := container.NewBorder(nil, nil,
-		widget.NewLabel(i18n.T("plugin.webinfo.port")), nil,
-		xfyne.EntryDisableUndoRedo(widget.NewEntryWithData(binding.IntToString(binding.BindInt(&w.Port)))),
-	)
-	serverUrl := widget.NewHyperlink(w.getServerUrl(), util.UrlMustParse(w.getServerUrl()))
-	serverPreview := container.NewHBox(
-		widget.NewLabel(i18n.T("plugin.webinfo.server_preview")),
-		serverUrl,
-	)
-	stopBtn := component.NewAsyncButtonWithIcon(
-		i18n.T("plugin.webinfo.server_control.stop"),
-		theme.MediaStopIcon(),
-		func() {
-			if !w.server.Running {
-				return
-			}
-			w.log.Info("User try stop webinfo server")
-			err := w.server.Stop()
-			if err != nil {
-				w.log.Warnf("stop server have error: %s", err)
-				return
-			}
-			statusText.SetText(w.getServerStatusText())
-		},
-	)
-	startBtn := component.NewAsyncButtonWithIcon(
-		i18n.T("plugin.webinfo.server_control.start"),
-		theme.MediaPlayIcon(),
-		func() {
-			if w.server.Running {
-				return
-			}
-			w.log.Infof("User try start webinfo server with port %d", w.Port)
-			w.server.Port = w.Port
-			w.server.Start()
-			statusText.SetText(w.getServerStatusText())
-			serverUrl.SetText(w.getServerUrl())
-			_ = serverUrl.SetURLFromString(w.getServerUrl())
-		},
-	)
-	restartBtn := component.NewAsyncButtonWithIcon(
-		i18n.T("plugin.webinfo.server_control.restart"),
-		theme.MediaReplayIcon(),
-		func() {
-			w.log.Infof("User try restart webinfo server with port %d", w.Port)
-			if w.server.Running {
-				if err := w.server.Stop(); err != nil {
-					w.log.Warnf("stop server have error: %s", err)
-					return
-				}
-			}
-			w.server.Port = w.Port
-			w.server.Start()
-			statusText.SetText(w.getServerStatusText())
-			serverUrl.SetText(w.getServerUrl())
-			_ = serverUrl.SetURLFromString(w.getServerUrl())
-		},
-	)
-	ctrlBtns := container.NewHBox(
-		widget.NewLabel(i18n.T("plugin.webinfo.server_control")),
-		startBtn, stopBtn, restartBtn,
-	)
-	w.panel = container.NewVBox(serverStatus, autoStart, serverPreview, serverPort, ctrlBtns)
-	return w.panel
-}

plugin/wshub/events.go

@@ -1,17 +1,16 @@
 package wshub
 
 import (
-	"AynaLivePlayer/pkg/event"
 	"encoding/json"
 )
 
 type EventData struct {
-	EventID event.EventId
+	EventID string
 	Data    interface{}
 }
 
 type EventDataReceived struct {
-	EventID event.EventId
+	EventID string
 	Data    json.RawMessage
 }
 

plugin/wshub/server.go

@@ -49,7 +49,7 @@ func (c *wsClient) start() {
 			return
 		}
 		if globalEnableWsHubControl {
-			global.EventManager.CallA(data.EventID, actualEventData)
+			_ = global.EventBus.Publish(data.EventID, actualEventData)
 		}
 	}
 }

plugin/wshub/wshub.go

@@ -7,7 +7,7 @@ import (
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/xfyne"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"fyne.io/fyne/v2"
@@ -175,9 +175,9 @@ func (w *WsHub) registerEvents() {
 	for eid, _ := range events.EventsMapping {
 		eventCache = append(eventCache, &EventData{})
 		currentIdx := i
-		global.EventManager.RegisterA(eid,
+		global.EventBus.Subscribe("", eid,
 			"plugin.wshub.event."+string(eid),
-			func(e *event.Event) {
+			func(e *eventbus.Event) {
 				ed := EventData{
 					EventID: e.Id,
 					Data:    e.Data,

plugin/yinliang/yinliang.go

@@ -7,7 +7,7 @@ import (
 	"AynaLivePlayer/gui/component"
 	"AynaLivePlayer/gui/xfyne"
 	"AynaLivePlayer/pkg/config"
-	"AynaLivePlayer/pkg/event"
+	"AynaLivePlayer/pkg/eventbus"
 	"AynaLivePlayer/pkg/i18n"
 	"AynaLivePlayer/pkg/logger"
 	"fmt"
@@ -67,15 +67,15 @@ func (y *Yinliang) Enable() error {
 
 	gui.AddConfigLayout(y)
 
-	global.EventManager.RegisterA(
+	_ = global.EventBus.Subscribe("",
 		events.LiveRoomMessageReceive,
 		"plugin.yinliang.message",
 		y.handleMessage)
 
-	global.EventManager.RegisterA(
+	_ = global.EventBus.Subscribe("",
 		events.PlayerVolumeChangeCmd,
 		"plugin.yinliang.volume_tracker",
-		func(e *event.Event) {
+		func(e *eventbus.Event) {
 			data := e.Data.(events.PlayerVolumeChangeCmdEvent)
 			y.currentVolume = data.Volume
 		})
@@ -86,7 +86,7 @@ func (y *Yinliang) Disable() error {
 	return nil
 }
 
-func (y *Yinliang) handleMessage(event *event.Event) {
+func (y *Yinliang) handleMessage(event *eventbus.Event) {
 	if !y.Enabled {
 		return
 	}
@@ -115,7 +115,7 @@ func (y *Yinliang) handleMessage(event *event.Event) {
 	}
 	y.log.Infof("User <%s> modify volume from %.2f to %.2f", message.User.Username, y.currentVolume, newVolume)
 
-	global.EventManager.CallA(
+	_ = global.EventBus.Publish(
 		events.PlayerVolumeChangeCmd,
 		events.PlayerVolumeChangeCmdEvent{
 			Volume: newVolume,