def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(embedded_device_client_detection_completed=self. embedded_device_notified) # noqa 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 try: wan_device = self.device.get_embedded_device_by_type( 'WANDevice')[0] self.wan_device = WANDeviceClient(wan_device) except Exception as e: self.warning(f'Embedded WANDevice device not available, device not' f' implemented properly according to the UPnP' f' specification [error: {e}]') raise self.info(f'InternetGatewayDevice {device.get_friendly_name()}')
def __init__(self, test=False, interface=''): '''Initialize the SSDP server.''' log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('datagram_received', 'new_device', 'removed_device', 'log') self.known = {} self._callbacks = {} self.test = test if not self.test: self.port = reactor.listenMulticast( SSDP_PORT, self, listenMultiple=True, interface=interface, ) self.port.joinGroup(SSDP_ADDR, interface=interface) self.resend_notify_loop = task.LoopingCall(self.resendNotify) self.resend_notify_loop.start(777.0, now=False) self.check_valid_loop = task.LoopingCall(self.check_valid) self.check_valid_loop.start(333.0, now=False) self.active_calls = []
def __init__(self, service, dbus_device, bus): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.service = service self.dbus_device = dbus_device # get the service name self.type = self.service.service_type.split(':')[3] 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(f'DBusService {service} {self.type}') if isinstance(self.service, EventDispatcher): self.service.bind(state_variable_changed=self.variable_changed) self.subscribeStateVariables()
def __init__(self, coherence, backend, **kwargs): EventDispatcher.__init__(self) self.coherence = coherence if not hasattr(self, 'version'): self.version = int( kwargs.get('version', self.coherence.config.get('version', 2))) try: self.uuid = str(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() urlbase = str(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 'icon' in kwargs: if isinstance(kwargs['icon'], dict): self.icons.append(kwargs['icon']) else: self.icons = kwargs['icon'] reactor.callLater(0.2, self.fire, backend, **kwargs)
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('embedded_device_client_detection_completed') self.device = device self.device.bind(service_notified=self.service_notified) 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 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(f'WANConnectionDevice {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, ssdp_server, test=False): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('datagram_received') self.ssdp_server = ssdp_server if not test: self.port = reactor.listenUDP(0, self) self.double_discover_loop = task.LoopingCall(self.double_discover) self.double_discover_loop.start(120.0)
def __init__(self, focus=None): """ """ #TODO: make it a singleton EventDispatcher.__init__(self) self._focus = focus self._blocking = 0 self._running = True self.__events = []
def __init__(self, service): resource.Resource.__init__(self) log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('event_client_message_received') self.service = service self.subscribers = service.get_subscribers() try: self.backend_name = self.service.backend.name except AttributeError: self.backend_name = self.service.backend
def __init__(self, *args, **kwargs): EventDispatcher.__init__(self) log.LogAble.__init__(self) self.register_event( 'response_flush', 'response_event', 'response_volume', 'response_mute', 'response_repeat', 'response_browse', )
def __init__(self, type, pattern, callback, timeout=0, oneshot=True): EventDispatcher.__init__(self) self.type = type self.pattern = pattern self.callback = callback self.timeout = timeout self.oneshot = oneshot if self.type == 'uuid' and self.pattern.startswith('uuid:'): self.pattern = self.pattern[5:] if isinstance(self.callback, str): # print(f'DeviceQuery: register event {self.callback}') self.register_event(self.callback)
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(device_service_notified=self.service_notified) 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.connection_manager = None self.av_transport = None 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.detection_completed: self.service_notified(service) self.info(f'MediaServer {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, control_point): log.LogAble.__init__(self) resource.Resource.__init__(self) EventDispatcher.__init__(self) self.register_event('event_server_message_received') self.coherence = control_point.coherence self.control_point = control_point self.coherence.add_web_resource('events', self) global hostname, web_server_port hostname = self.coherence.hostname web_server_port = self.coherence.web_server_port self.info('EventServer ready...')
def __init__( self, upnp_service, name, implementation, instance, send_events, data_type, allowed_values, ): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.service = upnp_service self.dispatch_events = [ f'state_variable_{name}_changed', 'state_variable_changed', ] self.dispatch_targets = [self] if isinstance(self.service, EventDispatcher): self.dispatch_targets.append(self.service) for target in self.dispatch_targets: for evt in self.dispatch_events: if evt not in target.event_dispatcher_event_callbacks: target.register_event(evt) self.name = name self.implementation = implementation self.instance = instance self.send_events = utils.means_true(send_events) self.never_evented = False self.data_type = data_type self.allowed_values = allowed_values if self.allowed_values is None: self.allowed_values = [] self.has_vendor_values = False self.allowed_value_range = None self.dependant_variable = None self.default_value = '' self.old_value = '' self.value = '' self.last_time_touched = None self._callbacks = [] if isinstance(self.service, service.ServiceServer): self.moderated = self.service.is_variable_moderated(name) self.updated = False
def __init__(self, parent=None, udn=None): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'device_detection_completed', 'device_remove_client', 'device_service_notified', 'device_got_client', ) self.parent = parent self.udn = udn # self.uid = self.usn[:-len(self.st)-2] self.friendly_name = '' self.device_type = '' self.upnp_version = 'n/a' self.friendly_device_type = '[unknown]' self.device_type_version = 0
def __init__(self, server, *args, **kwargs): ''' Args: server (object): This usually should be an instance of our main class :class:`~coherence.base.Coherence` (the UPnP device that's hosting our backend). *args (list): A list with extra arguments for the backend. This, must be implemented into the subclass (if needed). **kwargs (dict): An unpacked dictionary with the backend's configuration. ''' self.config = kwargs self.server = server EventDispatcher.__init__(self) log.LogAble.__init__(self) Plugin.__init__(self) self.register_event('backend_init_completed', 'backend_init_failed')
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'embedded_device_client_detection_completed', ) self.device = device self.device.bind( embedded_device_client_detection_completed=self.embedded_device_notified, # noqa service_notified=self.service_notified ) 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 try: wan_connection_device = \ self.device.get_embedded_device_by_type( 'WANConnectionDevice')[0] self.wan_connection_device = WANConnectionDeviceClient( wan_connection_device) except Exception as er: self.warning( f'Embedded WANConnectionDevice device not available, device ' f'not implemented properly according to the UPnP ' f'specification [ERROR: {er}]') raise 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(f'WANDevice {device.get_friendly_name()}')
def __init__(self, coherence, auto_client=None): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('control_point_client_detected', 'control_point_client_removed') if not auto_client: auto_client = ['MediaServer', 'MediaRenderer'] self.coherence = coherence self.auto_client = auto_client self.coherence.bind( coherence_device_detection_completed=self.check_device, coherence_device_removed=self.remove_client, ) self.info('Coherence UPnP ControlPoint starting...') self.event_server = EventServer(self) self.coherence.add_web_resource('RPC2', XMLRPC(self)) for device in self.get_devices(): self.info(f'ControlPoint [check device]: {device}') self.check_device(device)
def __init__(self, config=None): # initialize only once if self.__initialized: return self.__initialized = True # supers log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'coherence_device_detection_completed', 'coherence_device_removed', 'coherence_root_device_removed', ) self.config = config or {} self.available_plugins = None self.external_address = None self.urlbase = None self.web_server_port = int(config.get('serverport', 8080)) self.setup_logger() self.setup_hostname() if self.hostname.startswith('127.'): # use interface detection via routing table as last resort def catch_result(hostname): self.hostname = hostname self.setup_part2() d = defer.maybeDeferred(get_host_address) d.addCallback(catch_result) else: self.setup_part2()
def __init__(self, config=None): # initialize only once if self.__initialized: return self.__initialized = True # supers log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event( 'coherence_device_detection_completed', 'coherence_device_removed', 'coherence_root_device_removed', ) self.config = config or {} self.available_plugins = None self.external_address = None self.urlbase = None self.web_server_port = int(config.get('serverport', 8080)) # initializes log's system, a COHEN_DEBUG environment # variable overwrites all level settings here. try: logmode = config.get('logging').get('level', 'warning') except (KeyError, AttributeError): logmode = config.get('logmode', 'warning') try: subsystems = config.get('logging')['subsystem'] if isinstance(subsystems, dict): subsystems = [subsystems] for subsystem in subsystems: try: if subsystem['active'] == 'no': continue except (KeyError, TypeError): pass self.info(f'setting log-level for subsystem ' f'{subsystem["name"]} to {subsystem["level"]}') logging.getLogger(subsystem['name'].lower()).setLevel( subsystem['level'].upper()) except (KeyError, TypeError): subsystem_log = config.get('subsystem_log', {}) for subsystem, level in list(subsystem_log.items()): logging.getLogger(subsystem.lower()).setLevel(level.upper()) try: logfile = config.get('logging').get('logfile', None) if logfile is not None: logfile = str(logfile) except (KeyError, AttributeError, TypeError): logfile = config.get('logfile', None) log.init(logfile, logmode.upper()) self.warning(f'Coherence UPnP framework version {__version__} ' f'starting [log level: {logmode}]...') network_if = config.get('interface') if network_if: self.hostname = get_ip_address(f'{network_if}') else: try: self.hostname = socket.gethostbyname(socket.gethostname()) except socket.gaierror: self.warning('hostname can\'t be resolved, ' 'maybe a system misconfiguration?') self.hostname = '127.0.0.1' if self.hostname.startswith('127.'): # use interface detection via routing table as last resort def catch_result(hostname): self.hostname = hostname self.setup_part2() d = defer.maybeDeferred(get_host_address) d.addCallback(catch_result) else: self.setup_part2()
def __init__(self, device): log.LogAble.__init__(self) EventDispatcher.__init__(self) self.register_event('device_client_detection_completed', ) self.device = device self.device.bind(device_service_notified=self.service_notified) 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 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) if service.detection_completed: self.service_notified(service) self.info(f'MediaRenderer {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 __init__(self, *args, **kwargs): EventDispatcher.__init__(self) log.LogAble.__init__(self)
def __init__(self, *args, **kwargs): EventDispatcher.__init__(self) self.register_event('control_client_command_received')