def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
if self.service is not None:
self.type = self.service.service_type.split(":")[3] # get the service name
self.type = self.type.replace("-", "")
else:
self.type = "from_the_tubes"
try:
bus_name = dbus.service.BusName(SERVICE_IFACE, bus)
except:
bus_name = None
self.tube = bus
else:
self.tube = None
if self.dbus_device is not None:
self.device_id = self.dbus_device.id
else:
self.device_id = "dev_from_the_tubes"
self.path = OBJECT_PATH + "/devices/" + self.device_id + "/services/" + self.type
dbus.service.Object.__init__(self, bus, bus_name=bus_name, object_path=self.path)
self.debug("DBusService %r %r", service, self.type)
louie.connect(self.variable_changed, "Coherence.UPnP.StateVariable.changed", sender=self.service)
self.subscribe()
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_connection_device = None
self.wan_common_interface_connection = None
self.embedded_device_detection_completed = False
self.service_detection_completed = False
louie.connect(self.embedded_device_notified, signal='Coherence.UPnP.EmbeddedDeviceClient.detection_completed', sender=self.device)
try:
wan_connection_device = self.device.get_embedded_device_by_type('WANConnectionDevice')[0]
self.wan_connection_device = WANConnectionDeviceClient(wan_connection_device)
except:
self.warning("Embedded WANConnectionDevice device not available, device not implemented properly according to the UPnP specification")
raise
louie.connect(self.service_notified, signal='Coherence.UPnP.DeviceClient.Service.notified', sender=self.device)
for service in self.device.get_services():
if service.get_type() in ["urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1"]:
self.wan_common_interface_connection = WANCommonInterfaceConfigClient(service)
self.info("WANDevice %s" % (self.device.get_friendly_name()))
def __init__(self, device):
log.Loggable.__init__(self)
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_device = None
self.detection_completed = False
louie.connect(
self.embedded_device_notified,
signal='Coherence.UPnP.EmbeddedDeviceClient.detection_completed',
sender=self.device)
try:
wan_device = self.device.get_embedded_device_by_type(
'WANDevice')[0]
self.wan_device = WANDeviceClient(wan_device)
except:
self.warning(
"Embedded WANDevice device not available, device not implemented properly according to the UPnP specification"
)
raise
self.info("InternetGatewayDevice %s", self.device.get_friendly_name())
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.switch_power = None
self.detection_completed = False
louie.connect(self.service_notified,
signal='Coherence.UPnP.DeviceClient.Service.notified',
sender=self.device)
for service in self.device.get_services():
if service.get_type() in [
"urn:schemas-upnp-org:service:SwitchPower:1"
]:
self.switch_power = SwitchPowerClient(service)
self.info("BinaryLight %s" % (self.device.get_friendly_name()))
if self.switch_power:
self.info("SwitchPower service available")
else:
self.warning(
"SwitchPower service not available, device not implemented properly according to the UPnP specification"
)
def __init__(self, coherence, backend, **kwargs):
self.coherence = coherence
if not hasattr(self, 'version'):
self.version = int(
kwargs.get('version', self.coherence.config.get('version', 2)))
try:
self.uuid = kwargs['uuid']
if not self.uuid.startswith('uuid:'):
self.uuid = 'uuid:' + self.uuid
except KeyError:
from coherence.upnp.core.uuid import UUID
self.uuid = UUID()
self.backend = None
urlbase = self.coherence.urlbase
if urlbase[-1] != '/':
urlbase += '/'
self.urlbase = urlbase + str(self.uuid)[5:]
kwargs['urlbase'] = self.urlbase
self.icons = kwargs.get('iconlist', kwargs.get('icons', []))
if len(self.icons) == 0:
if kwargs.has_key('icon'):
if isinstance(kwargs['icon'], dict):
self.icons.append(kwargs['icon'])
else:
self.icons = kwargs['icon']
louie.connect(self.init_complete,
'Coherence.UPnP.Backend.init_completed', louie.Any)
louie.connect(self.init_failed, 'Coherence.UPnP.Backend.init_failed',
louie.Any)
reactor.callLater(0.2, self.fire, backend, **kwargs)
def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
if self.service is not None:
self.type = self.service.service_type.split(':')[3] # get the service name
else:
self.type = "from_the_tubes"
try:
bus_name = dbus.service.BusName(CDS_SERVICE, bus)
except:
bus_name = None
self.tube = bus
else:
self.tube = None
if dbus_device:
device_id = dbus_device.id
else:
device_id = "dev_from_the_tubes"
self.path = OBJECT_PATH + '/devices/' + device_id + '/services/' + 'CDS'
s = dbus.service.Object.__init__(self, bus, bus_name=bus_name,
object_path=self.path)
self.debug("DBusService %r %r %r", service, self.type, s)
louie.connect(self.variable_changed, 'StateVariable.changed', sender=self.service)
self.subscribeStateVariables()
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.switch_power = None
self.dimming = None
self.detection_completed = False
louie.connect(self.service_notified, signal='Coherence.UPnP.DeviceClient.Service.notified', sender=self.device)
for service in self.device.get_services():
if service.get_type() in ["urn:schemas-upnp-org:service:SwitchPower:1"]:
self.switch_power = SwitchPowerClient(service)
if service.get_type() in ["urn:schemas-upnp-org:service:Dimming:1"]:
self.dimming = DimmingClient(service)
self.info("DimmingLight %s" % (self.device.get_friendly_name()))
if self.switch_power:
self.info("SwitchPower service available")
else:
self.warning("SwitchPower service not available, device not implemented properly according to the UPnP specification")
return
if self.dimming:
self.info("Dimming service available")
else:
self.warning("Dimming service not available, device not implemented properly according to the UPnP specification")
def __init__(self, device):
log.Loggable.__init__(self)
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_ip_connection = None
self.wan_ppp_connection = None
self.detection_completed = False
louie.connect(self.service_notified,
signal='Coherence.UPnP.DeviceClient.Service.notified',
sender=self.device)
for service in self.device.get_services():
if service.get_type() in [
"urn:schemas-upnp-org:service:WANIPConnection:1"
]:
self.wan_ip_connection = WANIPConnectionClient(service)
if service.get_type() in [
"urn:schemas-upnp-org:service:WANPPPConnection:1"
]:
self.wan_ppp_connection = WANPPPConnectionClient(service)
self.info("WANConnectionDevice %s", self.device.get_friendly_name())
if self.wan_ip_connection:
self.info("WANIPConnection service available")
if self.wan_ppp_connection:
self.info("WANPPPConnection service available")
def __init__(self, server, **kwargs):
log.Loggable.__init__(self)
self.next_id = 1000
self.config = kwargs
self.name = kwargs.get('name', 'Buzztard')
self.urlbase = kwargs.get('urlbase', '')
if (len(self.urlbase) > 0
and self.urlbase[len(self.urlbase) - 1] != '/'):
self.urlbase += '/'
self.host = kwargs.get('host', '127.0.0.1')
self.port = int(kwargs.get('port', 7654))
self.server = server
self.update_id = 0
self.store = {}
self.parent = None
louie.connect(self.add_content, 'Buzztard.Response.browse', louie.Any)
louie.connect(self.clear, 'Buzztard.Response.flush', louie.Any)
self.buzztard = BzConnection(backend=self,
host=self.host,
port=self.port)
def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
if self.service is not None:
self.type = self.service.service_type.split(':')[
3] # get the service name
self.type = self.type.replace('-', '')
else:
self.type = "from_the_tubes"
try:
bus_name = dbus.service.BusName(SERVICE_IFACE, bus)
except:
bus_name = None
self.tube = bus
else:
self.tube = None
if self.dbus_device is not None:
self.device_id = self.dbus_device.id
else:
self.device_id = "dev_from_the_tubes"
self.path = OBJECT_PATH + '/devices/' + self.device_id + '/services/' + self.type
dbus.service.Object.__init__(self,
bus,
bus_name=bus_name,
object_path=self.path)
self.debug("DBusService %r %r", service, self.type)
louie.connect(self.variable_changed,
'Coherence.UPnP.StateVariable.changed',
sender=self.service)
self.subscribe()
def __init__(self, coherence, backend, **kwargs):
self.coherence = coherence
if not hasattr(self, 'version'):
self.version = int(kwargs.get('version', self.coherence.config.get('version', 2)))
try:
self.uuid = kwargs['uuid']
if not self.uuid.startswith('uuid:'):
self.uuid = 'uuid:' + self.uuid
except KeyError:
from coherence.upnp.core.uuid import UUID
self.uuid = UUID()
self.backend = None
urlbase = self.coherence.urlbase
if urlbase[-1] != '/':
urlbase += '/'
self.urlbase = urlbase + str(self.uuid)[5:]
kwargs['urlbase'] = self.urlbase
self.icons = kwargs.get('iconlist', kwargs.get('icons', []))
if len(self.icons) == 0:
if kwargs.has_key('icon'):
if isinstance(kwargs['icon'], dict):
self.icons.append(kwargs['icon'])
else:
self.icons = kwargs['icon']
louie.connect(self.init_complete, 'Coherence.UPnP.Backend.init_completed', louie.Any)
louie.connect(self.init_failed, 'Coherence.UPnP.Backend.init_failed', louie.Any)
reactor.callLater(0.2, self.fire, backend, **kwargs)
def connect(self,
receiver,
signal=louie.signal.All,
sender=louie.sender.Any,
weak=True):
""" wrapper method around louie.connect
"""
louie.connect(receiver, signal=signal, sender=sender, weak=weak)
def subscribe_for_variable(self, var_name, instance=0, callback=None, signal=False):
variable = self.get_state_variable(var_name)
if variable:
if callback is not None:
if signal:
callback(variable)
louie.connect(callback, signal='Coherence.UPnP.StateVariable.%s.changed' % var_name, sender=self)
else:
variable.subscribe(callback)
def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
self.type = self.service.service_type.split(':')[3] # get the service name
bus_name = dbus.service.BusName(BUS_NAME+'.service', bus)
s = dbus.service.Object.__init__(self, bus_name, OBJECT_PATH + '/devices/' + dbus_device.id + '/services/' + self.type)
self.debug("DBusService %r %r %r", service, self.type, s)
louie.connect(self.variable_changed, 'Coherence.UPnP.StateVariable.changed', sender=self.service)
self.subscribe()
def connect(self, receiver, signal = louie.signal.All, sender = louie.sender.Any, weak = True):
""" wrapper method around louie.connect
@param receiver: Method to connect to.
@param signal:
@param sender:
@param weak:
"""
#print " Connect #3 (ControlPoint) Receiver:{0:}, Signal:{1:}, Sender:{2:}, Weak:{3:}".format(receiver, signal, sender, weak)
louie.connect(receiver, signal = signal, sender = sender, weak = weak)
def testBrowse(self):
self._log.info( "\ntestBrowse" )
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigUPNP) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
louie.connect( self.mediaserver_detected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
time.sleep(30)
def load_device_info(self, device_infos): # Return a deferred that signals that the device's info is loaded # Bridges the coherence louie event bus to a single deferred def receive_callback(device): if device == self.device: louie.disconnect(receive_callback, 'Coherence.UPnP.RootDevice.detection_completed') d.callback(device) d = Deferred() louie.connect(receive_callback, 'Coherence.UPnP.RootDevice.detection_completed', louie.Any) self.device = RootDevice(device_infos) return d
def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
self.type = self.service.service_type.split(":")[3] # get the service name
bus_name = dbus.service.BusName(CDS_SERVICE, bus)
device_id = dbus_device.id
self.path = OBJECT_PATH + "/devices/" + device_id + "/services/" + "CDS"
dbus.service.Object.__init__(self, bus, bus_name=bus_name, object_path=self.path)
self.debug("DBusService %r %r", service, self.type)
louie.connect(self.variable_changed, "StateVariable.changed", sender=self.service)
self.subscribeStateVariables()
def __init__(self, device):
log.Loggable.__init__(self)
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.scheduled_recording = None
self.content_directory = None
self.connection_manager = None
self.av_transport = None
self.detection_completed = False
louie.connect(self.service_notified,
signal='Coherence.UPnP.DeviceClient.Service.notified',
sender=self.device)
for service in self.device.get_services():
if service.get_type() in [
"urn:schemas-upnp-org:service:ContentDirectory:1",
"urn:schemas-upnp-org:service:ContentDirectory:2"
]:
self.content_directory = ContentDirectoryClient(service)
if service.get_type() in [
"urn:schemas-upnp-org:service:ConnectionManager:1",
"urn:schemas-upnp-org:service:ConnectionManager:2"
]:
self.connection_manager = ConnectionManagerClient(service)
if service.get_type() in [
"urn:schemas-upnp-org:service:AVTransport:1",
"urn:schemas-upnp-org:service:AVTransport:2"
]:
self.av_transport = AVTransportClient(service)
self.info("MediaServer %s", self.device.get_friendly_name())
if self.content_directory:
self.info("ContentDirectory available")
else:
self.warning(
"ContentDirectory not available, device not implemented properly according to the UPnP specification"
)
return
if self.connection_manager:
self.info("ConnectionManager available")
else:
self.warning(
"ConnectionManager not available, device not implemented properly according to the UPnP specification"
)
return
if self.av_transport:
self.info("AVTransport (optional) available")
if self.scheduled_recording:
self.info("ScheduledRecording (optional) available")
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.scheduled_recording = None
self.content_directory = None
self.connection_manager = None
self.av_transport = None
self.detection_completed = False
louie.connect(self.service_notified, signal="Coherence.UPnP.DeviceClient.Service.notified", sender=self.device)
for service in self.device.get_services():
if service.get_type() in [
"urn:schemas-upnp-org:service:ContentDirectory:1",
"urn:schemas-upnp-org:service:ContentDirectory:2",
]:
self.content_directory = ContentDirectoryClient(service)
if service.get_type() in [
"urn:schemas-upnp-org:service:ConnectionManager:1",
"urn:schemas-upnp-org:service:ConnectionManager:2",
]:
self.connection_manager = ConnectionManagerClient(service)
if service.get_type() in [
"urn:schemas-upnp-org:service:AVTransport:1",
"urn:schemas-upnp-org:service:AVTransport:2",
]:
self.av_transport = AVTransportClient(service)
# if service.get_type() in ["urn:schemas-upnp-org:service:ScheduledRecording:1",
# "urn:schemas-upnp-org:service:ScheduledRecording:2"]:
# self.scheduled_recording = ScheduledRecordingClient( service)
self.info("MediaServer %s" % (self.device.get_friendly_name()))
if self.content_directory:
self.info("ContentDirectory available")
else:
self.warning(
"ContentDirectory not available, device not implemented properly according to the UPnP specification"
)
return
if self.connection_manager:
self.info("ConnectionManager available")
else:
self.warning(
"ConnectionManager not available, device not implemented properly according to the UPnP specification"
)
return
if self.av_transport:
self.info("AVTransport (optional) available")
if self.scheduled_recording:
self.info("ScheduledRecording (optional) available")
def __init__(self, infos):
self.usn = infos['USN']
self.server = infos['SERVER']
self.st = infos['ST']
self.location = infos['LOCATION']
self.manifestation = infos['MANIFESTATION']
self.host = infos['HOST']
self.root_detection_completed = False
Device.__init__(self, None)
louie.connect(self.device_detect, 'Coherence.UPnP.Device.detection_completed', self)
# we need to handle root device completion
# these events could be ourself or our children.
self.parse_description()
def __init__(self, infos):
self.usn = infos['USN']
self.server = infos['SERVER']
self.st = infos['ST']
self.location = infos['LOCATION']
self.manifestation = infos['MANIFESTATION']
self.host = infos['HOST']
self.root_detection_completed = False
Device.__init__(self, None)
louie.connect( self.device_detect, 'Coherence.UPnP.Device.detection_completed', self)
# we need to handle root device completion
# these events could be ourself or our children.
self.parse_description()
def __init__(self, parent=None):
self.parent = parent
self.services = []
self.friendly_name = ""
self.device_type = ""
self.friendly_device_type = "[unknown]"
self.device_type_version = 0
self.udn = None
self.detection_completed = False
self.client = None
self.icons = []
self.devices = []
louie.connect(self.receiver, "Coherence.UPnP.Service.detection_completed", self)
louie.connect(self.service_detection_failed, "Coherence.UPnP.Service.detection_failed", self)
def __init__(self, parent=None):
self.parent = parent
self.services = []
#self.uid = self.usn[:-len(self.st)-2]
self.friendly_name = ""
self.device_type = ""
self.udn = None
self.detection_completed = False
self.client = None
self.icons = []
self.devices = []
louie.connect( self.receiver, 'Coherence.UPnP.Service.detection_completed', self)
louie.connect( self.service_detection_failed, 'Coherence.UPnP.Service.detection_failed', self)
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.rendering_control = None
self.connection_manager = None
self.av_transport = None
self.detection_completed = False
louie.connect(self.service_notified, signal='Coherence.UPnP.DeviceClient.Service.notified', sender=self.device)
for service in self.device.get_services():
if service.get_type() in ["urn:schemas-upnp-org:service:RenderingControl:1",
"urn:schemas-upnp-org:service:RenderingControl:2"]:
self.rendering_control = RenderingControlClient( service)
if service.get_type() in ["urn:schemas-upnp-org:service:ConnectionManager:1",
"urn:schemas-upnp-org:service:ConnectionManager:2"]:
self.connection_manager = ConnectionManagerClient( service)
if service.get_type() in ["urn:schemas-upnp-org:service:AVTransport:1",
"urn:schemas-upnp-org:service:AVTransport:2"]:
self.av_transport = AVTransportClient( service)
self.info("MediaRenderer %s" % (self.device.get_friendly_name()))
if self.rendering_control:
self.info("RenderingControl available")
"""
actions = self.rendering_control.service.get_actions()
print actions
for action in actions:
print "Action:", action
for arg in actions[action].get_arguments_list():
print " ", arg
"""
#self.rendering_control.list_presets()
#self.rendering_control.get_mute()
#self.rendering_control.get_volume()
#self.rendering_control.set_mute(desired_mute=1)
else:
self.warning("RenderingControl not available, device not implemented properly according to the UPnP specification")
return
if self.connection_manager:
self.info("ConnectionManager available")
#self.connection_manager.get_protocol_info()
else:
self.warning("ConnectionManager not available, device not implemented properly according to the UPnP specification")
return
if self.av_transport:
self.info("AVTransport (optional) available")
def testBrowse2(self):
self._log.info( "\ntestBrowse2" )
louie.connect( self.add_server, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
self.loader = EventRouterLoader()
self.loader.loadHandlers( getDictFromXmlString(testConfigUPNP) )
self.loader.start() # all tasks
self.router = self.loader.getEventRouter()
self.directory = UPNP_Directory()
time.sleep(5)
for clnt in self.directory.getContainers():
self.dumpDirectory(clnt)
def main():
louie.connect( test_init_complete, 'Coherence.UPnP.Backend.init_completed', louie.Any)
f = BuzztardStore(None)
f.parent = f.append('Buzztard', 'directory', None)
print f.parent
print f.store
f.add_content('playlist|test label|start|stop')
print f.store
f.clear()
print f.store
f.add_content('playlist|after flush label|flush-start|flush-stop')
print f.store
def __init__(self, service, dbus_device, bus):
self.service = service
self.dbus_device = dbus_device
self.type = self.service.service_type.split(':')[3] # get the service name
bus_name = dbus.service.BusName(CDS_SERVICE, bus)
device_id = dbus_device.id
self.path = OBJECT_PATH + '/devices/' + device_id + '/services/' + 'CDS'
dbus.service.Object.__init__(self, bus, bus_name=bus_name,
object_path=self.path)
self.debug("DBusService %r %r", service, self.type)
louie.connect(self.variable_changed, 'StateVariable.changed', sender=self.service)
self.subscribeStateVariables()
def main():
louie.connect(test_init_complete, 'Coherence.UPnP.Backend.init_completed',
louie.Any)
f = BuzztardStore(None)
f.parent = f.append('Buzztard', 'directory', None)
print(f.parent)
print(f.store)
f.add_content('playlist|test label|start|stop')
print(f.store)
f.clear()
print(f.store)
f.add_content('playlist|after flush label|flush-start|flush-stop')
print(f.store)
def going_live(self):
self.info("add a view to the DevicesFragment",self._athenaID)
self.page.menu.add_tab('Devices',self.active,self._athenaID)
d = self.page.notifyOnDisconnect()
d.addCallback( self.remove_me)
d.addErrback( self.remove_me)
devices = []
for device in self.coherence.get_devices():
if device != None:
_,_,_,device_type,version = device.get_device_type().split(':')
name = unicode("%s:%s %s" % (device_type,version,device.get_friendly_name()))
usn = unicode(device.get_usn())
devices.append({u'name':name,u'usn':usn})
louie.connect( self.add_device, 'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect( self.remove_device, 'Coherence.UPnP.Device.removed', louie.Any)
return devices
def __init__(self, service, dbus_device, bus):
log.Loggable.__init__(self)
self.service = service
self.dbus_device = dbus_device
self.type = self.service.service_type.split(':')[3] # get the service name
bus_name = dbus.service.BusName(CDS_SERVICE, bus)
device_id = dbus_device.id
self.path = OBJECT_PATH + '/devices/' + device_id + '/services/' + 'CDS'
dbus.service.Object.__init__(self, bus, bus_name=bus_name,
object_path=self.path)
self.debug("DBusService %r %r", service, self.type)
louie.connect(self.variable_changed, 'StateVariable.changed', sender=self.service)
self.subscribeStateVariables()
def subscribe_for_variable(self,
var_name,
instance=0,
callback=None,
signal=False):
variable = self.get_state_variable(var_name)
if variable:
if callback != None:
if signal == True:
callback(variable)
louie.connect(
callback,
signal='Coherence.UPnP.StateVariable.%s.changed' %
var_name,
sender=self)
else:
variable.subscribe(callback)
def __init__(self, parent=None):
log.Loggable.__init__(self)
self.parent = parent
self.services = []
#self.uid = self.usn[:-len(self.st)-2]
self.friendly_name = ""
self.device_type = ""
self.friendly_device_type = "[unknown]"
self.device_type_version = 0
self.udn = None
self.detection_completed = False
self.client = None
self.icons = []
self.devices = []
louie.connect(self.receiver, 'Coherence.UPnP.Service.detection_completed', self)
louie.connect(self.service_detection_failed, 'Coherence.UPnP.Service.detection_failed', self)
def going_live(self):
self.info("add a view to the DevicesFragment %s", self._athenaID)
self.page.menu.add_tab('Devices', self.active, self._athenaID)
d = self.page.notifyOnDisconnect()
d.addCallback(self.remove_me)
d.addErrback(self.remove_me)
devices = []
for device in self.coherence.get_devices():
if device is not None:
devices.append({u'name': device.get_markup_name(),
u'usn': unicode(device.get_usn())})
louie.connect(self.add_device,
'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect(self.remove_device,
'Coherence.UPnP.Device.removed', louie.Any)
return devices
def __init__(self,controlpoint):
self.controlpoint = controlpoint
self.bus = dbus.SessionBus()
self.bus_name = dbus.service.BusName(BUS_NAME, self.bus)
dbus.service.Object.__init__(self, self.bus_name, OBJECT_PATH)
self.debug("D-Bus pontoon %r %r %r" % (self, self.bus, self.bus_name))
self.devices = []
for device in self.controlpoint.get_devices():
self.devices.append(DBusDevice(device,self.bus_name))
louie.connect(self.cp_ms_detected, 'Coherence.UPnP.ControlPoint.MediaServer.detected', louie.Any)
louie.connect(self.cp_ms_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed', louie.Any)
louie.connect(self.cp_mr_detected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected', louie.Any)
louie.connect(self.cp_mr_removed, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed', louie.Any)
louie.connect(self.remove_client, 'Coherence.UPnP.Device.remove_client', louie.Any)
def going_live(self):
self.info("add a view to the DevicesFragment", self._athenaID)
self.page.menu.add_tab('Devices', self.active, self._athenaID)
d = self.page.notifyOnDisconnect()
d.addCallback(self.remove_me)
d.addErrback(self.remove_me)
devices = []
for device in self.coherence.get_devices():
if device is not None:
devices.append({u'name': device.get_markup_name(),
u'usn':unicode(device.get_usn())})
louie.connect(self.add_device,
'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect(self.remove_device,
'Coherence.UPnP.Device.removed', louie.Any)
return devices
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_ip_connection = None
self.wan_ppp_connection = None
self.detection_completed = False
louie.connect(self.service_notified, signal = 'Coherence.UPnP.DeviceClient.Service.notified', sender = self.device)
for service in self.device.get_services():
if service.get_type() in ["urn:schemas-upnp-org:service:WANIPConnection:1"]:
self.wan_ip_connection = WANIPConnectionClient(service)
if service.get_type() in ["urn:schemas-upnp-org:service:WANPPPConnection:1"]:
self.wan_ppp_connection = WANPPPConnectionClient(service)
self.info("WANConnectionDevice %s" % (self.device.get_friendly_name()))
if self.wan_ip_connection:
self.info("WANIPConnection service available")
if self.wan_ppp_connection:
self.info("WANPPPConnection service available")
def __init__(self, device):
self.device = device
self.device_type,self.version = device.get_device_type().split(':')[3:5]
self.detection_completed = False
self.standalone_group = True
self.group_members = list()
# self.icons = device.icons
louie.connect(self.service_notified, signal='Coherence.UPnP.DeviceClient.Service.notified', sender=self.device)
self.alarm_clock = None
self.music_services = None
self.audio_in = None
self.device_properties = None
self.system_properties = None
self.zone_group_topology = None
self.group_management = None
for service in self.device.get_services():
if service.get_type() in ["urn:schemas-upnp-org:service:AlarmClock:1",
]:
self.alarm_clock = BaseClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:MusicServices:1",
]:
self.music_services = BaseClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:AudioIn:1",
]:
self.audio_in = BaseClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:DeviceProperties:1",
]:
self.device_properties = BaseClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:SystemProperties:1",
]:
self.system_properties = BaseClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:ZoneGroupTopology:1",
]:
self.zone_group_topology = ZoneGroupTopologyClient( service)
elif service.get_type() in ["urn:schemas-upnp-org:service:GroupManagement:1",
]:
self.group_management = GroupManagementClient( service)
self.info("%s", self.device.get_friendly_name())
def __init__(self, device):
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_device = None
self.detection_completed = False
louie.connect(self.embedded_device_notified, signal='Coherence.UPnP.EmbeddedDeviceClient.detection_completed', sender=self.device)
try:
wan_device = self.device.get_embedded_device_by_type('WANDevice')[0]
self.wan_device = WANDeviceClient(wan_device)
except:
self.warning("Embedded WANDevice device not available, device not implemented properly according to the UPnP specification")
raise
self.info("InternetGatewayDevice %s" % (self.device.get_friendly_name()))
def __init__(self, controlpoint, bus=None):
self.bus = bus or dbus.SessionBus()
try:
bus_name = dbus.service.BusName(BUS_NAME, self.bus)
except:
bus_name = None
self.tube = self.bus
else:
self.tube = None
self.bus_name = bus_name
dbus.service.Object.__init__(self,
self.bus,
bus_name=self.bus_name,
object_path=OBJECT_PATH)
self.debug("D-Bus pontoon %r %r %r" % (self, self.bus, self.bus_name))
self.devices = {}
self.controlpoint = controlpoint
self.pinboard = {}
# i am a stub service if i have no control point
if self.controlpoint is None:
return
for device in self.controlpoint.get_devices():
self.devices[device.get_id()] = DBusDevice(device, self.bus_name)
#louie.connect(self.cp_ms_detected, 'Coherence.UPnP.ControlPoint.MediaServer.detected', louie.Any)
#louie.connect(self.cp_ms_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed', louie.Any)
#louie.connect(self.cp_mr_detected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected', louie.Any)
#louie.connect(self.cp_mr_removed, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed', louie.Any)
#louie.connect(self.remove_client, 'Coherence.UPnP.Device.remove_client', louie.Any)
louie.connect(self._device_detected,
'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect(self._device_removed, 'Coherence.UPnP.Device.removed',
louie.Any)
self.debug("D-Bus pontoon started")
def __init__(self, coherence, backend, **kwargs):
self.coherence = coherence
self.device_type = 'BinaryLight'
self.version = 1
#log.Loggable.__init__(self)
try:
self.uuid = kwargs['uuid']
except KeyError:
from coherence.upnp.core.uuid import UUID
self.uuid = UUID()
self.backend = None
self.icons = kwargs.get('iconlist', kwargs.get('icons', []))
if len(self.icons) == 0:
if kwargs.has_key('icon'):
self.icons.append(kwargs['icon'])
louie.connect( self.init_complete, 'Coherence.UPnP.Backend.init_completed', louie.Any)
reactor.callLater(0.2, self.fire, backend, **kwargs)
def __init__(self, device):
log.Loggable.__init__(self)
self.device = device
self.device_type = self.device.get_friendly_device_type()
self.version = int(self.device.get_device_type_version())
self.icons = device.icons
self.wan_connection_device = None
self.wan_common_interface_connection = None
self.embedded_device_detection_completed = False
self.service_detection_completed = False
louie.connect(
self.embedded_device_notified,
signal='Coherence.UPnP.EmbeddedDeviceClient.detection_completed',
sender=self.device)
try:
wan_connection_device = self.device.get_embedded_device_by_type(
'WANConnectionDevice')[0]
self.wan_connection_device = WANConnectionDeviceClient(
wan_connection_device)
except:
self.warning(
"Embedded WANConnectionDevice device not available, device not implemented properly according to the UPnP specification"
)
raise
louie.connect(self.service_notified,
signal='Coherence.UPnP.DeviceClient.Service.notified',
sender=self.device)
for service in self.device.get_services():
if service.get_type() in [
"urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1"
]:
self.wan_common_interface_connection = WANCommonInterfaceConfigClient(
service)
self.info("WANDevice %s", self.device.get_friendly_name())
def __init__(self,
coherence,
auto_client=[
'MediaServer', 'MediaRenderer', 'BinaryLight',
'DimmableLight'
]):
self.coherence = coherence
self.info("Coherence UPnP ControlPoint starting...")
self.event_server = EventServer(self)
self.coherence.add_web_resource('RPC2', XMLRPC(self))
self.auto_client = auto_client
self.queries = []
for device in self.get_devices():
self.check_device(device)
louie.connect(self.check_device,
'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect(self.remove_client,
'Coherence.UPnP.Device.remove_client', louie.Any)
louie.connect(self.completed,
'Coherence.UPnP.DeviceClient.detection_completed',
louie.Any)
def __init__(self, server, **kwargs):
self.next_id = 1000
self.config = kwargs
self.name = kwargs.get('name','Buzztard')
self.urlbase = kwargs.get('urlbase','')
if( len(self.urlbase)>0 and
self.urlbase[len(self.urlbase)-1] != '/'):
self.urlbase += '/'
self.host = kwargs.get('host','127.0.0.1')
self.port = int(kwargs.get('port',7654))
self.server = server
self.update_id = 0
self.store = {}
self.parent = None
louie.connect( self.add_content, 'Buzztard.Response.browse', louie.Any)
louie.connect( self.clear, 'Buzztard.Response.flush', louie.Any)
self.buzztard = BzConnection(backend=self,host=self.host,port=self.port)
def __init__(self): self.ssdp = SSDPServer() self.msearch = MSearch(self.ssdp, test=False) self.devices = [] louie.connect(self.ssdp_detected, 'Coherence.UPnP.SSDP.new_device', louie.Any) louie.connect(self.ssdp_deleted, 'Coherence.UPnP.SSDP.removed_device', louie.Any) louie.connect(self.device_found, 'Coherence.UPnP.RootDevice.detection_completed', louie.Any) self.msearch.double_discover()
def __init__(self,controlpoint, bus=None):
self.bus = bus or dbus.SessionBus()
try:
bus_name = dbus.service.BusName(BUS_NAME, self.bus)
except:
bus_name = None
self.tube = self.bus
else:
self.tube = None
self.bus_name = bus_name
dbus.service.Object.__init__(self, self.bus, bus_name=self.bus_name,
object_path=OBJECT_PATH)
self.debug("D-Bus pontoon %r %r %r" % (self, self.bus, self.bus_name))
self.devices = {}
self.controlpoint = controlpoint
self.pinboard = {}
# i am a stub service if i have no control point
if self.controlpoint is None:
return
for device in self.controlpoint.get_devices():
self.devices[device.get_id()] = DBusDevice(device,self.bus_name)
#louie.connect(self.cp_ms_detected, 'Coherence.UPnP.ControlPoint.MediaServer.detected', louie.Any)
#louie.connect(self.cp_ms_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed', louie.Any)
#louie.connect(self.cp_mr_detected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected', louie.Any)
#louie.connect(self.cp_mr_removed, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed', louie.Any)
#louie.connect(self.remove_client, 'Coherence.UPnP.Device.remove_client', louie.Any)
louie.connect(self._device_detected, 'Coherence.UPnP.Device.detection_completed', louie.Any)
louie.connect(self._device_removed, 'Coherence.UPnP.Device.removed', louie.Any)
self.debug("D-Bus pontoon started")
def __init__(self):
self.ssdp = SSDPServer() # listen for things destined to port 1900
self.ssdpalt = SSDPServerAlt()
self.msearch = MSearch(self.ssdpalt, test=False) # use correct source port
self.devices = []
self.orphans = {}
self.listeners = {'added':[], 'deleted':[]}
louie.connect(self.ssdp_detected, 'Coherence.UPnP.SSDP.new_device', louie.Any)
louie.connect(self.ssdp_deleted, 'Coherence.UPnP.SSDP.removed_device', louie.Any)
louie.connect(self.device_found, 'Coherence.UPnP.RootDevice.detection_completed', louie.Any)
self.msearch.double_discover()
def __init__(self, device, **kwargs):
self.name = kwargs.get('name', 'Buzztard MediaRenderer')
self.host = kwargs.get('host', '127.0.0.1')
self.port = int(kwargs.get('port', 7654))
self.player = None
self.playing = False
self.state = None
self.duration = None
self.view = []
self.tags = {}
self.server = device
self.poll_LC = LoopingCall(self.poll_player)
louie.connect(self.event, 'Buzztard.Response.event', louie.Any)
louie.connect(self.get_volume, 'Buzztard.Response.volume', louie.Any)
louie.connect(self.get_mute, 'Buzztard.Response.mute', louie.Any)
louie.connect(self.get_repeat, 'Buzztard.Response.repeat', louie.Any)
self.buzztard = BzConnection(backend=self,
host=self.host,
port=self.port)
def __init__(self):
self.ssdp = SSDPServer() # listen for things destined to port 1900
self.ssdpalt = SSDPServerAlt()
self.msearch = MSearch(self.ssdpalt,
test=False) # use correct source port
self.devices = []
self.orphans = {}
self.listeners = {'added': [], 'deleted': []}
louie.connect(self.ssdp_detected, 'Coherence.UPnP.SSDP.new_device',
louie.Any)
louie.connect(self.ssdp_deleted, 'Coherence.UPnP.SSDP.removed_device',
louie.Any)
louie.connect(self.device_found,
'Coherence.UPnP.RootDevice.detection_completed',
louie.Any)
self.msearch.double_discover()
def setup_part2(self):
self.info('running on host: %s', self.hostname)
if self.hostname.startswith('127.'):
self.warning('detection of own ip failed, using %s as own address, functionality will be limited', self.hostname)
unittest = self.config.get('unittest', 'no')
unittest = False if unittest == 'no' else True
""" SSDP Server Initialization
"""
try:
# TODO: add ip/interface bind
self.ssdp_server = SSDPServer(test=unittest)
except CannotListenError as err:
self.error("Error starting the SSDP-server: %s", err)
self.debug("Error starting the SSDP-server", exc_info=True)
reactor.stop()
return
louie.connect(self.create_device, 'Coherence.UPnP.SSDP.new_device', louie.Any)
louie.connect(self.remove_device, 'Coherence.UPnP.SSDP.removed_device', louie.Any)
louie.connect(self.add_device, 'Coherence.UPnP.RootDevice.detection_completed', louie.Any)
# louie.connect( self.receiver, 'Coherence.UPnP.Service.detection_completed', louie.Any)
self.ssdp_server.subscribe("new_device", self.add_device)
self.ssdp_server.subscribe("removed_device", self.remove_device)
self.msearch = MSearch(self.ssdp_server, test=unittest)
reactor.addSystemEventTrigger('before', 'shutdown', self.shutdown, force=True)
""" Web Server Initialization
"""
try:
# TODO: add ip/interface bind
self.web_server = WebServer(self.config.get('web-ui', None), self.web_server_port, self)
except CannotListenError:
self.warning('port %r already in use, aborting!', self.web_server_port)
reactor.stop()
return
self.urlbase = 'http://%s:%d/' % (self.hostname, self.web_server_port)
# self.renew_service_subscription_loop = task.LoopingCall(self.check_devices)
# self.renew_service_subscription_loop.start(20.0, now=False)
try:
plugins = self.config['plugin']
if isinstance(plugins, dict):
plugins = [plugins]
except:
plugins = None
if plugins is None:
plugins = self.config.get('plugins', None)
if plugins is None:
self.info("No plugin defined!")
else:
if isinstance(plugins, dict):
for plugin, arguments in list(plugins.items()):
try:
if not isinstance(arguments, dict):
arguments = {}
self.add_plugin(plugin, **arguments)
except Exception as msg:
self.warning("Can't enable plugin, %s: %s!", plugin, msg)
self.info(traceback.format_exc())
else:
for plugin in plugins:
try:
if plugin['active'] == 'no':
continue
except (KeyError, TypeError):
pass
try:
backend = plugin['backend']
arguments = copy.copy(plugin)
del arguments['backend']
backend = self.add_plugin(backend, **arguments)
if self.writeable_config():
if 'uuid' not in plugin:
plugin['uuid'] = str(backend.uuid)[5:]
self.config.save()
except Exception as msg:
self.warning("Can't enable plugin, %s: %s!", plugin, msg)
self.info(traceback.format_exc())
self.external_address = ':'.join((self.hostname, str(self.web_server_port)))
""" Control Point Initialization
"""
if self.config.get('controlpoint', 'no') == 'yes' or self.config.get('json', 'no') == 'yes':
self.ctrl = ControlPoint(self)
""" Json Interface Initialization
"""
if self.config.get('json', 'no') == 'yes':
from coherence.json_service import JsonInterface
self.json = JsonInterface(self.ctrl)
""" Transcoder Initialization
"""
if self.config.get('transcoding', 'no') == 'yes':
from coherence.transcoder import TranscoderManager
self.transcoder_manager = TranscoderManager(self)
""" DBus Initialization
"""
if self.config.get('use_dbus', 'no') == 'yes':
try:
from coherence import dbus_service
if self.ctrl is None:
self.ctrl = ControlPoint(self)
self.ctrl.auto_client_append('InternetGatewayDevice')
self.dbus = dbus_service.DBusPontoon(self.ctrl)
except Exception as msg:
self.warning("Unable to activate dbus sub-system: %r", msg)
self.debug(traceback.format_exc())
class CoherencePlugin(rb.Plugin, log.Loggable):
logCategory = 'rb_coherence_plugin'
def __init__(self):
rb.Plugin.__init__(self)
self.coherence = None
self.config = gconf.client_get_default()
if self.config.get(gconf_keys['dmc_active']) is None:
# key not yet found represented by "None"
self._set_defaults()
def _set_defaults(self):
for a in ('r', 's'):
self.config.set_bool(gconf_keys['dm%s_active' % a], True)
self.config.set_int(gconf_keys['dm%s_version' % a], 2)
self.config.set_string(gconf_keys['dmr_name'],
"Rhythmbox UPnP MediaRenderer on {host}")
self.config.set_string(gconf_keys['dms_name'],
"Rhythmbox UPnP MediaServer on {host}")
self.config.set_bool(gconf_keys['dmc_active'], True)
def activate(self, shell):
from twisted.internet import gtk2reactor
try:
gtk2reactor.install()
except AssertionError, e:
# sometimes it's already installed
self.warning("gtk2reactor already installed %r" % e)
self.coherence = self.get_coherence()
if self.coherence is None:
self.warning("Coherence is not installed or too old, aborting")
return
self.warning("Coherence UPnP plugin activated")
self.shell = shell
self.sources = {}
# Set up our icon
the_icon = None
face_path = os.path.join(os.path.expanduser('~'), ".face")
if os.path.exists(face_path):
file = gio.File(path=face_path)
url = file.get_uri()
info = file.query_info("standard::fast-content-type")
mimetype = info.get_attribute_as_string(
"standard::fast-content-type")
pixbuf = gtk.gdk.pixbuf_new_from_file(face_path)
width = "%s" % pixbuf.get_width()
height = "%s" % pixbuf.get_height()
depth = '24'
the_icon = {
'url': url,
'mimetype': mimetype,
'width': width,
'height': height,
'depth': depth
}
if self.config.get_bool(gconf_keys['dms_active']):
# create our own media server
from coherence.upnp.devices.media_server import MediaServer
from MediaStore import MediaStore
kwargs = {
'version': self.config.get_int(gconf_keys['dms_version']),
'no_thread_needed': True,
'db': self.shell.props.db,
'plugin': self
}
if the_icon:
kwargs['icon'] = the_icon
dms_uuid = self.config.get_string(gconf_keys['dms_uuid'])
if dms_uuid:
kwargs['uuid'] = dms_uuid
name = self.config.get_string(gconf_keys['dms_name'])
if name:
name = name.replace('{host}', self.coherence.hostname)
kwargs['name'] = name
self.server = MediaServer(self.coherence, MediaStore, **kwargs)
if dms_uuid is None:
self.config.set_string(gconf_keys['dms_uuid'],
str(self.server.uuid))
self.warning("Media Store available with UUID %s" %
str(self.server.uuid))
if self.config.get_bool(gconf_keys['dmr_active']):
# create our own media renderer
# but only if we have a matching Coherence package installed
if self.coherence_version < (0, 5, 2):
print "activation failed. Coherence is older than version 0.5.2"
else:
from coherence.upnp.devices.media_renderer import MediaRenderer
from MediaPlayer import RhythmboxPlayer
kwargs = {
"version": self.config.get_int(gconf_keys['dmr_version']),
"no_thread_needed": True,
"shell": self.shell,
'dmr_uuid': gconf_keys['dmr_uuid']
}
if the_icon:
kwargs['icon'] = the_icon
dmr_uuid = self.config.get_string(gconf_keys['dmr_uuid'])
if dmr_uuid:
kwargs['uuid'] = dmr_uuid
name = self.config.get_string(gconf_keys['dmr_name'])
if name:
name = name.replace('{host}', self.coherence.hostname)
kwargs['name'] = name
self.renderer = MediaRenderer(self.coherence, RhythmboxPlayer,
**kwargs)
if dmr_uuid is None:
self.config.set_string(gconf_keys['dmr_uuid'],
str(self.renderer.uuid))
self.warning("Media Renderer available with UUID %s" %
str(self.renderer.uuid))
if self.config.get_bool(gconf_keys['dmc_active']):
self.warning("start looking for media servers")
# watch for media servers
louie.connect(self.detected_media_server,
'Coherence.UPnP.ControlPoint.MediaServer.detected',
louie.Any)
louie.connect(self.removed_media_server,
'Coherence.UPnP.ControlPoint.MediaServer.removed',
louie.Any)
def __init__(self,config):
self.config = config
fullscreen = False
try:
if means_true(self.config['fullscreen']):
fullscreen = True
except:
pass
grafics = self.config.get('grafics')
if grafics == 'pyglet':
from cadre.scribbling.pyglet_backend import Canvas
else:
from cadre.scribbling.clutter_backend import Canvas
self.canvas = Canvas(fullscreen)
try:
overlays = self.config['overlay']
if not isinstance(overlays,list):
overlays = [overlays]
except:
overlays = []
map(self.canvas.add_overlay,overlays)
coherence_config = {}
#coherence_config['version'] = '1'
coherence_config['logmode'] = 'warning'
#coherence_config['controlpoint'] = 'yes'
louie.connect(self.media_server_found, 'Coherence.UPnP.ControlPoint.MediaServer.detected', louie.Any)
louie.connect(self.media_server_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed', louie.Any)
self.coherence = Coherence(coherence_config)
name = self.config.get('name','Cadre - Coherence Picture-Frame')
kwargs = {'version':1,
'no_thread_needed':True,
'name':name}
kwargs['transition'] = 'NONE'
try:
if self.config['transition'].upper() in self.get_available_transitions():
kwargs['transition'] = self.config['transition'].upper()
self.set_transition(self.config['transition'].upper())
except:
pass
try:
kwargs['display_time'] = int(self.config['display_time'])
except:
pass
self.canvas.set_title(name)
kwargs['controller'] = self
uuid = self.config.get('uuid')
if uuid:
kwargs['uuid'] = uuid
print kwargs
self.renderer = MediaRenderer(self.coherence,CadreRenderer,**kwargs)
if 'uuid' not in self.config:
self.config['uuid'] = str(self.renderer.uuid)[5:]
try:
self.config.save()
except AttributeError:
pass
reactor.callLater(0.5,self.start,name)
