fix(loxone): a T5 double-click starts the music that is already there

Loxone's button 2 is documented as "double-click starts playback or chooses
next favorite", and starting comes first. We only ever cycled favourites, so a
zone that was paused on a Spotify track with no room favourites configured
answered the double-click with nothing at all — leaving only the single click's
volume step visible, which is what the zone looked like it was doing (#381).

Keyed off the zone's audiopath because that is exactly what the resume path
falls back to, so the check cannot promise a resume the zone then fails to
perform. A zone that is already playing, or has nothing to resume, cycles
favourites as before.

Also let the route tolerate a trailing slash, like every route around it.

Author: rudyberends

src/adapters/loxone/commands/handlers/zoneHandlers.ts

@@ -475,6 +475,19 @@ async function audioRoomFavPlus(
 ) {
   const parts = splitCommand(command);
   const zoneId = parseNumberPart(parts[1], 0);
+  const state = zoneManager.getState(zoneId);
+
+  // Loxone describes this button as "double-click starts playback or chooses next favorite", and
+  // starting comes first: a zone sitting on a track it can resume is asking to be un-paused, not to
+  // be thrown onto a radio station. Keyed off `audiopath` because that is exactly what the resume
+  // path falls back to, so the check cannot promise a resume the zone then fails to perform. Without
+  // it, a zone with no room favourites answered the double-click with nothing at all (#381), which
+  // left only the single-click volume step visible.
+  if (state && state.mode !== 'play' && state.audiopath) {
+    zoneManager.handleCommand(zoneId, 'play');
+    return buildEmptyResponse(command);
+  }
+
   const favorites = await favoritesManager.get(zoneId);
   if (!favorites.items.length) {
     return buildEmptyResponse(command);
@@ -484,7 +497,6 @@ async function audioRoomFavPlus(
   if (!metadata) {
     return buildEmptyResponse(command);
   }
-  const state = zoneManager.getState(zoneId);
 
   const lastFavoriteId = metadata.lastFavoriteId as number | undefined;
   let currentIndex = -1;

src/adapters/loxone/commands/router/routeRegistry.ts

@@ -170,7 +170,7 @@ export function registerRoutes(
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/playlist\/play\/.+$/, zoneHandlers.audioPlaylistPlay);
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/library\/play\/.+$/, zoneHandlers.audioLibraryPlay);
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/roomfav\/play\//, zoneHandlers.audioFavoritePlay);
-  router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/roomfav\/plus$/, zoneHandlers.audioRoomFavPlus);
+  router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/roomfav\/plus\/?$/, zoneHandlers.audioRoomFavPlus);
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/playurl\/.+$/, zoneHandlers.audioPlayUrl);
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/equalizersettings\/[^/]+\/?$/, zoneHandlers.audioEqualizerSettings);
   router.registerRegex('audio', /^audio\/(?:cfg\/)?\d+\/linein(?:\/.*)?$/, inputHandlers.audioLineIn);

tests/zoneHandlers.roomfavs.test.ts

@@ -30,3 +30,91 @@ test('audio cfg roomfavs add returns created favorite id (not zone id)', async (
   assert.equal(payload.id, 42);
   assert.equal(payload.name, 'Test Favorite');
 });
+
+test('roomfav plus resumes a paused zone instead of jumping to a favorite', async () => {
+  const commands: Array<{ zoneId: number; command: string }> = [];
+  const zoneHandlers = createZoneHandlers(
+    {
+      getState: () => ({ id: 7, mode: 'pause', audiopath: 'spotify:track:abc' }),
+      getQueue: () => ({ id: 7, items: [], shuffle: false, start: 0, totalitems: 0 }),
+      handleCommand: (zoneId: number, command: string) => {
+        commands.push({ zoneId, command });
+      },
+      queue: { setPendingShuffle: () => {}, seekInQueue: () => false },
+      playContent: async () => {},
+      getMetadata: () => ({}),
+    } as any,
+    { get: async () => ({}) } as any,
+    {
+      get: async () => ({ items: [{ id: 1, audiopath: 'radio:one' }] }),
+      getForPlayback: async () => ({ id: 1, audiopath: 'radio:one', title: 'One' }),
+    } as any,
+    { resolveMetadata: async () => null } as any,
+  );
+
+  await zoneHandlers.audioRoomFavPlus('audio/7/roomfav/plus');
+  assert.deepEqual(commands, [{ zoneId: 7, command: 'play' }]);
+});
+
+test('roomfav plus still cycles favorites when the zone is already playing', async () => {
+  const played: number[] = [];
+  const metadata: Record<string, unknown> = {};
+  const zoneHandlers = createZoneHandlers(
+    {
+      getState: () => ({ id: 7, mode: 'play', audiopath: 'radio:one' }),
+      getQueue: () => ({ id: 7, items: [], shuffle: false, start: 0, totalitems: 0 }),
+      handleCommand: () => {
+        throw new Error('should not resume while playing');
+      },
+      queue: { setPendingShuffle: () => {}, seekInQueue: () => false },
+      playContent: async (zoneId: number) => {
+        played.push(zoneId);
+      },
+      getMetadata: () => metadata,
+    } as any,
+    { get: async () => ({}) } as any,
+    {
+      get: async () => ({
+        items: [
+          { id: 1, audiopath: 'radio:one' },
+          { id: 2, audiopath: 'radio:two' },
+        ],
+      }),
+      getForPlayback: async (_zoneId: number, id: number) => ({
+        id,
+        audiopath: id === 2 ? 'radio:two' : 'radio:one',
+        title: 'Fav',
+      }),
+    } as any,
+    { resolveMetadata: async () => null } as any,
+  );
+
+  await zoneHandlers.audioRoomFavPlus('audio/7/roomfav/plus');
+  assert.equal(metadata.lastFavoriteId, 2);
+  assert.deepEqual(played, [7]);
+});
+
+test('roomfav plus falls back to a favorite when a stopped zone has nothing to resume', async () => {
+  const metadata: Record<string, unknown> = {};
+  const zoneHandlers = createZoneHandlers(
+    {
+      getState: () => ({ id: 7, mode: 'stop', audiopath: '' }),
+      getQueue: () => ({ id: 7, items: [], shuffle: false, start: 0, totalitems: 0 }),
+      handleCommand: () => {
+        throw new Error('should not resume without an audiopath');
+      },
+      queue: { setPendingShuffle: () => {}, seekInQueue: () => false },
+      playContent: async () => {},
+      getMetadata: () => metadata,
+    } as any,
+    { get: async () => ({}) } as any,
+    {
+      get: async () => ({ items: [{ id: 5, audiopath: 'radio:one' }] }),
+      getForPlayback: async () => ({ id: 5, audiopath: 'radio:one', title: 'One' }),
+    } as any,
+    { resolveMetadata: async () => null } as any,
+  );
+
+  await zoneHandlers.audioRoomFavPlus('audio/7/roomfav/plus');
+  assert.equal(metadata.lastFavoriteId, 5);
+});