git.maemo.org Git - gc-dialer/blob - dialcentral/stream_handler.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import with_statement
   4 from __future__ import division
   5
   6 import logging
   7
   8 import util.qt_compat as qt_compat
   9 QtCore = qt_compat.QtCore
  10
  11 import util.misc as misc_utils
  12 try:
  13         import stream_gst
  14         stream = stream_gst
  15 except ImportError:
  16         try:
  17                 import stream_osso
  18                 stream = stream_osso
  19         except ImportError:
  20                 import stream_null
  21                 stream = stream_null
  22
  23
  24 _moduleLogger = logging.getLogger(__name__)
  25
  26
  27 class StreamToken(QtCore.QObject):
  28
  29         stateChange = qt_compat.Signal(str)
  30         invalidated = qt_compat.Signal()
  31         error = qt_compat.Signal(str)
  32
  33         STATE_PLAY = stream.Stream.STATE_PLAY
  34         STATE_PAUSE = stream.Stream.STATE_PAUSE
  35         STATE_STOP = stream.Stream.STATE_STOP
  36
  37         def __init__(self, stream):
  38                 QtCore.QObject.__init__(self)
  39                 self._stream = stream
  40                 self._stream.connect("state-change", self._on_stream_state)
  41                 self._stream.connect("eof", self._on_stream_eof)
  42                 self._stream.connect("error", self._on_stream_error)
  43
  44         @property
  45         def state(self):
  46                 if self.isValid:
  47                         return self._stream.state
  48                 else:
  49                         return self.STATE_STOP
  50
  51         @property
  52         def isValid(self):
  53                 return self._stream is not None
  54
  55         def play(self):
  56                 self._stream.play()
  57
  58         def pause(self):
  59                 self._stream.pause()
  60
  61         def stop(self):
  62                 self._stream.stop()
  63
  64         def invalidate(self):
  65                 if self._stream is None:
  66                         return
  67                 _moduleLogger.info("Playback token invalidated")
  68                 self._stream = None
  69
  70         @misc_utils.log_exception(_moduleLogger)
  71         def _on_stream_state(self, s, state):
  72                 if not self.isValid:
  73                         return
  74                 if state == self.STATE_STOP:
  75                         self.invalidate()
  76                 self.stateChange.emit(state)
  77
  78         @misc_utils.log_exception(_moduleLogger)
  79         def _on_stream_eof(self, s, uri):
  80                 if not self.isValid:
  81                         return
  82                 self.invalidate()
  83                 self.stateChange.emit(self.STATE_STOP)
  84
  85         @misc_utils.log_exception(_moduleLogger)
  86         def _on_stream_error(self, s, error, debug):
  87                 if not self.isValid:
  88                         return
  89                 _moduleLogger.info("Error %s %s" % (error, debug))
  90                 self.error.emit(str(error))
  91
  92
  93 class StreamHandler(QtCore.QObject):
  94
  95         def __init__(self):
  96                 QtCore.QObject.__init__(self)
  97                 self._stream = stream.Stream()
  98                 self._token = StreamToken(self._stream)
  99
 100         def set_file(self, path):
 101                 self._token.invalidate()
 102                 self._token = StreamToken(self._stream)
 103                 self._stream.set_file(path)
 104                 return self._token
 105
 106         @misc_utils.log_exception(_moduleLogger)
 107         def _on_stream_state(self, s, state):
 108                 _moduleLogger.info("State change %r" % state)
 109
 110
 111 if __name__ == "__main__":
 112         pass
 113