352 lines
9.7 KiB
Go
352 lines
9.7 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/gob"
|
|
"fmt"
|
|
"github.com/delucks/go-subsonic"
|
|
"github.com/diamondburned/gotk4/pkg/core/glib"
|
|
// "io"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
// "github.com/diamondburned/gotk4/pkg/gtk/v4"
|
|
"github.com/djherbis/fscache"
|
|
"github.com/zalando/go-keyring"
|
|
)
|
|
|
|
func TestConnButtonClicked() {
|
|
clientt := CreateUser(HttpSettings)
|
|
_, err := clientt.GetGenres()
|
|
if err != nil {
|
|
var up = func() bool {
|
|
SettingsTabUserStatusLabel.SetText("✗ ")
|
|
return false
|
|
}
|
|
glib.IdleAdd(up)
|
|
|
|
} else {
|
|
var up = func() bool {
|
|
SettingsTabUserStatusLabel.SetText("✓ ")
|
|
return false
|
|
}
|
|
glib.IdleAdd(up)
|
|
|
|
}
|
|
}
|
|
|
|
func CreateUser(httpsettings *http.Client) subsonic.Client {
|
|
server := SettingsTabUserServerEntry.Text()
|
|
username := SettingsTabUserUsernameEntry.Text()
|
|
device := SettingsTabUserDeviceNameEntry.Text()
|
|
pass := SettingsTabUserPasswordEntry.Text()
|
|
|
|
clientt := subsonic.Client{
|
|
Client: httpsettings,
|
|
BaseUrl: server,
|
|
User: username,
|
|
ClientName: device,
|
|
}
|
|
clientt.Authenticate(pass)
|
|
|
|
return clientt
|
|
}
|
|
|
|
type User struct {
|
|
User string
|
|
Url string
|
|
}
|
|
|
|
type Settings struct {
|
|
//User
|
|
Users [10]User
|
|
PlayerName string
|
|
|
|
//Local
|
|
DeleteOnClose bool
|
|
Coversize int16
|
|
BlurRadius int8
|
|
HideHeaderBar bool
|
|
|
|
//Transcoding
|
|
Codec string
|
|
Bitrate int16
|
|
DownladBufferSize int16
|
|
|
|
//Net
|
|
UseStreamingProxy bool
|
|
StreamingProxy string
|
|
AuthStreamingProxy bool
|
|
StreamingProxyUser string
|
|
|
|
// Metadata
|
|
MetadataType string
|
|
UseMetadataProxy bool
|
|
MetadataProxy string
|
|
AuthMetadataProxy bool
|
|
MetadataProxyUser string
|
|
}
|
|
|
|
// type SonicallyStream struct {
|
|
// ReadMaster fscache.ReadAtCloser
|
|
// WriteMaster io.WriteCloser
|
|
// }
|
|
|
|
func Serialize(obj Settings, path string) {
|
|
dataFile, err1 := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0664)
|
|
defer dataFile.Close()
|
|
if err1 == nil {
|
|
os.Remove(path)
|
|
}
|
|
dataFile, _ = os.Create(path)
|
|
e := gob.NewEncoder(dataFile)
|
|
if err := e.Encode(obj); err != nil {
|
|
LogFatalOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
}
|
|
|
|
func DeSerialize(path string) Settings {
|
|
dataFile, err := os.Open(path)
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
var sett Settings
|
|
dataDecoder := gob.NewDecoder(dataFile)
|
|
err = dataDecoder.Decode(&sett)
|
|
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
return sett
|
|
}
|
|
|
|
func SerializeArtist(obj subsonic.ArtistID3, path string) {
|
|
dataFile, err1 := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0664)
|
|
defer dataFile.Close()
|
|
if err1 == nil {
|
|
os.Remove(path)
|
|
}
|
|
dataFile, _ = os.Create(path)
|
|
e := gob.NewEncoder(dataFile)
|
|
if err := e.Encode(obj); err != nil {
|
|
LogFatalOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
}
|
|
|
|
func DeSerializeArtist(path string) subsonic.ArtistID3 {
|
|
dataFile, err := os.Open(path)
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
var sett subsonic.ArtistID3
|
|
dataDecoder := gob.NewDecoder(dataFile)
|
|
err = dataDecoder.Decode(&sett)
|
|
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
return sett
|
|
}
|
|
|
|
func SerializePlaylist(obj subsonic.Playlist, path string) {
|
|
dataFile, err1 := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0664)
|
|
defer dataFile.Close()
|
|
if err1 == nil {
|
|
os.Remove(path)
|
|
}
|
|
dataFile, _ = os.Create(path)
|
|
e := gob.NewEncoder(dataFile)
|
|
if err := e.Encode(obj); err != nil {
|
|
LogFatalOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
}
|
|
|
|
func DeSerializePlaylist(path string) subsonic.Playlist {
|
|
dataFile, err := os.Open(path)
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
var sett subsonic.Playlist
|
|
dataDecoder := gob.NewDecoder(dataFile)
|
|
err = dataDecoder.Decode(&sett)
|
|
|
|
if err != nil {
|
|
PanicOnError(err)
|
|
}
|
|
dataFile.Close()
|
|
return sett
|
|
}
|
|
|
|
func Init() {
|
|
fil, err1 := os.OpenFile(settingsPath, os.O_APPEND|os.O_WRONLY, 0664)
|
|
defer fil.Close()
|
|
if err1 == nil {
|
|
MainSettings = DeSerialize(settingsPath)
|
|
UserList = MainSettings.Users
|
|
UserDeserialized = MainSettings.Users[0]
|
|
|
|
clientt := subsonic.Client{
|
|
Client: HttpSettings,
|
|
BaseUrl: UserDeserialized.Url,
|
|
User: UserDeserialized.User,
|
|
ClientName: MainSettings.PlayerName,
|
|
}
|
|
|
|
sec, err := keyring.Get(UserDeserialized.Url, UserDeserialized.User)
|
|
if err == nil {
|
|
clientt.Authenticate(sec)
|
|
CurrentClient = clientt
|
|
SettingsTabUserUsernameEntry.SetText(UserDeserialized.User)
|
|
SettingsTabUserPasswordEntry.SetText(sec)
|
|
SettingsTabUserDeviceNameEntry.SetText(MainSettings.PlayerName)
|
|
SettingsTabUserServerEntry.SetText(UserDeserialized.Url)
|
|
SettingsTabAppDeleteSwitch.SetActive(MainSettings.DeleteOnClose)
|
|
SettingsTabAppHideHeaderBarSwitch.SetActive(MainSettings.HideHeaderBar)
|
|
|
|
SettingsTabAppCoverSizeEntry.SetText(strconv.Itoa(int(MainSettings.Coversize)))
|
|
SettingsTabAppBlurRadiusEntry.SetText(strconv.Itoa(int(MainSettings.BlurRadius)))
|
|
SettingsTabAppBitrateEntry.SetText(strconv.Itoa(int(MainSettings.Bitrate)))
|
|
SettingsTabAppBufferSizeEntry.SetText(strconv.Itoa(int(MainSettings.DownladBufferSize)))
|
|
SettingsTabAppStreamingProxySwitch.SetActive(MainSettings.UseStreamingProxy)
|
|
if MainSettings.UseStreamingProxy == true {
|
|
SettingsTabAppStreamingProxyEntry.SetText(MainSettings.StreamingProxy)
|
|
|
|
// var temptrans *http.Transport
|
|
var protocol, parsed string
|
|
|
|
if strings.Contains(MainSettings.StreamingProxy, "https") {
|
|
protocol = "https://"
|
|
parsed = MainSettings.StreamingProxy[8:]
|
|
} else if strings.Contains(MainSettings.StreamingProxy, "socks5") {
|
|
protocol = "socks5://"
|
|
parsed = MainSettings.StreamingProxy[9:]
|
|
} else if strings.Contains(MainSettings.StreamingProxy, "http") && !strings.Contains(MainSettings.StreamingProxy, "https") {
|
|
protocol = "http://"
|
|
parsed = MainSettings.StreamingProxy[7:]
|
|
} else {
|
|
log.Fatal("Unsupported protocol")
|
|
}
|
|
|
|
if SettingsTabAppAuthStreamingProxySwitch.Active() == true {
|
|
sec2, err := keyring.Get(MainSettings.StreamingProxy, MainSettings.StreamingProxyUser)
|
|
if err != nil {
|
|
log.Fatal("Error getting from keyring")
|
|
}
|
|
SettingsTabAppStreamingProxyUsernameEntry.SetText(MainSettings.StreamingProxyUser)
|
|
SettingsTabAppStreamingProxyPassEntry.SetText(sec2)
|
|
|
|
fullURL := protocol + MainSettings.StreamingProxyUser + ":" + sec2 + "@" + parsed
|
|
//adding the proxy settings to the Transport object
|
|
parsedurl, _ := url.Parse(fullURL)
|
|
|
|
HttpSettings = &http.Client{Timeout: time.Second * 10, Transport: &http.Transport{Proxy: http.ProxyURL(parsedurl)}}
|
|
|
|
} else {
|
|
// fullURL := protocol + MainSettings.StreamingProxyUser + "@" + parsed
|
|
parsedurl, _ := url.Parse(MainSettings.StreamingProxy)
|
|
// temptrans :=
|
|
HttpSettings = &http.Client{Timeout: time.Second * 10, Transport: &http.Transport{Proxy: http.ProxyURL(parsedurl)}}
|
|
}
|
|
|
|
//adding the Transport object to the http Client
|
|
|
|
// HttpSettings.Transport
|
|
|
|
}
|
|
|
|
SettingsTabAppMetadataProxySwitch.SetActive(MainSettings.UseMetadataProxy)
|
|
if MainSettings.UseMetadataProxy == true {
|
|
SettingsTabAppMetadataProxyEntry.SetText(MainSettings.MetadataProxy)
|
|
|
|
// var temptrans2 *http.Transport
|
|
var protocol, parsed string
|
|
|
|
if strings.Contains(MainSettings.MetadataProxy, "https") {
|
|
protocol = "https://"
|
|
parsed = MainSettings.MetadataProxy[8:]
|
|
} else if strings.Contains(MainSettings.MetadataProxy, "socks5") {
|
|
protocol = "socks5://"
|
|
parsed = MainSettings.MetadataProxy[9:]
|
|
} else if strings.Contains(MainSettings.MetadataProxy, "http") && !strings.Contains(MainSettings.MetadataProxy, "https") {
|
|
protocol = "http://"
|
|
parsed = MainSettings.MetadataProxy[7:]
|
|
} else {
|
|
log.Fatal("Unsupported protocol")
|
|
}
|
|
|
|
if SettingsTabAppAuthMetadataProxySwitch.Active() == true {
|
|
sec3, err := keyring.Get(MainSettings.MetadataProxy, MainSettings.MetadataProxyUser)
|
|
if err != nil {
|
|
log.Fatal("Error getting from keyring")
|
|
}
|
|
SettingsTabAppMetadataProxyUsernameEntry.SetText(MainSettings.MetadataProxyUser)
|
|
SettingsTabAppMetadataProxyPassEntry.SetText(sec3)
|
|
|
|
fullURL := protocol + MainSettings.MetadataProxyUser + ":" + sec3 + "@" + parsed
|
|
//adding the proxy settings to the Transport object
|
|
parsedurl2, err := url.Parse(fullURL)
|
|
MetadataClient = &http.Client{Timeout: time.Second * 10, Transport: &http.Transport{Proxy: http.ProxyURL(parsedurl2)}}
|
|
|
|
} else {
|
|
// fullURL := protocol + MainSettings.StreamingProxyUser + "@" + parsed
|
|
parsedurl2, _ := url.Parse(MainSettings.MetadataProxy)
|
|
MetadataClient = &http.Client{Timeout: time.Second * 10, Transport: &http.Transport{Proxy: http.ProxyURL(parsedurl2)}}
|
|
|
|
}
|
|
|
|
//adding the Transport object to the http Client
|
|
|
|
}
|
|
if MainSettings.Codec == "opus" {
|
|
SettingsTabAppCodecComboBoxTest.SetActive(0)
|
|
} else if MainSettings.Codec == "flac" {
|
|
SettingsTabAppCodecComboBoxTest.SetActive(1)
|
|
} else if MainSettings.Codec == "ogg" {
|
|
SettingsTabAppCodecComboBoxTest.SetActive(2)
|
|
} else if MainSettings.Codec == "mp3" {
|
|
SettingsTabAppCodecComboBoxTest.SetActive(3)
|
|
}
|
|
|
|
// HERE
|
|
|
|
if MainSettings.MetadataType == "None" {
|
|
SettingsTabAppMetadataComboBoxTest.SetActive(0)
|
|
} else if MainSettings.MetadataType == "Server" {
|
|
SettingsTabAppMetadataComboBoxTest.SetActive(1)
|
|
} else if MainSettings.MetadataType == "Sonically" {
|
|
SettingsTabAppMetadataComboBoxTest.SetActive(2)
|
|
}
|
|
|
|
if MainSettings.HideHeaderBar {
|
|
MainWindow.SetDecorated(false)
|
|
}
|
|
|
|
log.Print("Sucessfully set user from deserialzed content")
|
|
cacheDir := GetRunDir() + MainDir + DataDir + "/.cache"
|
|
CurrentCache, err = fscache.New(cacheDir, 0755, time.Hour*24)
|
|
if err != nil {
|
|
log.Fatal(err.Error())
|
|
}
|
|
}
|
|
} else {
|
|
MainDirC := GetRunDir() + MainDir
|
|
if _, err := os.Stat(MainDir); os.IsNotExist(err) {
|
|
os.Mkdir(MainDirC, 0744)
|
|
os.Mkdir(MainDirC+DataDir, 0744)
|
|
os.Mkdir(MainDirC+InfDir, 0744)
|
|
os.Mkdir(MainDirC+SettingsDir, 0744)
|
|
fmt.Println("Directory tree created")
|
|
}
|
|
|
|
}
|
|
|
|
}
|