diff --git a/web/src/player/store.ts b/web/src/player/store.ts index ab2c131..61d56db 100644 --- a/web/src/player/store.ts +++ b/web/src/player/store.ts @@ -1,5 +1,6 @@ import { create } from 'zustand' import type { Track } from '@/api/catalog' +import { loadVolume, saveVolume } from './volume' export type Repeat = 'off' | 'all' | 'one' @@ -17,6 +18,9 @@ export interface PlayerState { seekId: number /** Changes every time a new list is started, so that playing the same track again restarts it. */ playId: number + /** From 0 to 1. Kept while muted, so that unmuting brings it back. Remembered in the browser. */ + volume: number + muted: boolean playTracks(tracks: Track[], start?: number): void togglePlay(): void @@ -32,8 +36,14 @@ export interface PlayerState { cycleRepeat(): void /** Plays the track at this position of the queue from the start. */ jumpTo(i: number): void + /** Sets the volume (brought into 0 to 1; a number that is not one is ignored) and unmutes. */ + setVolume(volume: number): void + toggleMute(): void } +/** The level that comes back when mute is pressed on a volume that is already zero. */ +const RESTORED_VOLUME = 0.5 + let random: () => number = Math.random /** Tests replace the random source to get a known shuffle. */ @@ -71,6 +81,7 @@ export const usePlayer = create()((set, get) => ({ seekMs: null, seekId: 0, playId: 0, + ...loadVolume(), playTracks(tracks, start = 0) { set((s) => { @@ -189,4 +200,19 @@ export const usePlayer = create()((set, get) => ({ return { index: i, playing: true, positionMs: 0 } }) }, + + setVolume(volume) { + if (Number.isNaN(volume)) return + set({ volume: Math.min(Math.max(volume, 0), 1), muted: false }) + saveVolume(get()) + }, + + toggleMute() { + set((s) => { + // Pressing mute on silence would change nothing: bring the sound back instead. + if (s.volume === 0) return { volume: RESTORED_VOLUME, muted: false } + return { muted: !s.muted } + }) + saveVolume(get()) + }, })) diff --git a/web/src/player/volume.test.ts b/web/src/player/volume.test.ts new file mode 100644 index 0000000..158b428 --- /dev/null +++ b/web/src/player/volume.test.ts @@ -0,0 +1,91 @@ +import { afterEach, beforeEach, expect, test, vi } from 'vitest' +import { usePlayer } from './store' +import { loadVolume, saveVolume } from './volume' + +const KEY = 'sonda.volume' + +beforeEach(() => { + localStorage.clear() + usePlayer.setState({ volume: 1, muted: false }) +}) +afterEach(() => vi.restoreAllMocks()) + +// --- what is remembered in the browser -------------------------------------------------------- + +test('with nothing remembered the volume is full and not muted', () => { + expect(loadVolume()).toEqual({ volume: 1, muted: false }) +}) + +test('what was saved is read back', () => { + saveVolume({ volume: 0.4, muted: true }) + expect(loadVolume()).toEqual({ volume: 0.4, muted: true }) +}) + +test.each([ + ['not JSON', 'nope'], + ['not an object', '3'], + ['a volume that is not a number', '{"volume":"loud","muted":false}'], + ['a volume above 1', '{"volume":7,"muted":false}'], + ['a negative volume', '{"volume":-1,"muted":false}'], + ['a mute that is not a boolean', '{"volume":0.5,"muted":"yes"}'], +])('%s is ignored and the defaults are used', (_what, stored) => { + localStorage.setItem(KEY, stored) + expect(loadVolume()).toEqual({ volume: 1, muted: false }) +}) + +test('a browser that refuses to read or write storage does not break the player', () => { + vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => { + throw new Error('blocked') + }) + vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => { + throw new Error('blocked') + }) + expect(loadVolume()).toEqual({ volume: 1, muted: false }) + expect(() => saveVolume({ volume: 0.2, muted: false })).not.toThrow() + expect(() => usePlayer.getState().setVolume(0.3)).not.toThrow() +}) + +// --- the rules of volume and mute ------------------------------------------------------------ + +test('setting the volume keeps it and remembers it', () => { + usePlayer.getState().setVolume(0.35) + expect(usePlayer.getState().volume).toBe(0.35) + expect(JSON.parse(localStorage.getItem(KEY) ?? '{}')).toEqual({ volume: 0.35, muted: false }) +}) + +test('a volume outside 0 to 1 is brought back into it, and a number that is not one is ignored', () => { + usePlayer.getState().setVolume(2) + expect(usePlayer.getState().volume).toBe(1) + usePlayer.getState().setVolume(-0.5) + expect(usePlayer.getState().volume).toBe(0) + usePlayer.getState().setVolume(0.6) + usePlayer.getState().setVolume(Number.NaN) + expect(usePlayer.getState().volume).toBe(0.6) +}) + +test('moving the volume while muted unmutes', () => { + usePlayer.setState({ muted: true, volume: 0.5 }) + usePlayer.getState().setVolume(0.7) + expect(usePlayer.getState()).toMatchObject({ volume: 0.7, muted: false }) +}) + +test('mute keeps the level, and unmute brings it back', () => { + usePlayer.setState({ volume: 0.8, muted: false }) + usePlayer.getState().toggleMute() + expect(usePlayer.getState()).toMatchObject({ volume: 0.8, muted: true }) + expect(JSON.parse(localStorage.getItem(KEY) ?? '{}')).toEqual({ volume: 0.8, muted: true }) + usePlayer.getState().toggleMute() + expect(usePlayer.getState()).toMatchObject({ volume: 0.8, muted: false }) +}) + +test('pressing mute on a volume that is already zero raises it instead, so the button never does nothing', () => { + usePlayer.setState({ volume: 0, muted: false }) + usePlayer.getState().toggleMute() + expect(usePlayer.getState()).toMatchObject({ volume: 0.5, muted: false }) +}) + +test('unmuting a volume that was dragged to zero while muted restores a level too', () => { + usePlayer.setState({ volume: 0, muted: true }) + usePlayer.getState().toggleMute() + expect(usePlayer.getState()).toMatchObject({ volume: 0.5, muted: false }) +}) diff --git a/web/src/player/volume.ts b/web/src/player/volume.ts new file mode 100644 index 0000000..0b845c4 --- /dev/null +++ b/web/src/player/volume.ts @@ -0,0 +1,31 @@ +const KEY = 'sonda.volume' + +export interface VolumeState { + /** From 0 (silence) to 1 (full). */ + volume: number + muted: boolean +} + +const DEFAULTS: VolumeState = { volume: 1, muted: false } + +/** What the volume was last time, from this browser. Anything missing or odd gives full volume, not muted. */ +export function loadVolume(): VolumeState { + try { + const stored: unknown = JSON.parse(localStorage.getItem(KEY) ?? 'null') + if (typeof stored !== 'object' || stored === null) return DEFAULTS + const { volume, muted } = stored as Record + if (typeof volume !== 'number' || !(volume >= 0 && volume <= 1) || typeof muted !== 'boolean') return DEFAULTS + return { volume, muted } + } catch { + return DEFAULTS + } +} + +/** Remembers the volume in this browser. A browser that refuses storage just forgets it next time. */ +export function saveVolume(state: VolumeState): void { + try { + localStorage.setItem(KEY, JSON.stringify({ volume: state.volume, muted: state.muted })) + } catch { + // Private window, blocked site data: the volume works, it is only not remembered. + } +}