Viewing file: mirabeau_tube_publisher.py (5.98 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
# Licensed under the MIT license # http://opensource.org/licenses/mit-license.php
# Copyright 2009 Philippe Normand <phil@base-art.net>
import gobject from dbus import PROPERTIES_IFACE
from telepathy.interfaces import CHANNEL_INTERFACE, CONNECTION_INTERFACE_REQUESTS, \ CHANNEL_TYPE_DBUS_TUBE from telepathy.constants import CONNECTION_HANDLE_TYPE_ROOM, \ SOCKET_ACCESS_CONTROL_CREDENTIALS
from telepathy.interfaces import CHANNEL_INTERFACE_TUBE, CHANNEL_TYPE_DBUS_TUBE, \ CHANNEL_INTERFACE from telepathy.constants import TUBE_CHANNEL_STATE_LOCAL_PENDING
from coherence.extern.telepathy import client, tube, mirabeau_tube_consumer from coherence.dbus_constants import BUS_NAME, OBJECT_PATH, DEVICE_IFACE, SERVICE_IFACE from coherence import dbus_service
from twisted.internet import task
class MirabeauTubePublisherMixin(tube.TubePublisherMixin): def __init__(self, tubes_to_offer, application, allowed_devices): tube.TubePublisherMixin.__init__(self, tubes_to_offer) self.coherence = application self.allowed_devices = allowed_devices self.coherence_tube = None self.device_tube = None self.service_tube = None self.announce_done = False
def _media_server_found(self, infos, udn): uuid = udn[5:] for device in self.coherence.dbus.devices.values(): if device.uuid == uuid: self._register_device(device) return
def _register_device(self, device): if self.allowed_devices is not None and device.uuid not in self.allowed_devices: self.info("device not allowed: %r", device.uuid) return device.add_to_connection(self.device_tube, device.path()) self.info("adding device %s to connection: %s", device.get_markup_name(), self.device_tube)
def iterate(): for service in device.services: if getattr(service,'NOT_FOR_THE_TUBES', False): continue yield service.add_to_connection(self.service_tube, service.path)
dfr = task.coiterate(iterate()) return dfr
def _media_server_removed(self, udn): for device in self.coherence.dbus.devices.values(): if udn == device.device.get_id(): if self.allowed_devices != None and device.uuid not in self.allowed_devices: # the device is not allowed, no reason to # disconnect from the tube to which it wasn't # connected in the first place anyway return device.remove_from_connection(self.device_tube, device.path()) self.info("remove_from_connection: %s" % device.get_friendly_name()) for service in device.services: if getattr(service,'NOT_FOR_THE_TUBES', False): continue service.remove_from_connection(self.service_tube, service.path) return
def post_tube_offer(self, tube, tube_conn): service = tube.props[CHANNEL_TYPE_DBUS_TUBE + ".ServiceName"] if service == BUS_NAME: self.coherence.dbus.add_to_connection(tube_conn, OBJECT_PATH) self.coherence_tube = tube_conn elif service == DEVICE_IFACE: self.device_tube = tube_conn elif service == SERVICE_IFACE: self.service_tube = tube_conn
if not self.announce_done and None not in (self.coherence_tube, self.device_tube, self.service_tube): self.announce_done = True
def iterate(devices): for device in devices: yield self._register_device(device)
def done(result): bus = self.coherence.dbus.bus bus.add_signal_receiver(self._media_server_found, "UPnP_ControlPoint_MediaServer_detected") bus.add_signal_receiver(self._media_server_removed, "UPnP_ControlPoint_MediaServer_removed")
dfr = task.coiterate(iterate(self.coherence.dbus.devices.values())) dfr.addCallback(lambda gen: done)
class MirabeauTubePublisherConsumer(MirabeauTubePublisherMixin, mirabeau_tube_consumer.MirabeauTubeConsumerMixin, client.Client): logCategory = "mirabeau_tube_publisher"
def __init__(self, manager, protocol, account, muc_id, tubes_to_offer, application, allowed_devices, found_peer_callback=None, disapeared_peer_callback=None, got_devices_callback=None): MirabeauTubePublisherMixin.__init__(self, tubes_to_offer, application, allowed_devices) mirabeau_tube_consumer.MirabeauTubeConsumerMixin.__init__(self, found_peer_callback=found_peer_callback, disapeared_peer_callback=disapeared_peer_callback, got_devices_callback=got_devices_callback) client.Client.__init__(self, manager, protocol, account, muc_id)
def got_tube(self, tube): client.Client.got_tube(self, tube) initiator_handle = tube.props[CHANNEL_INTERFACE + ".InitiatorHandle"] if initiator_handle == self.self_handle: self.finish_tube_offer(tube) else: self.accept_tube(tube)
def tube_opened(self, tube): tube_conn = super(MirabeauTubePublisherConsumer, self).tube_opened(tube) initiator_handle = tube.props[CHANNEL_INTERFACE + ".InitiatorHandle"] if initiator_handle == self.self_handle: self.post_tube_offer(tube, tube_conn) else: self.post_tube_accept(tube, tube_conn, initiator_handle) return tube_conn
|