From 3eed7537f8cc0221a81951b24ef965f6b7f35d6e Mon Sep 17 00:00:00 2001 From: Eddy Pedroni Date: Tue, 4 Jan 2022 14:58:39 +0100 Subject: Added song and AB limits change notification --- notifier.py | 2 + notifier_unittest.py | 36 +++++++++--------- playlist.py | 3 ++ playlist_unittest.py | 18 +++++++++ solo_tool.py | 24 ++++++++++++ solo_tool_integrationtest.py | 91 ++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 157 insertions(+), 17 deletions(-) diff --git a/notifier.py b/notifier.py index 99be1ce..fc91e8c 100644 --- a/notifier.py +++ b/notifier.py @@ -3,6 +3,8 @@ class Notifier: PLAYING_STATE_EVENT = 0 PLAYBACK_VOLUME_EVENT = 1 PLAYBACK_RATE_EVENT = 2 + CURRENT_SONG_EVENT = 3 + CURRENT_AB_EVENT = 4 def __init__(self, player): self._callbacks = dict() diff --git a/notifier_unittest.py b/notifier_unittest.py index 9f37992..13f2285 100644 --- a/notifier_unittest.py +++ b/notifier_unittest.py @@ -11,34 +11,36 @@ def mockPlayer(): def uut(mockPlayer): return Notifier(mockPlayer) -def checkEvent(uut, event): - callbacks = 2 - calledFlags = [False] * 2 +def test_allEvents(uut): + def checkEvent(uut, event): + callbacks = 2 + calledFlags = [False] * 2 - def createCallback(i): - def cb(): - nonlocal calledFlags - calledFlags[i] = True - return cb + def createCallback(i): + def cb(): + nonlocal calledFlags + calledFlags[i] = True + return cb - for i in range(0, callbacks): - uut.registerCallback(event, createCallback(i)) + for i in range(0, callbacks): + uut.registerCallback(event, createCallback(i)) - assert not any(calledFlags) - uut.notify(event) - assert all(calledFlags) + assert not any(calledFlags) + uut.notify(event) + assert all(calledFlags) -def test_allEvents(uut): checkEvent(uut, Notifier.PLAYING_STATE_EVENT) checkEvent(uut, Notifier.PLAYBACK_VOLUME_EVENT) checkEvent(uut, Notifier.PLAYBACK_RATE_EVENT) + checkEvent(uut, Notifier.CURRENT_SONG_EVENT) + checkEvent(uut, Notifier.CURRENT_AB_EVENT) def test_eventWithoutRegisteredCallbacks(uut): uut.notify(Notifier.PLAYING_STATE_EVENT) # expect no crash def test_eventsWithMockPlayer(uut, mockPlayer): - def testEvent(eventCode, simulateEvent): + def checkEvent(eventCode, simulateEvent): called = False def callback(): nonlocal called @@ -50,8 +52,8 @@ def test_eventsWithMockPlayer(uut, mockPlayer): simulateEvent() assert called - testEvent(Notifier.PLAYING_STATE_EVENT, mockPlayer.simulatePlayingStateChanged) - testEvent(Notifier.PLAYBACK_VOLUME_EVENT, mockPlayer.simulatePlaybackVolumeChanged) + checkEvent(Notifier.PLAYING_STATE_EVENT, mockPlayer.simulatePlayingStateChanged) + checkEvent(Notifier.PLAYBACK_VOLUME_EVENT, mockPlayer.simulatePlaybackVolumeChanged) def test_singleEventNotification(uut): playingStateCalled = False diff --git a/playlist.py b/playlist.py index 2880733..5dad711 100644 --- a/playlist.py +++ b/playlist.py @@ -17,6 +17,9 @@ class Playlist: index = self._currentSong return self._songList[index] if index is not None else None + def getCurrentSongIndex(self): + return self._currentSong + def getSongs(self): return self._songList diff --git a/playlist_unittest.py b/playlist_unittest.py index 24d3a59..815a05f 100644 --- a/playlist_unittest.py +++ b/playlist_unittest.py @@ -14,6 +14,7 @@ def test_addAndSelectOneSong(): assert songAddedByUser == songSetByCallback assert uut.getCurrentSong() == songAddedByUser + assert uut.getCurrentSongIndex() == 0 assert uut.getSongs() == [songAddedByUser] def test_addTwoSongsAndSelectBoth(): @@ -32,10 +33,12 @@ def test_addTwoSongsAndSelectBoth(): uut.setCurrentSong(0) assert songAddedByUser[0] == songSetByCallback assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 uut.setCurrentSong(1) assert songAddedByUser[1] == songSetByCallback assert uut.getCurrentSong() == songAddedByUser[1] + assert uut.getCurrentSongIndex() == 1 def test_firstAddedSongIsNotSelected(): songAddedByUser = "/path/to/song" @@ -50,6 +53,7 @@ def test_firstAddedSongIsNotSelected(): assert songSetByCallback == None assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None assert uut.getSongs() == [songAddedByUser] def test_invalidSongSelection(): @@ -63,15 +67,18 @@ def test_invalidSongSelection(): uut = Playlist(testCallback) assert songSetByCallback == None assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None uut.setCurrentSong(10) assert songSetByCallback == None assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None uut.addSong(songAddedByUser) uut.setCurrentSong(10) assert songSetByCallback == None assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None assert uut.getSongs() == [songAddedByUser] def test_clearPlaylist(): @@ -87,11 +94,13 @@ def test_clearPlaylist(): assert uut.getSongs() == songAddedByUser assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 uut.clear() assert uut.getSongs() == [] assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None def test_nextSong(): songAddedByUser = ["/path/to/song", "/path/to/second/song"] @@ -100,15 +109,19 @@ def test_nextSong(): for s in songAddedByUser: uut.addSong(s) assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None uut.nextSong() assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 uut.nextSong() assert uut.getCurrentSong() == songAddedByUser[1] + assert uut.getCurrentSongIndex() == 1 uut.nextSong() assert uut.getCurrentSong() == songAddedByUser[1] + assert uut.getCurrentSongIndex() == 1 def test_previousSong(): songAddedByUser = ["/path/to/song", "/path/to/second/song"] @@ -117,14 +130,19 @@ def test_previousSong(): for s in songAddedByUser: uut.addSong(s) assert uut.getCurrentSong() == None + assert uut.getCurrentSongIndex() == None uut.previousSong() assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 uut.previousSong() assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 uut.setCurrentSong(1) assert uut.getCurrentSong() == songAddedByUser[1] + assert uut.getCurrentSongIndex() == 1 uut.previousSong() assert uut.getCurrentSong() == songAddedByUser[0] + assert uut.getCurrentSongIndex() == 0 diff --git a/solo_tool.py b/solo_tool.py index bca5146..fee7e4a 100644 --- a/solo_tool.py +++ b/solo_tool.py @@ -30,13 +30,22 @@ class SoloTool: self._sessionManager.addSong(path) def setSong(self, index): + changed = index != self._playlist.getCurrentSongIndex() self._playlist.setCurrentSong(index) + if changed: + self._notifier.notify(Notifier.CURRENT_SONG_EVENT) def nextSong(self): + previous = self._playlist.getCurrentSongIndex() self._playlist.nextSong() + if previous != self._playlist.getCurrentSongIndex(): + self._notifier.notify(Notifier.CURRENT_SONG_EVENT) def previousSong(self): + previous = self._playlist.getCurrentSongIndex() self._playlist.previousSong() + if previous != self._playlist.getCurrentSongIndex(): + self._notifier.notify(Notifier.CURRENT_SONG_EVENT) def getSongs(self): return self._playlist.getSongs() @@ -45,7 +54,10 @@ class SoloTool: self._abController.storeLimits(aLimit, bLimit) def loadAbLimits(self, index): + changed = index != self._abController.getLoadedIndex() self._abController.loadLimits(index) + if changed: + self._notifier.notify(Notifier.CURRENT_AB_EVENT) def setAbLimits(self, aLimit, bLimit): self._abController.setLimits(aLimit, bLimit) @@ -61,10 +73,16 @@ class SoloTool: self._abController.setEnable(enable) def nextStoredAbLimits(self): + previous = self._abController.getLoadedIndex() self._abController.nextStoredAbLimits() + if previous != self._abController.getLoadedIndex(): + self._notifier.notify(Notifier.CURRENT_AB_EVENT) def previousStoredAbLimits(self): + previous = self._abController.getLoadedIndex() self._abController.previousStoredAbLimits() + if previous != self._abController.getLoadedIndex(): + self._notifier.notify(Notifier.CURRENT_AB_EVENT) def jumpToA(self): a = self._abController.getCurrentLimits()[0] @@ -121,3 +139,9 @@ class SoloTool: def registerPlaybackRateCallback(self, callback): self._notifier.registerCallback(Notifier.PLAYBACK_RATE_EVENT, callback) + def registerCurrentSongCallback(self, callback): + self._notifier.registerCallback(Notifier.CURRENT_SONG_EVENT, callback) + + def registerCurrentAbLimitsCallback(self, callback): + self._notifier.registerCallback(Notifier.CURRENT_AB_EVENT, callback) + diff --git a/solo_tool_integrationtest.py b/solo_tool_integrationtest.py index 98dd31b..386cb26 100644 --- a/solo_tool_integrationtest.py +++ b/solo_tool_integrationtest.py @@ -407,3 +407,94 @@ def test_playbackRateNotification(uut, mockPlayer): uut.setPlaybackRate(0.5) assert not called + +def test_currentSongNotification(uut): + called = False + def callback(): + nonlocal called + called = True + + uut.registerCurrentSongCallback(callback) + assert not called + + songs = [ + "test.flac", + "test.mp3" + ] + uut.addSong(songs[0]) + assert not called + + uut.setSong(0) + assert called + called = False + + uut.addSong(songs[1]) + assert not called + + uut.setSong(0) + assert not called + + uut.setSong(1) + assert called + called = False + + uut.previousSong() + assert called + called = False + + uut.previousSong() + assert not called + + uut.nextSong() + assert called + called = False + + uut.nextSong() + assert not called + +def test_currentAbNotification(uut): + called = False + def callback(): + nonlocal called + called = True + + uut.registerCurrentAbLimitsCallback(callback) + assert not called + + song = "test.flac" + uut.addSong(song) + uut.setSong(0) + + abLimits = [ + (0.2, 0.3), + (0.4, 0.5) + ] + uut.storeAbLimits(abLimits[0][0], abLimits[0][1]) + assert not called + uut.storeAbLimits(abLimits[1][0], abLimits[1][1]) + assert not called + + uut.loadAbLimits(0) + assert called + called = False + + uut.loadAbLimits(0) + assert not called + + uut.loadAbLimits(1) + assert called + called = False + + uut.previousStoredAbLimits() + assert called + called = False + + uut.previousStoredAbLimits() + assert not called + + uut.nextStoredAbLimits() + assert called + called = False + + uut.nextStoredAbLimits() + assert not called -- cgit v1.2.3