GitHub/AynaLivePlayer
1
0
Fork 0
mirror of https://github.com/AynaLivePlayer/AynaLivePlayer.git synced 2026-03-15 05:53:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

move all internal call to eventbus

Browse Source
This commit is contained in:
aynakeya
2026-02-19 11:10:42 +08:00
parent daae9b7cc4
commit 0fa54c6346
14 changed files with 594 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
plugin/diange/diange.go
View File

@@ -168,20 +168,24 @@ func (d *Diange) Enable() error {
}
d.isCurrentSystem = (!data.Media.IsLiveRoomUser()) && (data.Media.ToUser().Name == model.SystemUser.Name)
})
// check if all available source has a command in sourceConfigs, if not add this source to sourceConfigs
// actually, if default config exists, then this code does nothing.
prvdrs := miaosic.ListAvailableProviders()
for _, pvdr := range prvdrs {
// found pvdr in command list
if _, ok := d.sourceConfigs[pvdr]; ok {
continue
}
d.sourceConfigs[pvdr] = &sourceConfig{
Enable: true,
Command: "点" + pvdr + "歌",
Priority: len(d.sourceConfigs) + 1,
}
}
global.EventBus.Subscribe("",
events.MediaProviderUpdate,
"plugin.diange.provider.update",
func(event *eventbus.Event) {
// check if all available source has a command in sourceConfigs, if not add this source to sourceConfigs
// actually, if default config exists, then this code does nothing.
data := event.Data.(events.MediaProviderUpdateEvent)
for _, pvdr := range data.Providers {
if _, ok := d.sourceConfigs[pvdr]; ok {
continue
}
d.sourceConfigs[pvdr] = &sourceConfig{
Enable: true,
Command: "点" + pvdr + "歌",
Priority: len(d.sourceConfigs) + 1,
}
}
})
return nil
}
@@ -216,6 +220,22 @@ func (d *Diange) getSource(cmd string) []string {
return sources
}
func (d *Diange) searchByProvider(provider, keywords string) ([]model.Media, error) {
resp, err := global.EventBus.Call(
events.CmdMiaosicSearch,
events.ReplyMiaosicSearch,
events.CmdMiaosicSearchData{
Keyword: keywords,
Provider: provider,
},
)
if err != nil {
return nil, err
}
reply := resp.Data.(events.ReplyMiaosicSearchData)
return reply.Medias, reply.Error
}
func (d *Diange) handleMessage(event *eventbus.Event) {
message := event.Data.(events.LiveRoomMessageReceiveEvent).Message
msgs := strings.Split(message.Message, " ")
@@ -292,7 +312,20 @@ func (d *Diange) handleMessage(event *eventbus.Event) {
var mediaMeta miaosic.MetaData
found := false
for _, source := range sources {
mediaMeta, found = miaosic.MatchMediaByProvider(source, keywords)
resp, err := global.EventBus.Call(
events.CmdMiaosicMatchMediaByProvider,
events.ReplyMiaosicMatchMediaByProvider,
events.CmdMiaosicMatchMediaByProviderData{
Provider: source,
Keyword: keywords,
},
)
if err != nil {
continue
}
match := resp.Data.(events.ReplyMiaosicMatchMediaByProviderData)
mediaMeta = match.Meta
found = match.Found
if found {
break
}
@@ -302,22 +335,34 @@ func (d *Diange) handleMessage(event *eventbus.Event) {
if !found {
for _, source := range sources {
medias, err := miaosic.SearchByProvider(source, keywords, 1, 10)
medias, err := d.searchByProvider(source, keywords)
if len(medias) == 0 || err != nil {
continue
}
media = medias[0]
media = medias[0].Info
found = true
break
}
} else {
d.log.Info("Match media: ", mediaMeta)
m, err := miaosic.GetMediaInfo(mediaMeta)
resp, err := global.EventBus.Call(
events.CmdMiaosicGetMediaInfo,
events.ReplyMiaosicGetMediaInfo,
events.CmdMiaosicGetMediaInfoData{
Meta: mediaMeta,
},
)
if err != nil {
d.log.Error("Get media info failed: ", err)
found = false
} else {
reply := resp.Data.(events.ReplyMiaosicGetMediaInfoData)
if reply.Error != nil {
d.log.Error("Get media info failed: ", reply.Error)
found = false
}
media = reply.Info
}
media = m
}
if found {
@@ -410,11 +455,7 @@ func (d *Diange) CreatePanel() fyne.CanvasObject {
skipPlaylistCheck,
)
sourceCfgs := []fyne.CanvasObject{}
prvdrs := miaosic.ListAvailableProviders()
for source, cfg := range d.sourceConfigs {
if !slices.Contains(prvdrs, source) {
continue
}
sourceCfgs = append(
sourceCfgs, container.NewGridWithColumns(2,
widget.NewLabel(source),

213
plugin/sourcelogin/sourcelogin.go
View File

@@ -6,6 +6,7 @@ import (
"AynaLivePlayer/gui/component"
config2 "AynaLivePlayer/gui/views/config"
"AynaLivePlayer/pkg/config"
"AynaLivePlayer/pkg/eventbus"
"AynaLivePlayer/pkg/i18n"
"AynaLivePlayer/pkg/logger"
"AynaLivePlayer/resource"
@@ -55,15 +56,14 @@ func (w *SourceLogin) Enable() error {
func (w *SourceLogin) Disable() error {
w.log.Info("save session for all provider")
providers := miaosic.ListAvailableProviders()
for _, pname := range providers {
if p, ok := miaosic.GetProvider(pname); ok {
pl, ok2 := p.(miaosic.Loginable)
if ok2 {
w.log.Infof("save session for %s", pname)
w.sessions[pname] = pl.SaveSession()
}
for _, provider := range w.listLoginableProviders() {
w.log.Infof("save session for %s", provider)
session, err := w.saveSession(provider)
if err != nil {
w.log.Warnf("save session for %s failed: %v", provider, err)
continue
}
w.sessions[provider] = session
}
return nil
}
@@ -86,30 +86,16 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
widget.NewLabel(i18n.T("plugin.sourcelogin.current_user")),
currentUser)
providers := miaosic.ListAvailableProviders()
loginableProviders := make([]string, 0)
loginables := make(map[string]miaosic.MediaProvider)
for _, pname := range providers {
if p, ok := miaosic.GetProvider(pname); ok {
pl, ok2 := p.(miaosic.Loginable)
if ok2 {
loginableProviders = append(loginableProviders, pname)
loginables[pname] = p
if session, ok3 := w.sessions[pname]; ok3 {
err := pl.RestoreSession(session)
if err != nil {
w.log.Error("failed to restore session for ", pname)
}
}
}
}
}
providerChoice := widget.NewSelect(loginableProviders, func(s string) {
providerChoice := widget.NewSelect([]string{}, func(s string) {
w.log.Info("switching provider to ", s)
if s != "" {
pvdr, _ := miaosic.GetProvider(s)
provider := pvdr.(miaosic.Loginable)
if provider.IsLogin() {
isLogin, err := w.isLogin(s)
if err != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: err})
return
}
if isLogin {
currentUser.SetText(i18n.T("plugin.sourcelogin.current_user.loggedin"))
} else {
currentUser.SetText(i18n.T("plugin.sourcelogin.current_user.notlogin"))
@@ -119,11 +105,49 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
sourcePanel := container.NewGridWithColumns(2,
providerChoice, currentStatus)
restoredSessions := make(map[string]bool)
_ = global.EventBus.Subscribe("",
events.MediaProviderUpdate,
"plugin.sourcelogin.providers",
func(event *eventbus.Event) {
data := event.Data.(events.MediaProviderUpdateEvent)
loginableProviders := make([]string, 0)
for _, providerInfo := range data.ProviderInfos {
if providerInfo.Loginable {
loginableProviders = append(loginableProviders, providerInfo.Name)
}
}
for _, provider := range loginableProviders {
if restoredSessions[provider] {
continue
}
session, ok := w.sessions[provider]
if !ok || session == "" {
continue
}
restoredSessions[provider] = true
go func(providerName string, providerSession string) {
if err := w.restoreSession(providerName, providerSession); err != nil {
w.log.Warnf("failed to restore session for %s: %v", providerName, err)
}
}(provider, session)
}
fyne.DoAndWait(func() {
providerChoice.Options = loginableProviders
providerChoice.Refresh()
if providerChoice.Selected == "" && len(loginableProviders) > 0 {
providerChoice.SetSelected(loginableProviders[0])
}
})
})
logoutBtn := component.NewAsyncButton(
i18n.T("plugin.sourcelogin.logout"),
func() {
err := loginables[providerChoice.Selected].(miaosic.Loginable).Logout()
if providerChoice.Selected == "" {
return
}
err := w.logout(providerChoice.Selected)
if err != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: err})
@@ -153,14 +177,25 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
qrStatus.SetText("")
})
w.log.Info("getting a new qr code for login")
pvdr, _ := miaosic.GetProvider(providerChoice.Selected)
provider := pvdr.(miaosic.Loginable)
currentLoginSession, err = provider.QrLogin()
resp, err := global.EventBus.Call(
events.CmdMiaosicQrLogin,
events.ReplyMiaosicQrLogin,
events.CmdMiaosicQrLoginData{
Provider: providerChoice.Selected,
},
)
if err != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: err})
return
}
qrData := resp.Data.(events.ReplyMiaosicQrLoginData)
if qrData.Error != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: qrData.Error})
return
}
currentLoginSession = &qrData.Session
w.log.Debugf("trying encode url %s to qrcode", currentLoginSession.Url)
data, err := qrcode.Encode(currentLoginSession.Url, qrcode.Medium, 256)
if err != nil {
@@ -186,26 +221,43 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
if currentProvider == "" {
return
}
pvdr, _ := miaosic.GetProvider(currentProvider)
provider := pvdr.(miaosic.Loginable)
w.log.Info("checking qr status")
result, err := provider.QrLoginVerify(currentLoginSession)
resp, err := global.EventBus.Call(
events.CmdMiaosicQrLoginVerify,
events.ReplyMiaosicQrLoginVerify,
events.CmdMiaosicQrLoginVerifyData{
Provider: currentProvider,
Session: *currentLoginSession,
},
)
if err != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: err})
return
}
resultData := resp.Data.(events.ReplyMiaosicQrLoginVerifyData)
if resultData.Error != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: resultData.Error})
return
}
fyne.DoAndWait(func() {
qrStatus.SetText(result.Message)
qrStatus.SetText(resultData.Result.Message)
})
if result.Success {
if resultData.Result.Success {
currentLoginSession = nil
fyne.DoAndWait(func() {
qrcodeImg.Resource = resource.ImageEmptyQrCode
qrcodeImg.Refresh()
providerChoice.OnChanged(currentProvider)
})
w.sessions[currentProvider] = provider.SaveSession()
session, sessionErr := w.saveSession(currentProvider)
if sessionErr != nil {
_ = global.EventBus.Publish(events.ErrorUpdate,
events.ErrorUpdateEvent{Error: sessionErr})
return
}
w.sessions[currentProvider] = session
}
},
)
@@ -216,3 +268,84 @@ func (w *SourceLogin) CreatePanel() fyne.CanvasObject {
w.panel = container.NewVBox(sourcePanel, controlBox, qrImagePanel)
return w.panel
}
func (w *SourceLogin) listLoginableProviders() []string {
resp, err := global.EventBus.Call(
events.CmdMiaosicListProviders,
events.ReplyMiaosicListProviders,
events.CmdMiaosicListProvidersData{},
)
if err != nil {
w.log.Warnf("list providers failed: %v", err)
return []string{}
}
data := resp.Data.(events.ReplyMiaosicListProvidersData)
providers := make([]string, 0)
for _, provider := range data.Providers {
if provider.Loginable {
providers = append(providers, provider.Name)
}
}
return providers
}
func (w *SourceLogin) isLogin(provider string) (bool, error) {
resp, err := global.EventBus.Call(
events.CmdMiaosicIsLoginByProvider,
events.ReplyMiaosicIsLoginByProvider,
events.CmdMiaosicIsLoginByProviderData{
Provider: provider,
},
)
if err != nil {
return false, err
}
data := resp.Data.(events.ReplyMiaosicIsLoginByProviderData)
return data.IsLogin, data.Error
}
func (w *SourceLogin) logout(provider string) error {
resp, err := global.EventBus.Call(
events.CmdMiaosicLogoutByProvider,
events.ReplyMiaosicLogoutByProvider,
events.CmdMiaosicLogoutByProviderData{
Provider: provider,
},
)
if err != nil {
return err
}
data := resp.Data.(events.ReplyMiaosicLogoutByProviderData)
return data.Error
}
func (w *SourceLogin) restoreSession(provider, session string) error {
resp, err := global.EventBus.Call(
events.CmdMiaosicRestoreSessionByProvider,
events.ReplyMiaosicRestoreSessionByProvider,
events.CmdMiaosicRestoreSessionByProviderData{
Provider: provider,
Session: session,
},
)
if err != nil {
return err
}
data := resp.Data.(events.ReplyMiaosicRestoreSessionByProviderData)
return data.Error
}
func (w *SourceLogin) saveSession(provider string) (string, error) {
resp, err := global.EventBus.Call(
events.CmdMiaosicSaveSessionByProvider,
events.ReplyMiaosicSaveSessionByProvider,
events.CmdMiaosicSaveSessionByProviderData{
Provider: provider,
},
)
if err != nil {
return "", err
}
data := resp.Data.(events.ReplyMiaosicSaveSessionByProviderData)
return data.Session, data.Error
}