make triggers / voice triggers more general

* don't pass the trigger_name parameter as we can set it as class property

* add optional validate_config() method to BaseTrigger

* new base class VoiceTrigger for voice triggers such as pocketsphinx or snowboy

src/alexapi/triggers/__init__.py

@@ -38,6 +38,13 @@ def disable(type_filter=None):
  trigger.disable()
 
 
+def cleanup(type_filter=None):
+ for name in triggers:
+ trigger = triggers[name]
+ if (not type_filter) or (trigger.type == type_filter):
+ trigger.cleanup()
+
+
 class TYPES(object):
  OTHER = 0
  VOICE = 1

src/alexapi/triggers/basetrigger.py

@@ -4,7 +4,7 @@
 class BaseTrigger:
  __metaclass__ = ABCMeta
 
- name = None
+ name = ''
  type = None
  event_type = None
  voice_confirm = None
@@ -13,15 +13,18 @@ class BaseTrigger:
  _config = None
  _tconfig = None
 
- def __init__(self, config, trigger_callback, trigger_name):
-
- self.name = trigger_name
+ def __init__(self, config, trigger_callback):
 
  self._config = config
- self._tconfig = config['triggers'][trigger_name]
+ self._tconfig = config['triggers'][self.name]
  self._trigger_callback = trigger_callback
  self.voice_confirm = self._tconfig['voice_confirm']
 
+ self.validate_config()
+
+ def validate_config(self):
+ pass
+
  @abstractmethod
  def setup(self):
  pass
@@ -37,3 +40,6 @@ def enable(self):
  @abstractmethod
  def disable(self):
  pass
+
+ def cleanup(self):
+ pass

src/alexapi/triggers/platformtrigger.py

@@ -12,12 +12,13 @@
 class PlatformTrigger(BaseTrigger):
 
  type = triggers.TYPES.OTHER
+ name = 'platform'
 
  _platform_continuous_callback = None
 
  def __init__(self, config, trigger_callback):
 
- super(PlatformTrigger, self).__init__(config, trigger_callback, 'platform')
+ super(PlatformTrigger, self).__init__(config, trigger_callback)
 
  event_types = {
  'oneshot-vad': triggers.EVENT_TYPES.ONESHOT_VAD,

src/alexapi/triggers/pocketsphinxtrigger.py

@@ -6,23 +6,22 @@
 from pocketsphinx import get_model_path
 from pocketsphinx.pocketsphinx import Decoder
 
-import alexapi.triggers as triggers
-from .basetrigger import BaseTrigger
+from .voicetrigger import VoiceTrigger
 
 logger = logging.getLogger(__name__)
 
 
-class PocketsphinxTrigger(BaseTrigger):
+class PocketsphinxTrigger(VoiceTrigger):
 
- type = triggers.TYPES.VOICE
+ name = 'pocketsphinx'
 
  AUDIO_CHUNK_SIZE = 1024
  AUDIO_RATE = 16000
 
  _capture = None
 
  def __init__(self, config, trigger_callback, capture):
- super(PocketsphinxTrigger, self).__init__(config, trigger_callback, 'pocketsphinx')
+ super(PocketsphinxTrigger, self).__init__(config, trigger_callback)
 
  self._capture = capture
 
@@ -52,20 +51,15 @@ def setup(self):
  ps_config.set_string('-logfn', null_path)
 
  # Process audio chunk by chunk. On keyword detected perform action and restart search
- self._decoder = Decoder(ps_config)
-
- def run(self):
- thread = threading.Thread(target=self.thread, args=())
- thread.setDaemon(True)
- thread.start()
+ self._detector = Decoder(ps_config)
 
  def thread(self):
  while True:
  self._enabled_lock.wait()
 
  self._capture.handle_init(self.AUDIO_RATE, self.AUDIO_CHUNK_SIZE)
 
- self._decoder.start_utt()
+ self._detector.start_utt()
 
  triggered = False
  while not triggered:
@@ -77,23 +71,15 @@ def thread(self):
  data = self._capture.handle_read()
 
  # Detect if keyword/trigger word was said
- self._decoder.process_raw(data, False, False)
+ self._detector.process_raw(data, False, False)
 
- triggered = self._decoder.hyp() is not None
+ triggered = self._detector.hyp() is not None
 
  self._capture.handle_release()
 
- self._decoder.end_utt()
+ self._detector.end_utt()
 
  self._disabled_sync_lock.set()
 
  if triggered:
  self._trigger_callback(self)
-
- def enable(self):
- self._enabled_lock.set()
- self._disabled_sync_lock.clear()
-
- def disable(self):
- self._enabled_lock.clear()
- self._disabled_sync_lock.wait()

src/alexapi/triggers/voicetrigger.py

@@ -0,0 +1,40 @@
+import threading
+from abc import ABCMeta, abstractmethod
+
+import alexapi.triggers as triggers
+from .basetrigger import BaseTrigger
+
+
+class VoiceTrigger(BaseTrigger):
+ __metaclass__ = ABCMeta
+
+ type = triggers.TYPES.VOICE
+
+ _detector = None
+
+ _enabled_lock = None
+ _disabled_sync_lock = None
+
+ def __init__(self, config, trigger_callback):
+
+ super(VoiceTrigger, self).__init__(config, trigger_callback)
+
+ self._enabled_lock = threading.Event()
+ self._disabled_sync_lock = threading.Event()
+
+ @abstractmethod
+ def thread(self):
+ pass
+
+ def run(self):
+ thread = threading.Thread(target=self.thread, args=())
+ thread.setDaemon(True)
+ thread.start()
+
+ def enable(self):
+ self._enabled_lock.set()
+ self._disabled_sync_lock.clear()
+
+ def disable(self):
+ self._enabled_lock.clear()
+ self._disabled_sync_lock.wait()

src/main.py

@@ -543,6 +543,7 @@ def trigger_process(trigger):
 
 def cleanup(signal, frame): # pylint: disable=redefined-outer-name,unused-argument
  triggers.disable()
+ triggers.cleanup()
  capture.cleanup()
  pHandler.cleanup()
  platform.cleanup()
@@ -561,15 +562,14 @@ def cleanup(signal, frame): # pylint: disable=redefined-outer-name,unused-argu
 
  try:
  capture = alexapi.capture.Capture(config, tmp_path)
+ capture.setup(platform.indicate_recording)
+
+ triggers.init(config, trigger_callback, capture)
+ triggers.setup()
  except ConfigurationException as exp:
  logger.critical(exp)
  sys.exit(1)
 
- capture.setup(platform.indicate_recording)
-
- triggers.init(config, trigger_callback, capture)
- triggers.setup()
-
  pHandler.setup()
  platform.setup()