root/trunk/libffado/support/mixer-qt4/ffado/dbus_util.py

Revision 1934, 14.2 kB (checked in by adi, 13 years ago)

Shebang-line cleanup. Closes: #292

Patch provided by Orcan Ogetbil (Fedora).

  • Property svn:mergeinfo set to
Line 
1 #
2 # Copyright (C) 2005-2008 by Pieter Palmers
3 #               2007-2008 by Arnold Krille
4 #
5 # This file is part of FFADO
6 # FFADO = Free Firewire (pro-)audio drivers for linux
7 #
8 # FFADO is based upon FreeBoB.
9 #
10 # This program is free software: you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation, either version 3 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 #
23
24 import dbus
25 import dbus.mainloop.qt
26 dbus.mainloop.qt.DBusQtMainLoop(set_as_default=True)
27
28 import logging
29 log = logging.getLogger('dbus')
30
31 class ControlInterface:
32     def __init__(self, servername, basepath):
33         self.basepath=basepath
34         self.servername=servername
35         self.bus=dbus.SessionBus()
36
37     def setContignuous(self, subpath, v, idx=None):
38         try:
39             path = self.basepath + subpath
40             dev = self.bus.get_object(self.servername, path)
41             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Continuous')
42             if idx == None:
43                 dev_cont.setValue(v)
44             else:
45                 dev_cont.setValueIdx(idx,v)
46         except:
47             log.error("Failed to set Continuous %s on server %s" % (path, self.servername))
48
49     def getContignuous(self, subpath, idx=None):
50         try:
51             path = self.basepath + subpath
52             dev = self.bus.get_object(self.servername, path)
53             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Continuous')
54             if idx == None:
55                 return dev_cont.getValue()
56             else:
57                 return dev_cont.getValueIdx(idx)
58         except:
59             log.error("Failed to get Continuous %s on server %s" % (path, self.servername))
60             return 0
61
62     def setDiscrete(self, subpath, v):
63         try:
64             path = self.basepath + subpath
65             dev = self.bus.get_object(self.servername, path)
66             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Discrete')
67             dev_cont.setValue(v)
68         except:
69             log.error("Failed to set Discrete %s on server %s" % (path, self.servername))
70
71     def getDiscrete(self, subpath):
72         try:
73             path = self.basepath + subpath
74             dev = self.bus.get_object(self.servername, path)
75             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Discrete')
76             return dev_cont.getValue()
77         except:
78             log.error("Failed to get Discrete %s on server %s" % (path, self.servername))
79             return 0
80
81     def setText(self, subpath, v):
82         try:
83             path = self.basepath + subpath
84             dev = self.bus.get_object(self.servername, path)
85             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Text')
86             dev_cont.setValue(v)
87         except:
88             log.error("Failed to set Text %s on server %s" % (path, self.servername))
89
90     def getText(self, subpath):
91         try:
92             path = self.basepath + subpath
93             dev = self.bus.get_object(self.servername, path)
94             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Text')
95             return dev_cont.getValue()
96         except:
97             log.error("Failed to get Text %s on server %s" % (path, self.servername))
98             return 0
99
100     def setMatrixMixerValue(self, subpath, row, col, v):
101         try:
102             path = self.basepath + subpath
103             dev = self.bus.get_object(self.servername, path)
104             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.MatrixMixer')
105             dev_cont.setValue(row, col, v)
106         except:
107             log.error("Failed to set MatrixMixer %s on server %s" % (path, self.servername))
108
109     def getMatrixMixerValue(self, subpath, row, col):
110         try:
111             path = self.basepath + subpath
112             dev = self.bus.get_object(self.servername, path)
113             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.MatrixMixer')
114             return dev_cont.getValue(row, col)
115         except:
116             log.error("Failed to get MatrixMixer %s on server %s" % (path, self.servername))
117             return 0
118
119     def enumSelect(self, subpath, v):
120         try:
121             path = self.basepath + subpath
122             dev = self.bus.get_object(self.servername, path)
123             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum')
124             dev_cont.select(v)
125         except:
126             log.error("Failed to select %s on server %s" % (path, self.servername))
127
128     def enumSelected(self, subpath):
129         try:
130             path = self.basepath + subpath
131             dev = self.bus.get_object(self.servername, path)
132             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum')
133             return dev_cont.selected()
134         except:
135             log.error("Failed to get selected enum %s on server %s" % (path, self.servername))
136             return 0
137
138     def enumGetLabel(self, subpath, v):
139         try:
140             path = self.basepath + subpath
141             dev = self.bus.get_object(self.servername, path)
142             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum')
143             return dev_cont.getEnumLabel(v)
144         except:
145             log.error("Failed to get enum label %s on server %s" % (path, self.servername))
146             return 0
147
148     def enumCount(self, subpath):
149         try:
150             path = self.basepath + subpath
151             dev = self.bus.get_object(self.servername, path)
152             dev_cont = dbus.Interface(dev, dbus_interface='org.ffado.Control.Element.Enum')
153             return dev_cont.count()
154         except:
155             log.error("Failed to get enum count %s on server %s" % (path, self.servername))
156             return 0
157
158 class DeviceManagerInterface:
159     """ Implementation of the singleton """
160     def __init__(self, servername, basepath):
161         self.basepath=basepath + '/DeviceManager'
162         self.servername=servername
163         self.bus=dbus.SessionBus()
164         self.dev = self.bus.get_object(self.servername, self.basepath)
165         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Container')
166
167         self.updateSignalHandlers = []
168         self.updateSignalHandlerArgs = {}
169         self.preUpdateSignalHandlers = []
170         self.preUpdateSignalHandlerArgs = {}
171         self.postUpdateSignalHandlers = []
172         self.postUpdateSignalHandlerArgs = {}
173         self.destroyedSignalHandlers = []
174         self.destroyedSignalHandlerArgs = {}
175
176         # signal reception does not work yet since we need a mainloop for that
177         # and qt3 doesn't provide one for python/dbus
178         try:
179             log.debug("connecting to: Updated on %s (server: %s)" % (self.basepath, self.servername))
180             self.dev.connect_to_signal("Updated", self.updateSignal, \
181                                     dbus_interface="org.ffado.Control.Element.Container")
182             self.dev.connect_to_signal("PreUpdate", self.preUpdateSignal, \
183                                     dbus_interface="org.ffado.Control.Element.Container")
184             self.dev.connect_to_signal("PostUpdate", self.postUpdateSignal, \
185                                     dbus_interface="org.ffado.Control.Element.Container")
186             self.dev.connect_to_signal("Destroyed", self.destroyedSignal, \
187                                     dbus_interface="org.ffado.Control.Element.Container")
188
189         except dbus.DBusException:
190             traceback.print_exc()
191
192     def registerPreUpdateCallback(self, callback, arg=None):
193         if not callback in self.preUpdateSignalHandlers:
194             self.preUpdateSignalHandlers.append(callback)
195         # always update the argument
196         self.preUpdateSignalHandlerArgs[callback] = arg
197
198     def registerPostUpdateCallback(self, callback, arg=None):
199         if not callback in self.postUpdateSignalHandlers:
200             self.postUpdateSignalHandlers.append(callback)
201         # always update the argument
202         self.postUpdateSignalHandlerArgs[callback] = arg
203
204     def registerUpdateCallback(self, callback, arg=None):
205         if not callback in self.updateSignalHandlers:
206             self.updateSignalHandlers.append(callback)
207         # always update the argument
208         self.updateSignalHandlerArgs[callback] = arg
209
210     def registerDestroyedCallback(self, callback, arg=None):
211         if not callback in self.destroyedSignalHandlers:
212             self.destroyedSignalHandlers.append(callback)
213         # always update the argument
214         self.destroyedSignalHandlerArgs[callback] = arg
215
216     def updateSignal(self):
217         log.debug("Received update signal")
218         for handler in self.updateSignalHandlers:
219             arg = self.updateSignalHandlerArgs[handler]
220             try:
221                 if arg:
222                     handler(arg)
223                 else:
224                     handler()
225             except:
226                 log.error("Failed to execute handler %s" % handler)
227
228     def preUpdateSignal(self):
229         log.debug("Received pre-update signal")
230         for handler in self.preUpdateSignalHandlers:
231             arg = self.preUpdateSignalHandlerArgs[handler]
232             try:
233                 if arg:
234                     handler(arg)
235                 else:
236                     handler()
237             except:
238                 log.error("Failed to execute handler %s" % handler)
239
240     def postUpdateSignal(self):
241         log.debug("Received post-update signal")
242         for handler in self.postUpdateSignalHandlers:
243             arg = self.postUpdateSignalHandlerArgs[handler]
244             try:
245                 if arg:
246                     handler(arg)
247                 else:
248                     handler()
249             except:
250                 log.error("Failed to execute handler %s" % handler)
251
252     def destroyedSignal(self):
253         log.debug("Received destroyed signal")
254         for handler in self.destroyedSignalHandlers:
255             arg = self.destroyedSignalHandlerArgs[handler]
256             try:
257                 if arg:
258                     handler(arg)
259                 else:
260                     handler()
261             except:
262                 log.error("Failed to execute handler %s" % handler)
263
264     def getNbDevices(self):
265         return self.iface.getNbElements()
266     def getDeviceName(self, idx):
267         return self.iface.getElementName(idx)
268
269 class ConfigRomInterface:
270     def __init__(self, servername, devicepath):
271         self.basepath=devicepath + '/ConfigRom'
272         self.servername=servername
273         self.bus=dbus.SessionBus()
274         self.dev = self.bus.get_object(self.servername, self.basepath)
275         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.ConfigRomX')
276     def getGUID(self):
277         return self.iface.getGUID()
278     def getVendorName(self):
279         return self.iface.getVendorName()
280     def getModelName(self):
281         return self.iface.getModelName()
282     def getVendorId(self):
283         return self.iface.getVendorId()
284     def getModelId(self):
285         return self.iface.getModelId()
286     def getUnitVersion(self):
287         return self.iface.getUnitVersion()
288
289 class ClockSelectInterface:
290     def __init__(self, servername, devicepath):
291         self.basepath=devicepath + '/Generic/ClockSelect'
292         self.servername=servername
293         self.bus=dbus.SessionBus()
294         self.dev = self.bus.get_object(self.servername, self.basepath)
295         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.AttributeEnum')
296         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element')
297     def count(self):
298         return self.iface.count()
299     def select(self, idx):
300         return self.iface.select(idx)
301     def selected(self):
302         return self.iface.selected()
303     def getEnumLabel(self, idx):
304         return self.iface.getEnumLabel(idx)
305     def attributeCount(self):
306         return self.iface.attributeCount()
307     def getAttributeValue(self, idx):
308         return self.iface.getAttributeValue(idx)
309     def getAttributeName(self, idx):
310         return self.iface.getAttributeName(idx)
311     def canChangeValue(self):
312         return self.iface_element.canChangeValue()
313
314 class EnumInterface:
315     def __init__(self, servername, basepath):
316         self.basepath = basepath
317         self.servername = servername
318         self.bus = dbus.SessionBus()
319         self.dev = self.bus.get_object(self.servername, self.basepath)
320         self.iface = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Enum')
321         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element')
322     def count(self):
323         return self.iface.count()
324     def select(self, idx):
325         return self.iface.select(idx)
326     def selected(self):
327         return self.iface.selected()
328     def getEnumLabel(self, idx):
329         return self.iface.getEnumLabel(idx)
330     def canChangeValue(self):
331         return self.iface_element.canChangeValue()
332
333 class SamplerateSelectInterface(EnumInterface):
334     def __init__(self, servername, devicepath):
335         EnumInterface.__init__(self, servername, devicepath + '/Generic/SamplerateSelect')
336
337 class StreamingStatusInterface(EnumInterface):
338     def __init__(self, servername, devicepath):
339         EnumInterface.__init__(self, servername, devicepath + '/Generic/StreamingStatus')
340
341 class TextInterface:
342     def __init__(self, servername, basepath):
343         self.basepath=basepath
344         self.servername=servername
345         self.bus=dbus.SessionBus()
346         self.dev = self.bus.get_object( self.servername, self.basepath )
347         self.iface = dbus.Interface( self.dev, dbus_interface="org.ffado.Control.Element.Text" )
348         self.iface_element = dbus.Interface(self.dev, dbus_interface='org.ffado.Control.Element.Element')
349     def text(self):
350         return self.iface.getValue()
351     def setText(self,text):
352         self.iface.setValue(text)
353     def canChangeValue(self):
354         return self.iface_element.canChangeValue()
355
356 # vim: et
Note: See TracBrowser for help on using the browser.