def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
# ip = get_ip_address('')
ip, port = self.controlpoint._event_listener.host()
if self.proxytype == 'WMP':
listen_url = "http://" + ip + ':10243'
model_name = 'Windows Media Player Sharing'
else:
listen_url = ''
model_name = 'Rhapsody'
self.root_device = Device(
self.upnp_urn,
self.proxyname,
udn=self.udn,
manufacturer='Henkelis',
manufacturer_url=project_page,
model_description='Media Server',
model_name=model_name,
model_number='3.0',
model_url=project_page,
udp_listener=self.controlpoint._ssdp_server.udp_listener,
force_listen_url=listen_url)
self.root_device.webserver.get_render = self.get_render
class BinaryLight(object):
def __init__(self):
self.server_name = 'Binary Light Device'
self.device = None
def _create_device(self):
project_page = 'https://garage.maemo.org/projects/brisa'
self.device = Device('urn:schemas-upnp-org:device:BinaryLight:1',
self.server_name,
manufacturer='Brisa Team. Embedded Laboratory '\
'and INdT Brazil',
manufacturer_url=project_page,
model_name='Binary Light Device',
model_description='A UPnP Binary Light Device',
model_number='1.0',
model_url="http://www.bleoccupancy.com/",
serial_number="00")
def _add_services(self):
switch = SwitchPower()
self.device.add_service(switch)
def start(self):
self._create_device()
self._add_services()
self.device.start()
reactor.add_after_stop_func(self.device.stop)
reactor.main()
class BinaryLight(object):
def __init__(self):
""" Constructor for the LightDevice class, which fills some basic
information about the device.
"""
self.server_name = 'Binary Light Device'
self.device = None
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
project_page = 'https://garage.maemo.org/projects/brisa'
self.device = Device('urn:schemas-upnp-org:device:BinaryLight:1',
self.server_name,
manufacturer='Brisa Team. Embedded Laboratory '\
'and INdT Brazil',
manufacturer_url=project_page,
model_name='Binary Light Device',
model_description='A UPnP Binary Light Device',
model_number='1.0',
model_url=project_page)
def _add_services(self):
switch = SwitchPower()
self.device.add_service(switch)
def start(self):
self._create_device()
self._add_services()
self.device.start()
reactor.add_after_stop_func(self.device.stop)
reactor.main()
class myChEMBL(object):
def __init__(self):
""" Constructor for the myChEMBL device class, which fills some basic
information about the device.
"""
self.server_name = 'myChEMBL'
self.device = 'myChEMBL'
def _get_ip(self):
for iface in netifaces.interfaces():
keys = netifaces.ifaddresses(iface).keys()
if keys.__len__() > 1:
addrdict = netifaces.ifaddresses(iface)[keys[1]][0]
if 'addr' in addrdict.keys() and 'broadcast' in addrdict.keys(
):
return addrdict['addr']
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
self.device = Device(
'urn:schemas-upnp-org:device:myChEMBL:1',
self.server_name,
manufacturer='ChEMBL team',
manufacturer_url='https://www.ebi.ac.uk/chembl/',
model_name='myChEMBL',
model_description=
'A virtual machine implementation of open data and cheminformatics tools',
model_number='v18',
model_url='https://github.com/chembl/mychembl',
presentation_url='http://' + self._get_ip(),
)
def _add_icon(self):
icon = BaseDeviceIcon('image/png', '140', '140', '8', '/chembl.png')
self.device.icons.append(icon)
def start(self):
self._create_device()
self._add_icon()
self.device.start()
reactor.add_after_stop_func(self.device.stop)
reactor.main()
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
# ip = get_ip_address('')
ip, port = self.controlpoint._event_listener.host()
if self.proxytype == 'WMP':
listen_url = "http://" + ip + ':10243'
model_name='Windows Media Player Sharing'
else:
listen_url = ''
model_name='Rhapsody'
self.root_device = Device(self.upnp_urn,
self.proxyname,
udn=self.udn,
manufacturer='Henkelis',
manufacturer_url=project_page,
model_description='Media Server',
model_name=model_name,
model_number='3.0',
model_url=project_page,
udp_listener=self.controlpoint._ssdp_server.udp_listener,
force_listen_url=listen_url)
self.root_device.webserver.get_render = self.get_render
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.root_device = Device(self.upnp_urn,
self.server_name,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP generic '\
'Device',
model_name='Generic Device Example',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
self.device = Device(
'urn:schemas-upnp-org:device:myChEMBL:1',
self.server_name,
manufacturer='ChEMBL team',
manufacturer_url='https://www.ebi.ac.uk/chembl/',
model_name='myChEMBL',
model_description=
'A virtual machine implementation of open data and cheminformatics tools',
model_number='v18',
model_url='https://github.com/chembl/mychembl',
presentation_url='http://' + self._get_ip(),
)
class myChEMBL(object):
def __init__(self):
""" Constructor for the myChEMBL device class, which fills some basic
information about the device.
"""
self.server_name = 'myChEMBL'
self.device = 'myChEMBL'
def _get_ip(self):
for iface in netifaces.interfaces():
keys = netifaces.ifaddresses(iface).keys()
if keys.__len__() > 1:
addrdict = netifaces.ifaddresses(iface)[keys[1]][0]
if 'addr' in addrdict.keys() and 'broadcast' in addrdict.keys():
return addrdict['addr']
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
self.device = Device('urn:schemas-upnp-org:device:myChEMBL:1',
self.server_name,
manufacturer='ChEMBL team',
manufacturer_url='https://www.ebi.ac.uk/chembl/',
model_name='myChEMBL',
model_description='A virtual machine implementation of open data and cheminformatics tools',
model_number='v19',
model_url='https://github.com/chembl/mychembl',
presentation_url='http://'+self._get_ip(),)
def _add_icon(self):
icon = BaseDeviceIcon('image/png','140','140','8','/chembl.png')
self.device.icons.append(icon)
def start(self):
self._create_device()
self._add_icon()
self.device.start()
reactor.add_after_stop_func(self.device.stop)
reactor.main()
def _create_device(self):
""" Creates the root device and saves the information about the
device.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.device = Device('urn:schemas-upnp-org:device:MediaRenderer:1',
self.server_name,
force_listen_url=self.listen_url,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP Media '\
'Renderer',
model_name='BRisa Media Renderer',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
class MyDevice(object):
def __init__(self):
""" Constructor for class MyDevice, which fill some basic information
about the device.
"""
self.server_name = 'My Generic Device'
self.root_device = None
self.upnp_urn = 'urn:schemas-upnp-org:device:MyDevice:1'
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.root_device = Device(self.upnp_urn,
self.server_name,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP generic '\
'Device',
model_name='Generic Device Example',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
def _add_services(self):
# Creating the example Service
myservice = MyService()
# Inserting a service into the root device
self.root_device.add_service(myservice)
def _load(self):
self._add_root_device()
self._add_services()
def start(self):
self._load()
self.root_device.start()
reactor.add_after_stop_func(self.root_device.stop)
reactor.main()
def CreateDevice(self):
projectPage = 'http://www.github.com/AlanDThiessen/atha'
self.device = Device( 'urn:schemas-upnp-org:device:BinaryLight:1',
self.room + ': ' + self.name,
manufacturer='Alan Thiessen',
manufacturer_url=projectPage,
model_name='Atha X10 Light Device',
model_description='A UPnP Light Device Representing an X10 Light',
model_number='1.0',
model_url=projectPage )
class MyDevice(object):
def __init__(self):
""" Constructor for class MyDevice, which fill some basic information
about the device.
"""
self.server_name = 'My Generic Device'
self.root_device = None
self.upnp_urn = 'urn:schemas-upnp-org:device:MyDevice:1'
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.root_device = Device(self.upnp_urn,
self.server_name,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP generic '\
'Device',
model_name='Generic Device Example',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
def _add_services(self):
# Creating the example Service
myservice = MyService()
# Inserting a service into the root device
self.root_device.add_service(myservice)
def _load(self):
self._add_root_device()
self._add_services()
def start(self):
self._load()
self.root_device.start()
reactor.add_after_stop_func(self.root_device.stop)
reactor.main()
def _create_device(self):
project_page = 'https://garage.maemo.org/projects/brisa'
self.device = Device('urn:schemas-upnp-org:device:BinaryLight:1',
self.server_name,
manufacturer='Brisa Team. Embedded Laboratory '\
'and INdT Brazil',
manufacturer_url=project_page,
model_name='Binary Light Device',
model_description='A UPnP Binary Light Device',
model_number='1.0',
model_url="http://www.bleoccupancy.com/",
serial_number="00")
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
project_page = 'https://garage.maemo.org/projects/brisa'
self.device = Device('urn:schemas-upnp-org:device:BinaryLight:1',
self.server_name,
manufacturer='Brisa Team. Embedded Laboratory '\
'and INdT Brazil',
manufacturer_url=project_page,
model_name='Binary Light Device',
model_description='A UPnP Binary Light Device',
model_number='1.0',
model_url=project_page)
def _create_device(self):
""" Creates the root device object which will represent the device
description.'
"""
self.device = Device('urn:schemas-upnp-org:device:myChEMBL:1',
self.server_name,
manufacturer='ChEMBL team',
manufacturer_url='https://www.ebi.ac.uk/chembl/',
model_name='myChEMBL',
model_description='A virtual machine implementation of open data and cheminformatics tools',
model_number='v19',
model_url='https://github.com/chembl/mychembl',
presentation_url='http://'+self._get_ip(),)
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.root_device = Device(self.upnp_urn,
self.server_name,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP generic '\
'Device',
model_name='Generic Device Example',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
class X10Light(object):
def __init__(self, name, x10Device, dimmable, room ):
self.name = name
self.x10Device = x10Device
self.dimmable = dimmable;
self.room = room
self.device = None
logger.debug( 'New X10Light: Name: %s, Device: %s', self.name, self.x10Device )
def CreateDevice(self):
projectPage = 'http://www.github.com/AlanDThiessen/atha'
self.device = Device( 'urn:schemas-upnp-org:device:BinaryLight:1',
self.room + ': ' + self.name,
manufacturer='Alan Thiessen',
manufacturer_url=projectPage,
model_name='Atha X10 Light Device',
model_description='A UPnP Light Device Representing an X10 Light',
model_number='1.0',
model_url=projectPage )
def AddServices(self, controller):
switch = SwitchPower( controller, self.actuator, self.x10Device )
self.device.add_service(switch)
if( self.dimmable ):
dimmer = Dimming( controller, self.actuator, self.x10Device )
self.device.add_service( dimmer )
def start(self, controller):
logger.debug( 'Starting Light: %s', self.name )
self.actuator = controller.actuator( self.x10Device )
self.CreateDevice()
self.AddServices( controller )
self.device.start()
reactor.add_after_stop_func(self.device.stop)
class MediaRendererDevice(object):
""" Media Renderer reference 1.0 implementation. Use should be basic
start/stop and accessing the DBus interface.
The dbus interface contains the following methods:
halt() - Halts the media renderer
get_renderer_info() - Returns a 6-tuple containing information about the
device. The format is (device version, brisa
framework version, application version, renderer
name, logging level, logging output)
This media renderer contains a .service dbus file. This means that
bringing up the media renderer through its dbus interface can be simply
achieved by using the object path and interface constants defined above
to retrieve the dbus object.
"""
def __init__(self, server_name, listen_url=''):
""" Constructor for the media renderer device.
@param server_name: friendly name for the device
@param listen_url: a specific URL to be used for publishing resources
and listening for requests. If not specified, the
url will be http://IP:random_port
@type server_name: string
@type listen_url: string
"""
self.server_name = server_name
self.listen_url = listen_url
def _create_device(self):
""" Creates the root device and saves the information about the
device.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.device = Device('urn:schemas-upnp-org:device:MediaRenderer:1',
self.server_name,
force_listen_url=self.listen_url,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP Media '\
'Renderer',
model_name='BRisa Media Renderer',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
def _add_services(self):
""" Creates the Service's objects and attachs them to the root device.
Also attaches the dbus interface to the services.
"""
local_xml_path = os.path.join(os.path.dirname(__file__),
'xml_descriptions')
avt = AVTransport(local_xml_path)
rc = RenderingControl(local_xml_path, avt.get_player())
cm = ConnectionManagerRenderer()
self.device.add_service(cm)
self.device.add_service(avt)
self.device.add_service(rc)
self.dmr_dbus = DMRObject(avt, rc, cm)
def start(self):
""" Starts the device.
"""
self._create_device()
self._add_services()
self.device.start()
reactor.add_after_stop_func(self.device.stop)
reactor.main()
class ControlProxy(object):
def __init__(self, proxyname, proxytype, proxytrans, udn, controlpoint,
mediaserver, config):
self.root_device = None
self.upnp_urn = 'urn:schemas-upnp-org:device:MediaServer:1'
self.proxyname = proxyname
self.proxytype = proxytype
self.proxytrans = proxytrans
self.udn = udn
self.controlpoint = controlpoint
self.mediaserver = mediaserver
self.destmusicaddress = None
self.config = config
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
# ip = get_ip_address('')
ip, port = self.controlpoint._event_listener.host()
if self.proxytype == 'WMP':
listen_url = "http://" + ip + ':10243'
model_name = 'Windows Media Player Sharing'
else:
listen_url = ''
model_name = 'Rhapsody'
self.root_device = Device(
self.upnp_urn,
self.proxyname,
udn=self.udn,
manufacturer='Henkelis',
manufacturer_url=project_page,
model_description='Media Server',
model_name=model_name,
model_number='3.0',
model_url=project_page,
udp_listener=self.controlpoint._ssdp_server.udp_listener,
force_listen_url=listen_url)
self.root_device.webserver.get_render = self.get_render
def _add_services(self):
cdservice = ContentDirectory(self.controlpoint, self.mediaserver,
self.root_device.location, self)
self.root_device.add_service(cdservice)
cmservice = ConnectionManager(self.controlpoint, self.mediaserver)
self.root_device.add_service(cmservice)
mrservice = X_MS_MediaReceiverRegistrar()
self.root_device.add_service(mrservice)
def _add_resources(self):
pass
def _load(self):
self._add_root_device()
self._add_services()
self._add_resources()
def start(self):
self.stop()
self._load()
self.root_device.start()
def stop(self):
if self.root_device:
self.root_device.stop()
self.root_device = None
def get_render(self, uri, params):
return self
def render(self, env, start_response):
# if self.destmusicaddress is not None:
# address = self.destmusicaddress
# else:
# address = self.destaddress
# respbody = HTTPRedirect().call(address, env, start_response)
if env['PATH_INFO'] == '/on.mp3':
print ">>>>>>>>>>>>>>>>>>>>>>"
print ">>>>>>>>> ON >>>>>>>>>"
print ">>>>>>>>>>>>>>>>>>>>>>"
elif env['PATH_INFO'] == '/off.mp3':
print ">>>>>>>>>>>>>>>>>>>>>>"
print ">>>>>>>>> OFF >>>>>>>>"
print ">>>>>>>>>>>>>>>>>>>>>>"
return []
def __init__(self): Device.__init__(self, 'urn:schemas-icucinema-co-uk:device:LXDesk:1', 'LXDesk')
def __init__(self):
Device.__init__(self,
'urn:schemas-upnp-org:device:BinaryLight:1',
'Binary Light device')
class ControlProxy(object):
def __init__(self, proxyname, proxytype, proxytrans, udn, controlpoint, mediaserver, config):
self.root_device = None
self.upnp_urn = 'urn:schemas-upnp-org:device:MediaServer:1'
self.proxyname = proxyname
self.proxytype = proxytype
self.proxytrans = proxytrans
self.udn = udn
self.controlpoint = controlpoint
self.mediaserver = mediaserver
self.destmusicaddress = None
self.config = config
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
# ip = get_ip_address('')
ip, port = self.controlpoint._event_listener.host()
if self.proxytype == 'WMP':
listen_url = "http://" + ip + ':10243'
model_name='Windows Media Player Sharing'
else:
listen_url = ''
model_name='Rhapsody'
self.root_device = Device(self.upnp_urn,
self.proxyname,
udn=self.udn,
manufacturer='Henkelis',
manufacturer_url=project_page,
model_description='Media Server',
model_name=model_name,
model_number='3.0',
model_url=project_page,
udp_listener=self.controlpoint._ssdp_server.udp_listener,
force_listen_url=listen_url)
self.root_device.webserver.get_render = self.get_render
def _add_services(self):
cdservice = ContentDirectory(self.controlpoint, self.mediaserver, self.root_device.location, self)
self.root_device.add_service(cdservice)
cmservice = ConnectionManager(self.controlpoint, self.mediaserver)
self.root_device.add_service(cmservice)
mrservice = X_MS_MediaReceiverRegistrar()
self.root_device.add_service(mrservice)
def _add_resources(self):
pass
def _load(self):
self._add_root_device()
self._add_services()
self._add_resources()
def start(self):
self.stop()
self._load()
self.root_device.start()
def stop(self):
if self.root_device:
self.root_device.stop()
self.root_device = None
def get_render(self, uri, params):
return self
def render(self, env, start_response):
# if self.destmusicaddress is not None:
# address = self.destmusicaddress
# else:
# address = self.destaddress
# respbody = HTTPRedirect().call(address, env, start_response)
if env['PATH_INFO'] == '/on.mp3':
print ">>>>>>>>>>>>>>>>>>>>>>"
print ">>>>>>>>> ON >>>>>>>>>"
print ">>>>>>>>>>>>>>>>>>>>>>"
elif env['PATH_INFO'] == '/off.mp3':
print ">>>>>>>>>>>>>>>>>>>>>>"
print ">>>>>>>>> OFF >>>>>>>>"
print ">>>>>>>>>>>>>>>>>>>>>>"
return []
class MyDevice(object):
def __init__(self):
""" Constructor for class MyDevice, which fill some basic information
about the device.
"""
self.server_name = 'My Generic Device - Event Example'
self.root_device = None
self.upnp_urn = 'urn:schemas-upnp-org:device:MyDevice:1'
self.running = False
self.commands = {'exit': self._exit,
'help': self._help}
def _add_root_device(self):
""" Creates the root device object which will represent the device
description.
"""
project_page = 'http://brisa.garage.maemo.org'
serial_no = config.manager.brisa_version.replace('.', '').rjust(7, '0')
self.root_device = Device(self.upnp_urn,
self.server_name,
manufacturer='BRisa Team. Embedded '\
'Laboratory and INdT Brazil',
manufacturer_url=project_page,
model_description='An Open Source UPnP generic '\
'Device',
model_name='Generic Device Example',
model_number=config.manager.brisa_version,
model_url=project_page,
serial_number=serial_no)
def _add_services(self):
# Creating the example Service
self.myservice = MyService()
# Inserting a service into the root device
self.root_device.add_service(self.myservice)
def _load(self):
self._add_root_device()
self._add_services()
def run(self):
self.running = True
self._load()
self.root_device.start()
run_async_function(reactor.main)
try:
while self.running:
command = str(raw_input('>>> '))
if command.find('set_var') == 0:
new_value = command.split(' ')[1]
self.myservice.set_state_variable('A_ARG_TYPE_Textin', new_value)
else:
try:
self.commands[command]()
except KeyError:
print 'invalid command, try help'
command = ''
except KeyboardInterrupt, k:
pass
except EOFError, k:
pass
def __init__(self):
Device.__init__(self, "urn:schemas-upnp-org:device:BinaryLight:1", "Binary Light device")
def __init__(self): Device.__init__(self, 'urn:schemas-icucinema-co-uk:device:CP500:1', 'CP500')
