${info?.type || ''}
${info?.ip_address ? html`(${info.ip_address})` : null}
+ ${stereoPair ? html`
+
+ Stereo pair ${stereoPair.availableMemberCount}/${stereoPair.memberCount}
+
+ ` : null}
${!isStandby ? html`
diff --git a/pkg/service/soundtouchweb/static/js/components/Library.js b/pkg/service/soundtouchweb/static/js/components/Library.js
index d8d42229..239e491f 100644
--- a/pkg/service/soundtouchweb/static/js/components/Library.js
+++ b/pkg/service/soundtouchweb/static/js/components/Library.js
@@ -23,10 +23,12 @@ export function Library({ devices }) {
// invalidate the current selection.
useEffect(() => {
const entries = Object.entries(devices);
- if (!deviceId && entries.length > 0) {
+ if ((!deviceId || !devices[deviceId]) && entries.length > 0) {
setDeviceId(entries[0][0]);
+ } else if (deviceId && entries.length === 0) {
+ setDeviceId(null);
}
- }, [devices]);
+ }, [devices, deviceId]);
// Reload registered servers whenever deviceId changes.
useEffect(() => {
diff --git a/pkg/service/soundtouchweb/websocket.go b/pkg/service/soundtouchweb/websocket.go
index cff60460..72c1ee39 100644
--- a/pkg/service/soundtouchweb/websocket.go
+++ b/pkg/service/soundtouchweb/websocket.go
@@ -46,23 +46,10 @@ func (app *WebApp) HandleWebSocket(w http.ResponseWriter, r *http.Request) {
}
// Send initial device list
- snapshot := app.DeviceSnapshot()
- devices := make(map[string]interface{}, len(snapshot))
-
- for _, entry := range snapshot {
- devices[entry.ID] = map[string]interface{}{
- "info": entry.Device.DeviceInfo,
- "status": entry.Device.Status(),
- "lastSeen": entry.Device.LastSeen,
- }
- }
-
- initialMessage := webtypes.WebSocketMessage{
+ if err := conn.WriteJSON(webtypes.WebSocketMessage{
Type: "devices",
- Data: devices,
- }
-
- if err := conn.WriteJSON(initialMessage); err != nil {
+ Data: app.deviceViewSnapshot(),
+ }); err != nil {
log.Printf("Failed to send initial data: %v", err)
return
}
@@ -100,21 +87,14 @@ func (app *WebApp) HandleWebSocket(w http.ResponseWriter, r *http.Request) {
return
}
- // Send periodic status updates
- for _, entry := range app.DeviceSnapshot() {
- status := entry.Device.Status()
- if status.IsConnected {
- statusMessage := webtypes.WebSocketMessage{
- Type: "status_update",
- DeviceID: entry.ID,
- Data: status,
- }
-
- if err := conn.WriteJSON(statusMessage); err != nil {
- log.Printf("Failed to send status update: %v", err)
- return
- }
- }
+ // A full projected list keeps pair topology and availability current
+ // without event handlers writing to this browser connection.
+ if err := conn.WriteJSON(webtypes.WebSocketMessage{
+ Type: "devices",
+ Data: app.deviceViewSnapshot(),
+ }); err != nil {
+ log.Printf("Failed to send device update: %v", err)
+ return
}
}
}
@@ -218,6 +198,10 @@ func (app *WebApp) ConnectDeviceWebSocket(deviceID string, conn *webtypes.Device
})
})
+ wsClient.OnGroupUpdated(func(event *models.GroupUpdatedEvent) {
+ applyGroupUpdatedEvent(conn, event)
+ })
+
if err := wsClient.Connect(); err != nil {
log.Printf("Failed to connect WebSocket for device %s: %v (retrying in %s)", sanitizeLog(deviceID), err, backoff)
@@ -298,6 +282,8 @@ func (app *WebApp) UpdateDeviceStatus(_ string, conn *webtypes.DeviceConnection)
return
}
+ groupGeneration := conn.BeginGroupRefresh()
+
// Phase 1: slow network fetches. Local vars only, no shared state
// is touched yet. Errors are recorded so the merge below can tell
// "field N stayed unchanged" apart from "field N got refreshed".
@@ -306,6 +292,7 @@ func (app *WebApp) UpdateDeviceStatus(_ string, conn *webtypes.DeviceConnection)
presets, presetsErr := conn.Client.GetPresets()
sources, sourcesErr := conn.Client.GetSources()
bass, bassErr := conn.Client.GetBass()
+ group, groupErr := conn.Client.GetGroup()
// Phase 2: fast merge. Only fields we successfully fetched
// overwrite; everything else keeps the value other goroutines may
@@ -338,11 +325,21 @@ func (app *WebApp) UpdateDeviceStatus(_ string, conn *webtypes.DeviceConnection)
statusUpdated = true
}
+ statusUpdated = statusUpdated || groupErr == nil
+
// Mark as connected if we successfully got at least one
// status from this round. Mirrors prior behaviour.
s.IsConnected = statusUpdated
s.LastActivity = time.Now()
})
+
+ if groupErr == nil {
+ conn.ApplyPolledGroup(groupGeneration, group)
+ }
+}
+
+func applyGroupUpdatedEvent(conn *webtypes.DeviceConnection, event *models.GroupUpdatedEvent) {
+ conn.ApplyGroupEvent(&event.Group, time.Now())
}
// HandleDeviceWebSocket handles individual device WebSocket connections for real-time device-specific updates
diff --git a/pkg/service/soundtouchweb/websocket_test.go b/pkg/service/soundtouchweb/websocket_test.go
new file mode 100644
index 00000000..56682fa4
--- /dev/null
+++ b/pkg/service/soundtouchweb/websocket_test.go
@@ -0,0 +1,141 @@
+package soundtouchweb
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/gesellix/bose-soundtouch/pkg/client"
+ "github.com/gesellix/bose-soundtouch/pkg/models"
+ "github.com/gesellix/bose-soundtouch/pkg/service/soundtouchweb/webtypes"
+)
+
+func TestUpdateDeviceStatusRefreshesGroup(t *testing.T) {
+ server := newStatusTestServer(t, http.StatusOK, `
+ Living Room
+ master-1
+
+ master-1LEFT
+ member-1RIGHT
+
+ GROUP_OK
+ `)
+ defer server.Close()
+
+ conn := webtypes.NewDeviceConnection(client.NewClientFromHost(server.URL), nil)
+ NewWebApp().UpdateDeviceStatus("device-1", conn)
+
+ status := conn.Status()
+ if status.Group == nil {
+ t.Fatal("Group was not populated by UpdateDeviceStatus")
+ }
+
+ if status.Group.ID != "pair-1" || status.Group.MasterDeviceID != "master-1" {
+ t.Errorf("Group = %+v, want refreshed stereo pair", status.Group)
+ }
+
+ if len(status.Group.Roles.Roles) != 2 {
+ t.Errorf("group roles = %d, want 2", len(status.Group.Roles.Roles))
+ }
+
+ if !status.IsConnected {
+ t.Error("successful status refresh should mark the device connected")
+ }
+}
+
+func TestUpdateDeviceStatusPreservesGroupOnError(t *testing.T) {
+ server := newStatusTestServer(t, http.StatusInternalServerError, "group unavailable")
+ defer server.Close()
+
+ conn := webtypes.NewDeviceConnection(client.NewClientFromHost(server.URL), nil)
+ existing := &models.Group{ID: "pair-old", Name: "Existing Pair"}
+ conn.SetStatus(&webtypes.DeviceStatus{Group: existing})
+
+ NewWebApp().UpdateDeviceStatus("device-1", conn)
+
+ status := conn.Status()
+ if status.Group != existing {
+ t.Errorf("Group = %+v, want previous group preserved on refresh error", status.Group)
+ }
+
+ if !status.IsConnected {
+ t.Error("other successful status fetches should keep the device connected")
+ }
+}
+
+func TestApplyGroupUpdatedEventReplacesGroup(t *testing.T) {
+ conn := webtypes.NewDeviceConnection(nil, nil)
+ previousActivity := time.Unix(1, 0)
+ conn.SetStatus(&webtypes.DeviceStatus{
+ Group: &models.Group{ID: "pair-old"},
+ Volume: &models.Volume{ActualVolume: 25},
+ IsConnected: true,
+ LastActivity: previousActivity,
+ })
+
+ event := &models.GroupUpdatedEvent{
+ Group: models.Group{ID: "pair-new", Name: "Renamed Pair"},
+ }
+ applyGroupUpdatedEvent(conn, event)
+
+ status := conn.Status()
+ if status.Group != &event.Group || status.Group.ID != "pair-new" {
+ t.Errorf("Group = %+v, want event group", status.Group)
+ }
+
+ if status.Volume == nil || status.Volume.ActualVolume != 25 || !status.IsConnected {
+ t.Errorf("unrelated status fields were not preserved: %+v", status)
+ }
+
+ if !status.LastActivity.After(previousActivity) {
+ t.Errorf("LastActivity = %s, want after %s", status.LastActivity, previousActivity)
+ }
+
+ teardown := &models.GroupUpdatedEvent{Group: models.Group{}}
+ applyGroupUpdatedEvent(conn, teardown)
+
+ if conn.Status().Group != nil {
+ t.Errorf("teardown event did not clear the group: %+v", conn.Status().Group)
+ }
+}
+
+func newStatusTestServer(t *testing.T, groupStatus int, groupBody string) *httptest.Server {
+ t.Helper()
+
+ responses := map[string]string{
+ "/now_playing": `
STOP_STATE`,
+ "/volume": `
1010false`,
+ "/presets": `
`,
+ "/sources": `
`,
+ "/bass": `
00`,
+ }
+
+ return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodGet {
+ t.Errorf("method for %s = %s, want GET", r.URL.Path, r.Method)
+ w.WriteHeader(http.StatusMethodNotAllowed)
+
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/xml")
+
+ if r.URL.Path == "/getGroup" {
+ w.WriteHeader(groupStatus)
+ _, _ = w.Write([]byte(groupBody))
+
+ return
+ }
+
+ body, ok := responses[r.URL.Path]
+ if !ok {
+ t.Errorf("unexpected status endpoint %q", r.URL.Path)
+ w.WriteHeader(http.StatusNotFound)
+
+ return
+ }
+
+ _, _ = w.Write([]byte(body))
+ }))
+}
diff --git a/pkg/service/soundtouchweb/webtypes/status_test.go b/pkg/service/soundtouchweb/webtypes/status_test.go
index a7fb6ede..fbeae144 100644
--- a/pkg/service/soundtouchweb/webtypes/status_test.go
+++ b/pkg/service/soundtouchweb/webtypes/status_test.go
@@ -3,9 +3,11 @@
package webtypes
import (
+ "encoding/json"
"fmt"
"sync"
"testing"
+ "time"
"github.com/gesellix/bose-soundtouch/pkg/models"
)
@@ -75,6 +77,7 @@ func TestUpdateStatus_PreservesUnchangedFields(t *testing.T) {
conn.SetStatus(&DeviceStatus{
Volume: &models.Volume{ActualVolume: 10},
Bass: &models.Bass{ActualBass: 3},
+ Group: &models.Group{ID: "pair-1", Name: "Living Room"},
IsConnected: true,
})
@@ -92,11 +95,87 @@ func TestUpdateStatus_PreservesUnchangedFields(t *testing.T) {
t.Errorf("Bass not preserved: %+v", got.Bass)
}
+ if got.Group == nil || got.Group.ID != "pair-1" {
+ t.Errorf("Group not preserved: %+v", got.Group)
+ }
+
if !got.IsConnected {
t.Error("IsConnected not preserved")
}
}
+func TestDeviceStatusGroupJSON(t *testing.T) {
+ status := DeviceStatus{
+ Group: &models.Group{
+ ID: "pair-1",
+ Name: "Living Room",
+ MasterDeviceID: "master-1",
+ },
+ }
+
+ payload, err := json.Marshal(status)
+ if err != nil {
+ t.Fatalf("Marshal DeviceStatus: %v", err)
+ }
+
+ var decoded struct {
+ Group *models.Group `json:"group"`
+ }
+
+ if err := json.Unmarshal(payload, &decoded); err != nil {
+ t.Fatalf("Unmarshal DeviceStatus: %v", err)
+ }
+
+ if decoded.Group == nil || decoded.Group.ID != "pair-1" || decoded.Group.MasterDeviceID != "master-1" {
+ t.Fatalf("group did not round-trip in status JSON: %+v", decoded.Group)
+ }
+
+ emptyPayload, err := json.Marshal(DeviceStatus{})
+ if err != nil {
+ t.Fatalf("Marshal empty DeviceStatus: %v", err)
+ }
+
+ var emptyDecoded map[string]json.RawMessage
+ if err := json.Unmarshal(emptyPayload, &emptyDecoded); err != nil {
+ t.Fatalf("Unmarshal empty DeviceStatus: %v", err)
+ }
+
+ if _, ok := emptyDecoded["group"]; ok {
+ t.Errorf("nil group should be omitted, JSON = %s", emptyPayload)
+ }
+}
+
+func TestGroupEventSupersedesInFlightPoll(t *testing.T) {
+ conn := NewDeviceConnection(nil, &models.DeviceInfo{Name: "test"})
+ generation := conn.BeginGroupRefresh()
+
+ eventGroup := &models.Group{ID: "new-pair", MasterDeviceID: "master"}
+ if !conn.ApplyGroupEvent(eventGroup, time.Now()) {
+ t.Fatal("new group event should change group state")
+ }
+
+ if conn.ApplyPolledGroup(generation, &models.Group{ID: "stale-pair"}) {
+ t.Fatal("stale poll must not replace a newer group event")
+ }
+
+ if got := conn.Status().Group; got == nil || got.ID != "new-pair" {
+ t.Fatalf("Group = %+v, want newer event state", got)
+ }
+}
+
+func TestEmptyGroupClearsCurrentClaim(t *testing.T) {
+ conn := NewDeviceConnection(nil, &models.DeviceInfo{Name: "test"})
+ conn.SetStatus(&DeviceStatus{Group: &models.Group{ID: "pair-1"}})
+
+ if !conn.ApplyGroupEvent(&models.Group{}, time.Now()) {
+ t.Fatal("empty teardown event should change group state")
+ }
+
+ if got := conn.Status().Group; got != nil {
+ t.Fatalf("Group = %+v, want nil after teardown", got)
+ }
+}
+
func TestStatusSnapshotIsolation(t *testing.T) {
// A snapshot returned by Status() must NOT change when a later
// UpdateStatus replaces a pointer field. This proves the atomic
diff --git a/pkg/service/soundtouchweb/webtypes/types.go b/pkg/service/soundtouchweb/webtypes/types.go
index 37b42e3e..cd0f1caa 100644
--- a/pkg/service/soundtouchweb/webtypes/types.go
+++ b/pkg/service/soundtouchweb/webtypes/types.go
@@ -2,6 +2,7 @@
package webtypes
import (
+ "reflect"
"sync"
"sync/atomic"
"time"
@@ -28,6 +29,7 @@ type SoundTouchClient interface {
GetPresets() (*models.Presets, error)
GetSources() (*models.Sources, error)
GetBass() (*models.Bass, error)
+ GetGroup() (*models.Group, error)
NewWebSocketClient(config interface{}) *client.WebSocketClient
}
@@ -47,6 +49,12 @@ type DeviceConnection struct {
status atomic.Pointer[DeviceStatus]
+ // groupMu orders polled /getGroup responses against real-time
+ // groupUpdated events. Starting a newer refresh or receiving an event
+ // invalidates any older in-flight poll.
+ groupMu sync.Mutex
+ groupGeneration uint64
+
// done is closed by Close when the device is removed from the
// registry, signalling its background goroutines (the status poller
// and the WebSocket reconnect loop) to exit. closeOnce keeps Close
@@ -62,6 +70,7 @@ type DeviceStatus struct {
Presets *models.Presets `json:"presets,omitempty"`
Sources *models.Sources `json:"sources,omitempty"`
Bass *models.Bass `json:"bass,omitempty"`
+ Group *models.Group `json:"group,omitempty"`
IsConnected bool `json:"isConnected"`
LastActivity time.Time `json:"lastActivity"`
}
@@ -85,10 +94,9 @@ func NewDeviceConnection(c *client.Client, info *models.DeviceInfo) *DeviceConne
}
// Status returns a snapshot of the current device status. The returned
-// pointer is read-only from the caller's perspective; mutating the
-// pointed-to struct has no effect on the stored status. Use
-// UpdateStatus or SetStatus to apply changes. Never returns nil for
-// connections built via NewDeviceConnection.
+// pointer is read-only from the caller's perspective and must not be
+// mutated. Use UpdateStatus or SetStatus to apply changes. Never returns
+// nil for connections built via NewDeviceConnection.
func (c *DeviceConnection) Status() *DeviceStatus {
return c.status.Load()
}
@@ -128,7 +136,7 @@ func (c *DeviceConnection) SetStatus(s *DeviceStatus) {
// writers cannot silently lose each other's changes.
//
// The copy mut receives is a shallow value copy of the previous status.
-// Nested pointer fields (NowPlaying, Volume, Presets, Sources, Bass)
+// Nested pointer fields (NowPlaying, Volume, Presets, Sources, Bass, Group)
// share their backing struct with the previous version: callers MUST
// REPLACE these pointers (s.Volume = &models.Volume{...}) rather than
// mutate through them (s.Volume.ActualVolume++ would race with any
@@ -147,6 +155,61 @@ func (c *DeviceConnection) UpdateStatus(mut func(*DeviceStatus)) {
}
}
+// BeginGroupRefresh starts a new generation for an asynchronous /getGroup
+// request. Only the latest started request may later update Group.
+func (c *DeviceConnection) BeginGroupRefresh() uint64 {
+ c.groupMu.Lock()
+ defer c.groupMu.Unlock()
+
+ c.groupGeneration++
+
+ return c.groupGeneration
+}
+
+// ApplyPolledGroup stores a /getGroup result only when no newer poll or
+// groupUpdated event superseded it. Empty groups clear the current claim.
+func (c *DeviceConnection) ApplyPolledGroup(generation uint64, group *models.Group) bool {
+ c.groupMu.Lock()
+ defer c.groupMu.Unlock()
+
+ if generation != c.groupGeneration {
+ return false
+ }
+
+ return c.replaceGroup(normalizeGroup(group), time.Time{})
+}
+
+// ApplyGroupEvent stores the newest groupUpdated event and invalidates all
+// in-flight /getGroup requests. Empty teardown events clear the current claim.
+func (c *DeviceConnection) ApplyGroupEvent(group *models.Group, activity time.Time) bool {
+ c.groupMu.Lock()
+ defer c.groupMu.Unlock()
+
+ c.groupGeneration++
+
+ return c.replaceGroup(normalizeGroup(group), activity)
+}
+
+func (c *DeviceConnection) replaceGroup(group *models.Group, activity time.Time) bool {
+ changed := !reflect.DeepEqual(c.Status().Group, group)
+ c.UpdateStatus(func(s *DeviceStatus) {
+ s.Group = group
+ if !activity.IsZero() {
+ s.LastActivity = activity
+ }
+ })
+
+ return changed
+}
+
+func normalizeGroup(group *models.Group) *models.Group {
+ if group == nil || group.IsEmpty() {
+ return nil
+ }
+
+ return group
+}
+
// APIResponse is a standard JSON response wrapper
type APIResponse struct {
Success bool `json:"success"`