def start(self):
print "Upnp backend starting"
# clear device list
self._removeXML()
# config Coherence
conf = Config(self._configfile)
c = Coherence({'logmode':'warning'})
c.setup(conf)
#add share folders
con = ""
for f in config.share_folders:
if len(con) > 0:
con +=","
con += f
c.add_plugin('FSStore',name=config.device_name,content=con)
# start a ControlPoint to start detecting upnp activity
cp = ControlPoint(c, auto_client=['MediaServer'])
cp.connect(self.mediaserver_detected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
cp.connect(self.mediaserver_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
#self._localdevice = cp.get_device_by_name(self._localdevicename)
#print "SPRURPDDSOPF ",self._localdevice.client.get_friendly_name()
print "Upnp loop succesfully started"
self._handler.start()
print "DBus loop succesfully started"
def start(self):
print "Upnp backend starting"
# clear device list
self._removeXML()
# config Coherence
conf = Config(self._configfile)
c = Coherence({'logmode': 'warning'})
c.setup(conf)
#add share folders
con = ""
for f in config.share_folders:
if len(con) > 0:
con += ","
con += f
c.add_plugin('FSStore', name=config.device_name, content=con)
# start a ControlPoint to start detecting upnp activity
cp = ControlPoint(c, auto_client=['MediaServer'])
cp.connect(self.mediaserver_detected,
'Coherence.UPnP.ControlPoint.MediaServer.detected')
cp.connect(self.mediaserver_removed,
'Coherence.UPnP.ControlPoint.MediaServer.removed')
#self._localdevice = cp.get_device_by_name(self._localdevicename)
#print "SPRURPDDSOPF ",self._localdevice.client.get_friendly_name()
print "Upnp loop succesfully started"
self._handler.start()
print "DBus loop succesfully started"
def start():
control_point = ControlPoint(Coherence({'logmode': 'warning'}),
auto_client=['MediaServer'])
control_point.connect(media_server_found,
'Coherence.UPnP.ControlPoint.MediaServer.detected')
control_point.connect(media_server_removed,
'Coherence.UPnP.ControlPoint.MediaServer.removed')
class UPNP_Browser():
def __init__(self):
self.browse_count = 0
self.music = Music_DB()
self.__client = None
self.control_point = ControlPoint(Coherence({'logmode':'warning'}),
auto_client=['MediaServer'])
self.control_point.connect(self.media_server_found,
'Coherence.UPnP.ControlPoint.MediaServer.detected')
self.control_point.connect(self.media_server_removed,
'Coherence.UPnP.ControlPoint.MediaServer.removed')
# now we should also try to discover the ones that are already there:
for device in self.control_point.coherence.devices:
print device
# called for each media server found
def media_server_found(self, client, udn):
print "media_server_found", client
print "media_server_found", client.device.get_friendly_name()
self.__client = client
self.load_children(0)
# sadly they sometimes get removed as well :(
def media_server_removed(self, udn):
print "media_server_removed", udn
# browse callback
def process_media_server_browse(self, result, client):
print "browsing root of", client.device.get_friendly_name()
print "result contains %d out of %d total matches" % \
(int(result['NumberReturned']), int(result['TotalMatches']))
elt = DIDLLite.DIDLElement.fromString(result['Result'])
for item in elt.getItems():
if item.upnp_class.startswith("object.container"):
self.load_children(item.id)
if item.upnp_class.startswith("object.item"):
url = None
duration = None
size = None
for res in item.res:
remote_protocol,remote_network,remote_content_format,remote_flags = res.protocolInfo.split(':')
if remote_protocol == 'http-get':
url = res.data
duration = res.duration
size = res.size
break
self.music.add_song(item, url, duration)
def load_children(self, id):
self.browse_count += 1
d = self.__client.content_directory.browse(id, browse_flag='BrowseDirectChildren', process_result=False, backward_compatibility=False)
d.addCallback(self.process_media_server_browse, self.__client)
def start():
control_point = ControlPoint(Coherence({'logmode': 'warning'}),
auto_client=['MediaServer'])
control_point.connect(media_server_found, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
control_point.connect(media_server_removed, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
# now we should also try to discover the ones that are already there:
for device in control_point.coherence.devices:
print device
class Puncher(object):
def __init__(self,command,config):
#print "command %r %r %r" %(command,config,config.subOptions)
self.config = config
self.locked = False
if command == None:
self.command = 'show-devices'
else:
self.command = command
if self.command == 'show-devices':
self.locked = None
if self.command == 'add-mapping':
if self.config.subOptions['internal-host'] == None:
raise Exception("internal-host parameter missing")
if self.config.subOptions['internal-port'] == None:
raise Exception("internal-port parameter missing")
if self.config.subOptions['protocol'].lower() not in ['tcp','udp']:
raise Exception("protocol value invalid")
if self.config.subOptions['active'].lower() in ['y','true','1','yes']:
self.config.subOptions['active'] = True
else:
self.config.subOptions['active'] = False
if self.config.subOptions['remote-host'].lower() in ['""','any']:
self.config.subOptions['remote-host'] = ''
if self.config.subOptions['external-port'] == None:
self.config.subOptions['external-port'] = self.config.subOptions['internal-port']
if self.command == 'delete-mapping':
if self.config.subOptions['remote-host'] == None:
raise Exception("remote-host parameter missing")
if self.config.subOptions['external-port'] == None:
raise Exception("external-port parameter missing")
if self.config.subOptions['protocol'].lower() not in ['tcp','udp']:
raise Exception("protocol value invalid")
coherence_config = {}
coherence_config['logmode'] = 'none'
self.control_point = ControlPoint(Coherence(coherence_config),auto_client=['InternetGatewayDevice'])
self.control_point.connect(self.igd_found, 'Coherence.UPnP.ControlPoint.InternetGatewayDevice.detected')
self.control_point.connect(self.igd_removed, 'Coherence.UPnP.ControlPoint.InternetGatewayDevice.removed')
self.timeout = reactor.callLater(int(self.config['timeout']),self.stop)
self.devices = {}
self.reports = {'show-devices': self.show_devices,
'show-mappings': self.show_mappings,
'info': self.show_info}
def show_devices(self):
for uuid in self.devices.keys():
print "%s with uuid:%s" % (self.devices[uuid]['friendly_name'], uuid)
def show_info(self):
for uuid in self.devices.keys():
print "%s with uuid:%s" % (self.devices[uuid]['friendly_name'], uuid)
if len(self.devices) > 0:
print "External IP address: ", self.external_ip_address
print "Number of port-mappings: ", self.port_mapping_number_of_entries
def show_mappings(self):
for uuid in self.devices.keys():
print "%s with uuid:%s" % (self.devices[uuid]['friendly_name'], uuid)
mappings = self.devices[uuid].get('mappings',None)
if mappings == None or len(mappings) == 0:
print "no port-mappings found"
else:
print "Ext. Port | Remote Host | Int. Port | Internal Host | Prot. | active | duration | description"
print "=" * 100
for mapping in mappings:
if mapping['NewLeaseDuration'] == '0':
mapping['NewLeaseDuration'] = 'infinite'
else:
mapping['NewLeaseDuration'] += 'sec'
if mapping['NewRemoteHost'] == '':
mapping['NewRemoteHost'] = 'any'
if mapping['NewEnabled'] == '1':
mapping['NewEnabled'] = 'yes'
else:
mapping['NewEnabled'] = 'no'
print " %05s | %-14s | %05s | %-14s | %5s | %6s | %8s | %s" % (mapping['NewExternalPort'],
mapping['NewRemoteHost'],
mapping['NewInternalPort'],
mapping['NewInternalClient'],
mapping['NewProtocol'],
mapping['NewEnabled'],
mapping['NewLeaseDuration'],
mapping['NewPortMappingDescription'])
print "=" * 100
def stop(self,quiet=False):
try:
self.timeout.cancel()
except:
pass
if quiet == False:
if len(self.devices) == 0:
print "no InternetGatewayDevice found"
elif len(self.devices) == 1:
print "1 InternetGatewayDevice found:"
else:
print "%d InternetGatewayDevices found:" % len(self.devices)
self.reports.get(self.command,self.show_devices)()
print ""
reactor.stop()
def append_mappings(self,mappings,device):
device['mappings'] = mappings
self.stop()
def add_mapping_ok(self,result,device):
print "port-mapping to %s added" %device['friendly_name']
self.stop(quiet=True)
def add_mapping_failed(self,result,device):
print "failed to add port-mapping to %s" %device['friendly_name']
self.stop(quiet=True)
def delete_mapping_ok(self,result,device):
print "port-mapping deleted from %s" %device['friendly_name']
self.stop(quiet=True)
def delete_mapping_failed(self,result,device):
print "failed to delete port-mapping from %s" %device['friendly_name']
self.stop(quiet=True)
def igd_found(self,client,udn):
#print "IGD found", client.device.get_friendly_name()
if self.locked == True:
return
elif self.locked == False:
self.locked = True
if(self.config['uuid'] != None and
client.device.get_uuid().endswith(self.config['uuid']) == False):
return
self.devices[client.device.get_uuid()] = {'friendly_name': client.device.get_friendly_name()}
if self.locked == True:
wan_ip_connection_service = client.wan_device.wan_connection_device.wan_ip_connection or \
client.wan_device.wan_connection_device.wan_ppp_connection
if self.command == 'show-mappings':
dfr = wan_ip_connection_service.get_all_port_mapping_entries()
dfr.addCallback(self.append_mappings,self.devices[client.device.get_uuid()])
elif self.command == 'add-mapping':
dfr = wan_ip_connection_service.add_port_mapping(remote_host=self.config.subOptions['remote-host'],
external_port=int(self.config.subOptions['external-port']),
protocol=self.config.subOptions['protocol'].upper(),
internal_port=int(self.config.subOptions['internal-port']),
internal_client=self.config.subOptions['internal-host'],
enabled=self.config.subOptions['active'],
port_mapping_description=self.config.subOptions['description'],
lease_duration=int(self.config.subOptions['lease-duration']))
dfr.addCallback(self.add_mapping_ok,self.devices[client.device.get_uuid()])
dfr.addErrback(self.add_mapping_failed,self.devices[client.device.get_uuid()])
elif self.command == 'delete-mapping':
dfr = wan_ip_connection_service.delete_port_mapping(remote_host=self.config.subOptions['remote-host'],
external_port=int(self.config.subOptions['external-port']),
protocol=self.config.subOptions['protocol'].upper())
dfr.addCallback(self.delete_mapping_ok,self.devices[client.device.get_uuid()])
dfr.addErrback(self.delete_mapping_failed,self.devices[client.device.get_uuid()])
elif self.command == 'info':
self.port_mapping_number_of_entries = None
self.external_ip_address = None
wan_ip_connection_service.subscribe_for_variable('PortMappingNumberOfEntries', callback=self.state_variable_change)
wan_ip_connection_service.subscribe_for_variable('ExternalIPAddress', callback=self.state_variable_change)
def igd_removed(self,udn):
#print "IGD removed", udn
pass
def state_variable_change(self,variable):
if variable.name == 'ExternalIPAddress':
self.external_ip_address = variable.value
elif variable.name == 'PortMappingNumberOfEntries':
if variable.value != '':
self.port_mapping_number_of_entries = int(variable.value)
else:
self.port_mapping_number_of_entries = 0
if(self.port_mapping_number_of_entries != None and
self.external_ip_address != None):
self.stop()
class ManagedControlPoint(object):
DEVICE_TYPE_SATIP_SERVER = "SatIPServer"
DEVICE_TYPE_DREAMBOX = "Dreambox"
URI_BASE_DREAMBOX = "urn:dreambox-de:device"
def __init__(self):
self.coherence = None
self._controlPoint = None
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self.onMediaServerDetected = []
self.onMediaServerRemoved = []
self.onMediaRendererDetected = []
self.onMediaRendererRemoved = []
self.onMediaDeviceDectected = []
self.onMediaDeviceRemoved = []
self.onSatIpServerDetected = []
self.onSatIpServerRemoved = []
self.onDreamboxDetected = []
self.onDreamboxRemoved = []
self._session = None
self.__deferredShutDown = None
self._startPending = False
def _onShutdownFinished(self, *args, **kwargs):
self.__deferredShutDown = None
if self._startPending:
self.start()
def start(self):
def doStart(*args, **kwargs):
if self._controlPoint:
Log.w("already running!")
return
Log.i("starting now!")
self._startPending = False
self.coherence = Coherence({
'logging': {
'level' : 'warning',
'subsystem' : [
{'name' : 'msearch', 'level' : 'warning'},
{'name' : 'ssdp', 'level' : 'warning'}
]}
})
self._controlPoint = ControlPoint(self.coherence, auto_client=['MediaServer','MediaRenderer'])
self.coherence.ctrl = self._controlPoint
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self._controlPoint.connect(self._onMediaServerDetected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
self._controlPoint.connect(self._onMediaServerRemoved, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
self._controlPoint.connect(self._onMediaRendererDetected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
self._controlPoint.connect(self._onMediaRendererRemoved, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
self._controlPoint.connect(self._onMediaDeviceDectected, 'Coherence.UPnP.Device.detection_completed')
self._controlPoint.connect(self._onMediaDeviceRemoved, 'Coherence.UPnP.RootDevice.removed')
self.__deferredShutDown = None
if self._session:
self._callPlugins(reason=0)
if self.__deferredShutDown:
Log.w("deferring start until shutdown is finished")
if not self._startPending:
self._startPending = True
else:
doStart()
def restart(self):
Log.i()
if not self.__deferredShutDown:
self.shutdown()
self.start()
def setSession(self, session):
self._session = session
if self.coherence:
self._callPlugins(reason=0)
def _callPlugins(self, reason=0):
for plugin in plugins.getPlugins(PluginDescriptor.WHERE_UPNP):
plugin(reason, session=self._session)
def _onMediaServerDetected(self, client, udn):
print "[DLNA] MediaServer Detected: %s (%s)" % (client.device.get_friendly_name(), client.device.get_friendly_device_type())
self.__mediaServerClients[udn] = client
for fnc in self.onMediaServerDetected:
fnc(udn, client)
def _onMediaServerRemoved(self, udn):
if self.__mediaServerClients.get(udn, None) != None:
del self.__mediaServerClients[udn]
for fnc in self.onMediaServerRemoved:
fnc(udn)
def _onMediaRendererDetected(self, client, udn):
print "[DLNA] MediaRenderer detected: %s (%s, %s)" % (client.device.get_friendly_name(), client.device.get_friendly_device_type(), udn)
self.__mediaRendererClients[udn] = client
for fnc in self.onMediaRendererDetected:
fnc(udn, client)
def _onMediaRendererRemoved(self, udn):
print "[DLNA] MediaRenderer removed: %s" % (udn)
if self.__mediaRendererClients.get(udn, None) != None:
del self.__mediaRendererClients[udn]
for fnc in self.onMediaRendererRemoved:
fnc(udn)
def _onMediaDeviceDectected(self, device):
if device.udn in self.__mediaDevices:
return
self.__mediaDevices[device.udn] = device
device_type = device.get_friendly_device_type()
if device_type == self.DEVICE_TYPE_SATIP_SERVER:
Log.i("New SAT>IP Server found: %s (%s - %s)" %(device.get_friendly_name(), device.get_friendly_device_type(), device.get_satipcap()))
for fnc in self.onSatIpServerDetected:
fnc(device)
elif device_type == self.DEVICE_TYPE_DREAMBOX:
Log.i("New Dreambox found: %s (%s - %s)" %(device.get_friendly_name(), device.get_friendly_device_type(), device.get_presentation_url()))
for fnc in self.onDreamboxDetected:
fnc(device)
else:
Log.i("New Device found: %s (%s)" % (device.get_friendly_name(), device.get_friendly_device_type()))
def _onMediaDeviceRemoved(self, usn):
if usn in self.__mediaDevices:
print "[DLNA] Device removed: %s" % (usn)
device = self.__mediaDevices[usn]
device_type = device.get_friendly_device_type()
if device_type == self.DEVICE_TYPE_SATIP_SERVER:
for fnc in self.onSatIpServerRemoved:
fnc(device)
elif device_type == self.DEVICE_TYPE_DREAMBOX:
for fnc in self.onDreamboxRemoved:
fnc(device)
for fnc in self.onMediaDeviceRemoved:
fnc(device)
del self.__mediaDevices[usn]
def registerRenderer(self, classDef, **kwargs):
renderer = MediaRenderer(self.coherence, classDef, no_thread_needed=True, **kwargs)
self.__devices.append(renderer)
return renderer
def registerServer(self, classDef, **kwargs):
server = MediaServer(self.coherence, classDef, no_thread_needed=True, **kwargs)
self.__devices.append(server)
return server
def registerDevice(self, instance, **kwargs):
self.__devices.append(instance)
return instance
def getServerList(self):
return self.__mediaServerClients.values()
def getRenderingControlClientList(self):
return self.__mediaRendererClients.values()
def getDeviceName(self, client):
return Item.ue(client.device.get_friendly_name())
def getSatIPDevices(self):
devices = []
for device in self.__mediaDevices.itervalues():
if device.get_friendly_device_type() == self.DEVICE_TYPE_SATIP_SERVER:
devices.append(device)
return devices
def getDreamboxes(self):
devices = []
for device in self.__mediaDevices.itervalues():
if device.get_friendly_device_type() == self.DEVICE_TYPE_DREAMBOX:
devices.append(device)
return devices
def getDevice(self, uuid):
for device in self.__devices:
if device.uuid == uuid:
return device
return None
def removeDevice(self, uuid):
device = self.getDevice(uuid)
if device:
device.unregister()
self.__devices.remove(device)
return True
return False
def shutdown(self):
Log.i("%s" %(self.coherence,))
if True:
Log.w("shutdown is broken... will continue running. please restart enigma2 instead!")
return
if self.coherence:
self._callPlugins(reason=1)
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self.__deferredShutDown = self.coherence.shutdown(force=True)
self.__deferredShutDown.addCallback(self._onShutdownFinished)
self._controlPoint.disconnect(self._onMediaServerDetected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
self._controlPoint.disconnect(self._onMediaServerRemoved, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
self._controlPoint.disconnect(self._onMediaRendererDetected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
self._controlPoint.disconnect(self._onMediaRendererRemoved, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
self._controlPoint.disconnect(self._onMediaDeviceDectected, 'Coherence.UPnP.Device.detection_completed')
self._controlPoint.disconnect(self._onMediaDeviceRemoved, 'Coherence.UPnP.RootDevice.removed')
self.coherence = None
self._controlPoint = None
class ManagedControlPoint(object):
def __init__(self):
self.coherence = Coherence({'logmode':'warning'})
self._controlPoint = ControlPoint(self.coherence, auto_client=['MediaServer','MediaRenderer'])
self._controlPoint.connect(self._onMediaServerDetected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
self._controlPoint.connect(self._onMediaServerRemoved, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
self._controlPoint.connect(self._onMediaRendererDetected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
self._controlPoint.connect(self._onMediaRendererRemoved, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
self._controlPoint.connect(self._onMediaDeviceDectected, 'Coherence.UPnP.Device.detection_completed')
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__browser = []
self.__devices = []
self.onMediaServerDetected = []
self.onMediaServerRemoved = []
self.onMediaRendererDetected = []
self.onMediaRendererRemoved = []
self.onMediaDeviceDectected = []
def _onMediaServerDetected(self, client, udn):
print "[DLNA] MediaServer Detected: %s (%s)" % (client.device.get_friendly_name(), client.device.get_friendly_device_type())
self.__mediaServerClients[udn] = client
for fnc in self.onMediaServerDetected:
fnc(udn, client)
def _onMediaServerRemoved(self, udn):
if self.__mediaServerClients.get(udn, None) != None:
del self.__mediaServerClients[udn]
for fnc in self.onMediaServerRemoved:
fnc(udn)
def _onMediaRendererDetected(self, client, udn):
print "[DLNA] MediaRenderer detected: %s (%s, %s)" % (client.device.get_friendly_name(), client.device.get_friendly_device_type(), udn)
self.__mediaRendererClients[udn] = client
for fnc in self.onMediaRendererDetected:
fnc(udn, client)
def _onMediaRendererRemoved(self, udn):
print "[DLNA] MediaRenderer removed: %s" % (udn)
if self.__mediaRendererClients.get(udn, None) != None:
del self.__mediaRendererClients[udn]
for fnc in self.onMediaRendererRemoved:
fnc(udn)
def _onMediaDeviceDectected(self, device):
print "[DLNA] Device found: %s (%s)" % (device.get_friendly_name(), device.get_friendly_device_type())
self.__mediaDevices[device.udn] = device
def registerRenderer(self, classDef, **kwargs):
renderer = MediaRenderer(self.coherence, classDef, no_thread_needed=True, **kwargs)
self.__devices.append(renderer)
return renderer
def registerServer(self, classDef, **kwargs):
server = MediaServer(self.coherence, classDef, no_thread_needed=True, **kwargs)
self.__devices.append(server)
return server
def getServerList(self):
return self.__mediaServerClients.values()
def getRenderingControlClientList(self):
return self.__mediaRendererClients.values()
def getDeviceName(self, client):
return Item.ue(client.device.get_friendly_name())
def shutdown(self):
for device in self.__devices:
device.unregister()
self._controlPoint.shutdown()
class UpnpRapp(object):
def __init__(self):
# configuration setup
self.gconf = gconf.client_get_default()
self.conf = {
"autoconnect": self.gconf.get_bool(gconf_keys["autoconnect"]),
"udn": self.gconf.get_string(gconf_keys["udn"]),
"mmkeys": self.gconf.get_bool(gconf_keys["mmkeys"]),
}
# coherence setup
self.coherence = Coherence({"logmode": "warning"})
self.ctp = ControlPoint(self.coherence, auto_client=["MediaRenderer"])
# internals setup
self.client = MediaRendererClient(self.coherence)
self.gui = StatusIconController(self)
self.gui.connect(self.client)
self.mmkeys = MMKeysController(name="MUPnPApp")
# hack to make it start
if True or self.conf["mmkeys"]:
self.mmkeys.connect(self.client)
# signal connection
self.ctp.connect(self._renderer_found, "Coherence.UPnP.ControlPoint.MediaRenderer.detected")
self.ctp.connect(self._renderer_removed, "Coherence.UPnP.ControlPoint.MediaRenderer.removed")
def _renderer_found(self, device=None, udn=None, client=None):
# FIXME: take care about the auto connect if not connected yet
# instead of just connecting
if not device:
device = self.coherence.get_device_with_id(udn)
self.gui.device_found(device, udn)
if not self.client.device and self.conf["autoconnect"]:
if device.udn == self.conf["udn"]:
self.connect(device)
def _renderer_removed(self, device=None, udn=None):
return
self.gui.renderer_removed(device, udn)
def set_autoconnect(self, value):
self.conf["autoconnect"] = value
self.gconf.set_bool(gconf_keys["autoconnect"], value)
def set_mmkeys(self, value):
self.conf["mmkeys"] = value
self.gconf.set_bool(gconf_keys["mmkeys"], value)
# reloading
if not value:
self.mmkeys.disconnect()
else:
self.mmkeys.connect(self.client)
def quit(self, value=0):
# FIXME: we should disconnect and stuff here
sys.exit(value)
def connect(self, device):
print "connecting to %s" % device.get_friendly_name()
self.gconf.set_string(gconf_keys["udn"], str(device.udn))
self.client.disconnect()
self.client.connect(device)
# HACK!
self.gui._connection_state_changed(True, device)
class ManagedControlPoint(object):
DEVICE_TYPE_SATIP_SERVER = "SatIPServer"
DEVICE_TYPE_DREAMBOX = "Dreambox"
URI_BASE_DREAMBOX = "urn:dreambox-de:device"
def __init__(self):
self.coherence = None
self._controlPoint = None
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self.onMediaServerDetected = []
self.onMediaServerRemoved = []
self.onMediaRendererDetected = []
self.onMediaRendererRemoved = []
self.onMediaDeviceDectected = []
self.onMediaDeviceRemoved = []
self.onSatIpServerDetected = []
self.onSatIpServerRemoved = []
self.onDreamboxDetected = []
self.onDreamboxRemoved = []
self._session = None
self.__deferredShutDown = None
self._startPending = False
def _onShutdownFinished(self, *args, **kwargs):
self.__deferredShutDown = None
if self._startPending:
self.start()
def start(self):
def doStart(*args, **kwargs):
if self._controlPoint:
Log.w("already running!")
return
Log.i("starting now!")
self._startPending = False
self.coherence = Coherence({
'logging': {
'level':
'warning',
'subsystem': [{
'name': 'msearch',
'level': 'warning'
}, {
'name': 'ssdp',
'level': 'warning'
}]
}
})
self._controlPoint = ControlPoint(
self.coherence, auto_client=['MediaServer', 'MediaRenderer'])
self.coherence.ctrl = self._controlPoint
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self._controlPoint.connect(
self._onMediaServerDetected,
'Coherence.UPnP.ControlPoint.MediaServer.detected')
self._controlPoint.connect(
self._onMediaServerRemoved,
'Coherence.UPnP.ControlPoint.MediaServer.removed')
self._controlPoint.connect(
self._onMediaRendererDetected,
'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
self._controlPoint.connect(
self._onMediaRendererRemoved,
'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
self._controlPoint.connect(
self._onMediaDeviceDectected,
'Coherence.UPnP.Device.detection_completed')
self._controlPoint.connect(self._onMediaDeviceRemoved,
'Coherence.UPnP.RootDevice.removed')
self.__deferredShutDown = None
if self._session:
self._callPlugins(reason=0)
if self.__deferredShutDown:
Log.w("deferring start until shutdown is finished")
if not self._startPending:
self._startPending = True
else:
doStart()
def restart(self):
Log.i()
if not self.__deferredShutDown:
self.shutdown()
self.start()
def setSession(self, session):
self._session = session
if self.coherence:
self._callPlugins(reason=0)
def _callPlugins(self, reason=0):
for plugin in plugins.getPlugins(PluginDescriptor.WHERE_UPNP):
plugin(reason, session=self._session)
def _onMediaServerDetected(self, client, udn):
print "[DLNA] MediaServer Detected: %s (%s)" % (
client.device.get_friendly_name(),
client.device.get_friendly_device_type())
self.__mediaServerClients[udn] = client
for fnc in self.onMediaServerDetected:
fnc(udn, client)
def _onMediaServerRemoved(self, udn):
if self.__mediaServerClients.get(udn, None) != None:
del self.__mediaServerClients[udn]
for fnc in self.onMediaServerRemoved:
fnc(udn)
def _onMediaRendererDetected(self, client, udn):
print "[DLNA] MediaRenderer detected: %s (%s, %s)" % (
client.device.get_friendly_name(),
client.device.get_friendly_device_type(), udn)
self.__mediaRendererClients[udn] = client
for fnc in self.onMediaRendererDetected:
fnc(udn, client)
def _onMediaRendererRemoved(self, udn):
print "[DLNA] MediaRenderer removed: %s" % (udn)
if self.__mediaRendererClients.get(udn, None) != None:
del self.__mediaRendererClients[udn]
for fnc in self.onMediaRendererRemoved:
fnc(udn)
def _onMediaDeviceDectected(self, device):
if device.udn in self.__mediaDevices:
return
self.__mediaDevices[device.udn] = device
device_type = device.get_friendly_device_type()
if device_type == self.DEVICE_TYPE_SATIP_SERVER:
Log.i("New SAT>IP Server found: %s (%s - %s)" %
(device.get_friendly_name(),
device.get_friendly_device_type(), device.get_satipcap()))
for fnc in self.onSatIpServerDetected:
fnc(device)
elif device_type == self.DEVICE_TYPE_DREAMBOX:
Log.i(
"New Dreambox found: %s (%s - %s)" %
(device.get_friendly_name(), device.get_friendly_device_type(),
device.get_presentation_url()))
for fnc in self.onDreamboxDetected:
fnc(device)
else:
Log.i("New Device found: %s (%s)" %
(device.get_friendly_name(),
device.get_friendly_device_type()))
def _onMediaDeviceRemoved(self, usn):
if usn in self.__mediaDevices:
print "[DLNA] Device removed: %s" % (usn)
device = self.__mediaDevices[usn]
device_type = device.get_friendly_device_type()
if device_type == self.DEVICE_TYPE_SATIP_SERVER:
for fnc in self.onSatIpServerRemoved:
fnc(device)
elif device_type == self.DEVICE_TYPE_DREAMBOX:
for fnc in self.onDreamboxRemoved:
fnc(device)
for fnc in self.onMediaDeviceRemoved:
fnc(device)
del self.__mediaDevices[usn]
def registerRenderer(self, classDef, **kwargs):
renderer = MediaRenderer(self.coherence,
classDef,
no_thread_needed=True,
**kwargs)
self.__devices.append(renderer)
return renderer
def registerServer(self, classDef, **kwargs):
server = MediaServer(self.coherence,
classDef,
no_thread_needed=True,
**kwargs)
self.__devices.append(server)
return server
def registerDevice(self, instance, **kwargs):
self.__devices.append(instance)
return instance
def getServerList(self):
return self.__mediaServerClients.values()
def getRenderingControlClientList(self):
return self.__mediaRendererClients.values()
def getDeviceName(self, client):
return Item.ue(client.device.get_friendly_name())
def getSatIPDevices(self):
devices = []
for device in self.__mediaDevices.itervalues():
if device.get_friendly_device_type(
) == self.DEVICE_TYPE_SATIP_SERVER:
devices.append(device)
return devices
def getDreamboxes(self):
devices = []
for device in self.__mediaDevices.itervalues():
if device.get_friendly_device_type() == self.DEVICE_TYPE_DREAMBOX:
devices.append(device)
return devices
def getDevice(self, uuid):
for device in self.__devices:
if device.uuid == uuid:
return device
return None
def removeDevice(self, uuid):
device = self.getDevice(uuid)
if device:
device.unregister()
self.__devices.remove(device)
return True
return False
def shutdown(self):
Log.i("%s" % (self.coherence, ))
if True:
Log.w(
"shutdown is broken... will continue running. please restart enigma2 instead!"
)
return
if self.coherence:
self._callPlugins(reason=1)
self.__mediaServerClients = {}
self.__mediaRendererClients = {}
self.__mediaDevices = {}
self.__devices = []
self.__deferredShutDown = self.coherence.shutdown(force=True)
self.__deferredShutDown.addCallback(self._onShutdownFinished)
self._controlPoint.disconnect(
self._onMediaServerDetected,
'Coherence.UPnP.ControlPoint.MediaServer.detected')
self._controlPoint.disconnect(
self._onMediaServerRemoved,
'Coherence.UPnP.ControlPoint.MediaServer.removed')
self._controlPoint.disconnect(
self._onMediaRendererDetected,
'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
self._controlPoint.disconnect(
self._onMediaRendererRemoved,
'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
self._controlPoint.disconnect(
self._onMediaDeviceDectected,
'Coherence.UPnP.Device.detection_completed')
self._controlPoint.disconnect(self._onMediaDeviceRemoved,
'Coherence.UPnP.RootDevice.removed')
self.coherence = None
self._controlPoint = None
