Fix events on sounds

mpfmc/assets/sound.py

@@ -726,11 +726,11 @@ def __init__(self, sound: Union[SoundAsset, SoundPool],     # noqa
         # be overridden
         self._simultaneous_limit = sound.simultaneous_limit
         self._stealing_method = sound.stealing_method
-
-        self._track = sound.track
-        self._key = sound.key
+        self._markers = self._sound.markers
+        self._exp_time = None
 
         # Assign default values from parent sound for parameters that can be overridden
+        self._track = sound.track
         self._loops = self._sound.loops
         self._volume = self._sound.volume
         self._priority = self._sound.priority
@@ -744,68 +744,64 @@ def __init__(self, sound: Union[SoundAsset, SoundPool],     # noqa
         self._events_when_looping = self._sound.events_when_looping
         self._events_when_about_to_finish = self._sound.events_when_about_to_finish
         self._mode_end_action = self._sound.mode_end_action
-        self._markers = self._sound.markers
-        self._exp_time = None
+        self._key = sound.key
 
         if settings is None:
             settings = dict()
 
         # TODO: Implement parameter validation for overridden parameters
 
         # Assign any overridden parameter values
-        if 'track' in settings and settings['track'] is not None:
+        if settings.get('track'):
             self._track = settings['track']
 
-        if 'loops' in settings and settings['loops'] is not None:
+        if settings.get('loops'):
             self._loops = settings['loops']
 
-        if 'volume' in settings and settings['volume'] is not None:
+        if settings.get('volume'):
             self._volume = settings['volume']
 
-        if 'pan' in settings and settings['pan'] is not None:
+        if settings.get('pan'):
             self._pan = settings['pan']
 
-        if 'priority' in settings and settings['priority'] is not None:
+        if settings.get('priority'):
             self._priority = settings['priority']
 
-        if 'start_at' in settings and settings['start_at'] is not None:
+        if settings.get('start_at'):
             self._start_at = settings['start_at']
 
-        if 'fade_in' in settings and settings['fade_in'] is not None:
+        if settings.get('fade_in'):
             self._fade_in = settings['fade_in']
 
-        if 'fade_out' in settings and settings['fade_out'] is not None:
+        if settings.get('fade_out'):
             self._fade_out = settings['fade_out']
 
-        if 'about_to_finish_time' in settings:
+        if settings.get('about_to_finish_time', -1) != -1:
             self._about_to_finish_time = settings['about_to_finish_time']
 
-        if 'max_queue_time' in settings:
+        if settings.get('max_queue_time', -1) != -1:
             self._max_queue_time = settings['max_queue_time']
 
-        if 'events_when_played' in settings:
+        if settings.get('events_when_played', ['use_sound_setting']) != ['use_sound_setting']:
             self._events_when_played = settings['events_when_played']
 
-        if 'events_when_stopped' in settings:
+        if settings.get('events_when_stopped', ['use_sound_setting']) != ['use_sound_setting']:
             self._events_when_stopped = settings['events_when_stopped']
 
-        if 'events_when_looping' in settings:
+        if settings.get('events_when_looping', ['use_sound_setting']) != ['use_sound_setting']:
             self._events_when_looping = settings['events_when_looping']
 
-        if 'events_when_about_to_finish' in settings:
+        if settings.get('events_when_about_to_finish', ['use_sound_setting']) != ['use_sound_setting']:
             self._events_when_about_to_finish = settings['events_when_about_to_finish']
 
-        if 'mode_end_action' in settings and settings['mode_end_action'] is not None:
+        if settings.get('mode_end_action', 'use_sound_setting') != 'use_sound_setting':
             action = str(settings['mode_end_action']).lower()
             if action == 'stop':
                 self._mode_end_action = ModeEndAction.stop
             elif action == 'stop_looping':
                 self._mode_end_action = ModeEndAction.stop_looping
 
-        if settings is not None and 'markers' in settings:
-            self._markers = SoundAsset.load_markers(settings['markers'], self.name)
-
-        if 'key' in settings:
+        if settings.get('key', 'use_sound_setting') != 'use_sound_setting':
             self._key = settings['key']
 
     def __repr__(self):

mpfmc/config_players/plugins/sound_player.py

@@ -14,6 +14,10 @@ class MpfSoundPlayer(PluginPlayer):
     config_file_section = 'sound_player'
     show_section = 'sounds'
 
+    def get_express_config(self, value):
+        """Parse express config."""
+        return {"action": value}
+
 
 player_cls = MpfSoundPlayer
 

mpfmc/config_players/sound_player.py

@@ -187,53 +187,6 @@ def validate_config(self, config):
 
         return validated_config
 
-    def _validate_config_item(self, device, device_settings):
-        """Validates the config when in a show or in a player"""
-
-        # device is sound name
-        # Validate the settings against the config spec
-        validated_dict = super()._validate_config_item(device, device_settings)
-
-        # Remove any items from the settings that were not explicitly provided in the
-        # sound_player config section (only want to override sound settings explicitly
-        # and not with any default values).  The default values for these items are not
-        # legal values and therefore we know the user did not provide them.
-        if validated_dict[device]['track'] == 'use_sound_setting':
-            del validated_dict[device]['track']
-        if validated_dict[device]['priority'] is None:
-            del validated_dict[device]['priority']
-        if validated_dict[device]['volume'] is None:
-            del validated_dict[device]['volume']
-        if validated_dict[device]['loops'] is None:
-            del validated_dict[device]['loops']
-        if validated_dict[device]['start_at'] is None:
-            del validated_dict[device]['start_at']
-        if validated_dict[device]['fade_in'] is None:
-            del validated_dict[device]['fade_in']
-        if validated_dict[device]['fade_out'] is None:
-            del validated_dict[device]['fade_out']
-        if validated_dict[device]['about_to_finish_time'] == -1:
-            del validated_dict[device]['about_to_finish_time']
-        if validated_dict[device]['max_queue_time'] == -1:
-            del validated_dict[device]['max_queue_time']
-        if len(validated_dict[device]['events_when_played']) == 1 and \
-                validated_dict[device]['events_when_played'][0] == 'use_sound_setting':
-            del validated_dict[device]['events_when_played']
-        if len(validated_dict[device]['events_when_about_to_finish']) == 1 and \
-                validated_dict[device]['events_when_about_to_finish'][0] == 'use_sound_setting':
-            del validated_dict[device]['events_when_about_to_finish']
-        if len(validated_dict[device]['events_when_stopped']) == 1 and \
-                validated_dict[device]['events_when_stopped'][0] == 'use_sound_setting':
-            del validated_dict[device]['events_when_stopped']
-        if len(validated_dict[device]['events_when_looping']) == 1 and \
-                validated_dict[device]['events_when_looping'][0] == 'use_sound_setting':
-            del validated_dict[device]['events_when_looping']
-        if validated_dict[device]['mode_end_action'] is None or \
-                validated_dict[device]['mode_end_action'] == 'use_sound_setting':
-            del validated_dict[device]['mode_end_action']
-
-        return validated_dict
-
     def clear_context(self, context):
         """Stop all sounds from this context."""
         self.machine.log.debug("SoundPlayer: Clearing context - applying mode_end_action for all active sounds")

mpfmc/integration/machine_files/audio/config/config.yaml

@@ -34,7 +34,29 @@ assets:
 
 sounds:
   264828_text:
+    max_queue_time: 0s
     events_when_played: text_sound_played
+    events_when_stopped: text_sound_stopped
+
+sound_player:
+  play_sound_1:
+    264828_text:
+      action: play
+      events_when_played: text_sound_played_from_sound_player
+      events_when_stopped: text_sound_stopped_from_sound_player
+
+  play_sound_2:
+    264828_text:
+      action: play
+
+  play_sound_3:
+    264828_text:
+      action: play
+      events_when_played: None
+      events_when_stopped: use_sound_setting
+
+  stop_sound:
+    264828_text: stop
 
 shows:
   sound_test_1:
@@ -43,23 +65,23 @@ shows:
         264828_text:
           action: play
           events_when_played: text_sound_played_from_show
+          events_when_stopped: text_sound_stopped_from_show
 
   sound_test_2:
     - time: 0
       sounds:
         264828_text:
           action: play
 
+  sound_test_3:
+    - time: 0
+      sounds:
+        264828_text:
+          action: play
+          events_when_played: None
+          events_when_stopped: use_sound_setting
+
 show_player:
   play_sound_test_1_show: sound_test_1
   play_sound_test_2_show: sound_test_2
-
-sound_player:
-  play_sound_1:
-    264828_text:
-      action: play
-      events_when_played: text_sound_played_from_sound_player
-
-  play_sound_2:
-    264828_text:
-      action: play
+  play_sound_test_3_show: sound_test_3

mpfmc/integration/test_Audio.py

@@ -80,20 +80,48 @@ def test_sound_player_and_show(self):
         self.mock_event("text_sound_played")
         self.mock_event("text_sound_played_from_show")
         self.mock_event("text_sound_played_from_sound_player")
+        self.mock_event("text_sound_stopped")
+        self.mock_event("text_sound_stopped_from_show")
+        self.mock_event("text_sound_stopped_from_sound_player")
 
         # Play sound using sound player
         self.post_event('play_sound_1')
         self.advance_time_and_run(0.1)
         self.assertEventNotCalled("use_sound_setting")
         self.assertEventNotCalled("text_sound_played")
         self.assertEventCalled("text_sound_played_from_sound_player")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventNotCalled("text_sound_stopped")
+        self.assertEventCalled("text_sound_stopped_from_sound_player")
         self.reset_mock_events()
 
         self.post_event('play_sound_2')
         self.advance_time_and_run(0.1)
         self.assertEventNotCalled("use_sound_setting")
         self.assertEventNotCalled("text_sound_played_from_sound_player")
         self.assertEventCalled("text_sound_played")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventCalled("text_sound_stopped")
+        self.assertEventNotCalled("text_sound_stopped_from_sound_player")
+        self.reset_mock_events()
+
+        self.post_event('play_sound_3')
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventNotCalled("text_sound_played_from_sound_player")
+        self.assertEventNotCalled("text_sound_played")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventCalled("text_sound_stopped")
+        self.assertEventNotCalled("text_sound_stopped_from_sound_player")
         self.reset_mock_events()
 
         # Play first show
@@ -102,6 +130,12 @@ def test_sound_player_and_show(self):
         self.assertEventNotCalled("use_sound_setting")
         self.assertEventNotCalled("text_sound_played")
         self.assertEventCalled("text_sound_played_from_show")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventNotCalled("text_sound_stopped")
+        self.assertEventCalled("text_sound_stopped_from_show")
         self.reset_mock_events()
 
         # Play second show
@@ -110,4 +144,23 @@ def test_sound_player_and_show(self):
         self.assertEventNotCalled("use_sound_setting")
         self.assertEventNotCalled("text_sound_played_from_show")
         self.assertEventCalled("text_sound_played")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventCalled("text_sound_stopped")
+        self.assertEventNotCalled("text_sound_stopped_from_show")
         self.reset_mock_events()
+
+        # Play third show
+        self.post_event('play_sound_test_3_show')
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventNotCalled("text_sound_played_from_show")
+        self.assertEventNotCalled("text_sound_played")
+
+        self.post_event("stop_sound")
+        self.advance_time_and_run(0.1)
+        self.assertEventNotCalled("use_sound_setting")
+        self.assertEventCalled("text_sound_stopped")
+        self.assertEventNotCalled("text_sound_stopped_from_show")

mpfmc/tests/machine_files/audio/config/test_audio.yaml

@@ -74,9 +74,11 @@ sounds:
               name: verse_1
               events: moron_next_marker, last_marker
     210871_synthping:
+        priority: 1
         simultaneous_limit: 3
         stealing_method: oldest
         events_when_played: synthping_played
+        max_queue_time: 2s
     198361_sfx-028:
         simultaneous_limit: 3
         stealing_method: newest