Now when people join after a channel has been muted the will be muted too.

This commit is contained in:
Storm Dragon 2025-01-29 00:24:59 -05:00
parent 356ff5a3a8
commit c7362dfc36

324
client.go
View File

@ -1,203 +1,215 @@
package main package main
import ( import (
"fmt" "fmt"
"net" "net"
"time" "time"
"git.stormux.org/storm/barnard/gumble/gumble" "git.stormux.org/storm/barnard/gumble/gumble"
"git.stormux.org/storm/barnard/gumble/gumbleopenal" "git.stormux.org/storm/barnard/gumble/gumbleopenal"
"git.stormux.org/storm/barnard/gumble/gumbleutil" "git.stormux.org/storm/barnard/gumble/gumbleutil"
) )
func (b *Barnard) start() { func (b *Barnard) start() {
b.Config.Attach(gumbleutil.AutoBitrate) b.Config.Attach(gumbleutil.AutoBitrate)
b.Config.Attach(b) b.Config.Attach(b)
b.Config.Address = b.Address b.Config.Address = b.Address
// test Audio // test Audio
_, err := gumbleopenal.New(b.Client, b.UserConfig.GetInputDevice(), b.UserConfig.GetOutputDevice(), true) _, err := gumbleopenal.New(b.Client, b.UserConfig.GetInputDevice(), b.UserConfig.GetOutputDevice(), true)
if err != nil { if err != nil {
b.exitWithError(err) b.exitWithError(err)
return return
} }
//connect, not reconnect //connect, not reconnect
b.connect(false) b.connect(false)
} }
func (b *Barnard) exitWithError(err error) { func (b *Barnard) exitWithError(err error) {
b.Ui.Close() b.Ui.Close()
b.exitStatus = 1 b.exitStatus = 1
b.exitMessage = err.Error() b.exitMessage = err.Error()
} }
func (b *Barnard) connect(reconnect bool) bool { func (b *Barnard) connect(reconnect bool) bool {
var err error var err error
_, err = gumble.DialWithDialer(new(net.Dialer), b.Config, &b.TLSConfig) _, err = gumble.DialWithDialer(new(net.Dialer), b.Config, &b.TLSConfig)
if err != nil { if err != nil {
if reconnect { if reconnect {
b.Log(err.Error()) b.Log(err.Error())
} else { } else {
b.exitWithError(err) b.exitWithError(err)
} }
return false return false
} }
stream, err := gumbleopenal.New(b.Client, b.UserConfig.GetInputDevice(), b.UserConfig.GetOutputDevice(), false) stream, err := gumbleopenal.New(b.Client, b.UserConfig.GetInputDevice(), b.UserConfig.GetOutputDevice(), false)
if err != nil { if err != nil {
b.exitWithError(err) b.exitWithError(err)
return false return false
} }
b.Stream = stream b.Stream = stream
b.Stream.AttachStream(b.Client) b.Stream.AttachStream(b.Client)
b.Connected = true b.Connected = true
return true return true
} }
func (b *Barnard) OnConnect(e *gumble.ConnectEvent) { func (b *Barnard) OnConnect(e *gumble.ConnectEvent) {
b.Client = e.Client b.Client = e.Client
b.Ui.SetActive(uiViewInput) b.Ui.SetActive(uiViewInput)
b.UiTree.Rebuild() b.UiTree.Rebuild()
b.Ui.Refresh() b.Ui.Refresh()
for _, u := range b.Client.Users { for _, u := range b.Client.Users {
b.UserConfig.UpdateUser(u) b.UserConfig.UpdateUser(u)
} }
b.UpdateInputStatus(fmt.Sprintf("[%s]", e.Client.Self.Channel.Name)) b.UpdateInputStatus(fmt.Sprintf("[%s]", e.Client.Self.Channel.Name))
b.AddOutputLine(fmt.Sprintf("Connected to %s", b.Client.Conn.RemoteAddr())) b.AddOutputLine(fmt.Sprintf("Connected to %s", b.Client.Conn.RemoteAddr()))
wmsg := "" wmsg := ""
if e.WelcomeMessage != nil { if e.WelcomeMessage != nil {
wmsg = esc(*e.WelcomeMessage) wmsg = esc(*e.WelcomeMessage)
} }
b.Notify("connect", "me", wmsg) b.Notify("connect", "me", wmsg)
if wmsg != "" { if wmsg != "" {
b.AddOutputLine(fmt.Sprintf("Welcome message: %s", wmsg)) b.AddOutputLine(fmt.Sprintf("Welcome message: %s", wmsg))
} }
b.Ui.Refresh() b.Ui.Refresh()
} }
func (b *Barnard) OnDisconnect(e *gumble.DisconnectEvent) { func (b *Barnard) OnDisconnect(e *gumble.DisconnectEvent) {
var reason string var reason string
switch e.Type { switch e.Type {
case gumble.DisconnectError: case gumble.DisconnectError:
reason = "connection error" reason = "connection error"
} }
b.Notify("disconnect", "me", reason) b.Notify("disconnect", "me", reason)
if reason == "" { if reason == "" {
b.AddOutputLine("Disconnected") b.AddOutputLine("Disconnected")
} else { } else {
b.AddOutputLine("Disconnected: " + reason) b.AddOutputLine("Disconnected: " + reason)
} }
b.Tx = false b.Tx = false
b.Connected = false b.Connected = false
b.UiTree.Rebuild() b.UiTree.Rebuild()
b.Ui.Refresh() b.Ui.Refresh()
go b.reconnectGoroutine() go b.reconnectGoroutine()
} }
func (b *Barnard) reconnectGoroutine() { func (b *Barnard) reconnectGoroutine() {
for { for {
res := b.connect(true) res := b.connect(true)
if res == true { if res == true {
break break
} }
time.Sleep(15 * time.Second) time.Sleep(15 * time.Second)
} }
} }
func (b *Barnard) Log(s string) { func (b *Barnard) Log(s string) {
b.AddOutputMessage(nil, s) b.AddOutputMessage(nil, s)
} }
func (b *Barnard) OnTextMessage(e *gumble.TextMessageEvent) { func (b *Barnard) OnTextMessage(e *gumble.TextMessageEvent) {
var public = false var public = false
for _, c := range e.Channels { for _, c := range e.Channels {
if c.Name == b.Client.Self.Channel.Name { if c.Name == b.Client.Self.Channel.Name {
public = true public = true
break break
} }
} }
if public { if public {
b.Notify("msg", e.Sender.Name, e.Message) b.Notify("msg", e.Sender.Name, e.Message)
b.AddOutputMessage(e.Sender, e.Message) b.AddOutputMessage(e.Sender, e.Message)
} else { } else {
var sender string var sender string
if e.Sender == nil { if e.Sender == nil {
sender = "Server" sender = "Server"
} else { } else {
sender = e.Sender.Name sender = e.Sender.Name
} }
b.Notify("pm", sender, e.Message) b.Notify("pm", sender, e.Message)
b.AddOutputPrivateMessage(e.Sender, b.Client.Self, e.Message) b.AddOutputPrivateMessage(e.Sender, b.Client.Self, e.Message)
} }
} }
func (b *Barnard) OnUserChange(e *gumble.UserChangeEvent) { func (b *Barnard) OnUserChange(e *gumble.UserChangeEvent) {
if e.User != nil { if e.User != nil {
b.UserConfig.UpdateUser(e.User) b.UserConfig.UpdateUser(e.User)
}
var s = "unknown" // New code: Check if user is joining a muted channel
var t = "unknown" if e.Type.Has(gumble.UserChangeConnected) || e.Type.Has(gumble.UserChangeChannel) {
if e.Type.Has(gumble.UserChangeConnected) { // If the channel is muted, mute the new user
s = "joined" if b.MutedChannels[e.User.Channel.ID] {
t = "join" b.UserConfig.ToggleMute(e.User)
} if e.User.AudioSource != nil {
if e.Type.Has(gumble.UserChangeDisconnected) { e.User.AudioSource.SetGain(0)
s = "left" }
t = "leave" }
if e.User == b.selectedUser { }
b.SetSelectedUser(nil) }
}
} var s = "unknown"
if e.User.Channel.Name == b.Client.Self.Channel.Name { var t = "unknown"
b.Notify(t, e.User.Name, e.User.Channel.Name) if e.Type.Has(gumble.UserChangeConnected) {
b.AddOutputLine(fmt.Sprintf("%s %s %s", e.User.Name, s, e.User.Channel.Name)) s = "joined"
} t = "join"
if e.Type.Has(gumble.UserChangeChannel) && e.User == b.Client.Self { }
b.UpdateInputStatus(fmt.Sprintf("[%s]", e.User.Channel.Name)) if e.Type.Has(gumble.UserChangeDisconnected) {
} s = "left"
b.UiTree.Rebuild() t = "leave"
b.Ui.Refresh() if e.User == b.selectedUser {
b.SetSelectedUser(nil)
}
}
if e.User.Channel.Name == b.Client.Self.Channel.Name {
b.Notify(t, e.User.Name, e.User.Channel.Name)
b.AddOutputLine(fmt.Sprintf("%s %s %s", e.User.Name, s, e.User.Channel.Name))
}
if e.Type.Has(gumble.UserChangeChannel) && e.User == b.Client.Self {
b.UpdateInputStatus(fmt.Sprintf("[%s]", e.User.Channel.Name))
}
b.UiTree.Rebuild()
b.Ui.Refresh()
} }
func (b *Barnard) OnChannelChange(e *gumble.ChannelChangeEvent) { func (b *Barnard) OnChannelChange(e *gumble.ChannelChangeEvent) {
b.UpdateInputStatus(fmt.Sprintf("[%s]", e.Channel.Name)) b.UpdateInputStatus(fmt.Sprintf("[%s]", e.Channel.Name))
b.UiTree.Rebuild() b.UiTree.Rebuild()
b.Ui.Refresh() b.Ui.Refresh()
} }
func (b *Barnard) OnPermissionDenied(e *gumble.PermissionDeniedEvent) { func (b *Barnard) OnPermissionDenied(e *gumble.PermissionDeniedEvent) {
var info string var info string
switch e.Type { switch e.Type {
case gumble.PermissionDeniedOther: case gumble.PermissionDeniedOther:
info = e.String info = e.String
case gumble.PermissionDeniedPermission: case gumble.PermissionDeniedPermission:
info = "insufficient permissions" info = "insufficient permissions"
case gumble.PermissionDeniedSuperUser: case gumble.PermissionDeniedSuperUser:
info = "cannot modify SuperUser" info = "cannot modify SuperUser"
case gumble.PermissionDeniedInvalidChannelName: case gumble.PermissionDeniedInvalidChannelName:
info = "invalid channel name" info = "invalid channel name"
case gumble.PermissionDeniedTextTooLong: case gumble.PermissionDeniedTextTooLong:
info = "text too long" info = "text too long"
case gumble.PermissionDeniedTemporaryChannel: case gumble.PermissionDeniedTemporaryChannel:
info = "temporary channel" info = "temporary channel"
case gumble.PermissionDeniedMissingCertificate: case gumble.PermissionDeniedMissingCertificate:
info = "missing certificate" info = "missing certificate"
case gumble.PermissionDeniedInvalidUserName: case gumble.PermissionDeniedInvalidUserName:
info = "invalid user name" info = "invalid user name"
case gumble.PermissionDeniedChannelFull: case gumble.PermissionDeniedChannelFull:
info = "channel full" info = "channel full"
case gumble.PermissionDeniedNestingLimit: case gumble.PermissionDeniedNestingLimit:
info = "nesting limit" info = "nesting limit"
} }
b.AddOutputLine(fmt.Sprintf("Permission denied: %s", info)) b.AddOutputLine(fmt.Sprintf("Permission denied: %s", info))
} }
func (b *Barnard) OnUserList(e *gumble.UserListEvent) { func (b *Barnard) OnUserList(e *gumble.UserListEvent) {
//for _,u := range e.UserList { //for _,u := range e.UserList {
//b.UserConfig.UpdateUser(u) //b.UserConfig.UpdateUser(u)
//} //}
} }
func (b *Barnard) OnACL(e *gumble.ACLEvent) { func (b *Barnard) OnACL(e *gumble.ACLEvent) {