def get_info(self):
info = {
"protocol": "xpra",
"connection_time": int(self.connection_time),
"elapsed_time": int(monotonic_time() - self.connection_time),
"counter": self.counter,
"hello-sent": self.hello_sent,
"bandwidth-limit": {
"setting": self.bandwidth_limit or 0,
"actual": self.soft_bandwidth_limit or 0,
}
}
p = self.protocol
if p:
info.update({
"connection": p.get_info(),
})
info.update(self.get_features_info())
merge_dicts(info, FilePrintMixin.get_info(self))
merge_dicts(info, AudioMixin.get_info(self))
merge_dicts(info, MMAP_Connection.get_info(self))
merge_dicts(info, NetworkStateMixin.get_info(self))
merge_dicts(info, ClientInfoMixin.get_info(self))
merge_dicts(info, WindowsMixin.get_info(self))
merge_dicts(info, EncodingsMixin.get_info(self))
merge_dicts(info, AVSyncMixin.get_info(self))
merge_dicts(info, ClientDisplayMixin.get_info(self))
merge_dicts(info, IdleMixin.get_info(self))
merge_dicts(info, ClipboardConnection.get_info(self))
return info
def send_hello(self, server_capabilities):
capabilities = server_capabilities.copy()
merge_dicts(capabilities, AudioMixin.get_caps(self))
merge_dicts(capabilities, MMAP_Connection.get_caps(self))
merge_dicts(capabilities, WindowsMixin.get_caps(self))
merge_dicts(capabilities, EncodingsMixin.get_caps(self))
merge_dicts(capabilities, InputMixin.get_caps(self))
merge_dicts(capabilities, AVSyncMixin.get_caps(self))
merge_dicts(capabilities, ClientDisplayMixin.get_caps(self))
self.send("hello", capabilities)
self.hello_sent = True
def __init__(self, protocol, disconnect_cb, session_name, idle_add,
timeout_add, source_remove, setting_changed, idle_timeout,
socket_dir, unix_socket_paths, log_disconnect, dbus_control,
get_transient_for, get_focus, get_cursor_data_cb,
get_window_id, window_filters, file_transfer, supports_mmap,
mmap_filename, min_mmap_size, bandwidth_limit, av_sync,
core_encodings, encodings, default_encoding, scaling_control,
webcam_enabled, webcam_device, webcam_encodings,
sound_properties, sound_source_plugin, supports_speaker,
supports_microphone, speaker_codecs, microphone_codecs,
default_quality, default_min_quality, default_speed,
default_min_speed):
log("ServerSource%s",
(protocol, disconnect_cb, session_name, idle_add, timeout_add,
source_remove, setting_changed, idle_timeout, socket_dir,
unix_socket_paths, log_disconnect, dbus_control,
get_transient_for, get_focus, get_window_id, window_filters,
file_transfer, supports_mmap, mmap_filename, min_mmap_size,
bandwidth_limit, av_sync, core_encodings, encodings,
default_encoding, scaling_control, webcam_enabled, webcam_device,
webcam_encodings, sound_properties, sound_source_plugin,
supports_speaker, supports_microphone, speaker_codecs,
microphone_codecs, default_quality, default_min_quality,
default_speed, default_min_speed))
global counter
self.counter = counter.increase()
self.protocol = protocol
self.connection_time = monotonic_time()
self.close_event = Event()
self.session_name = session_name
AudioMixin.__init__(self, sound_properties, sound_source_plugin,
supports_speaker, supports_microphone,
speaker_codecs, microphone_codecs)
MMAP_Connection.__init__(self, supports_mmap, mmap_filename,
min_mmap_size)
ClipboardConnection.__init__(self)
FilePrintMixin.__init__(self, file_transfer)
NetworkStateMixin.__init__(self)
ClientInfoMixin.__init__(self)
DBUS_Mixin.__init__(self, dbus_control)
WindowsMixin.__init__(self, get_transient_for, get_focus,
get_cursor_data_cb, get_window_id,
window_filters)
EncodingsMixin.__init__(self, core_encodings, encodings,
default_encoding, scaling_control,
default_quality, default_min_quality,
default_speed, default_min_speed)
IdleMixin.__init__(self, idle_timeout)
InputMixin.__init__(self)
AVSyncMixin.__init__(self, av_sync)
ClientDisplayMixin.__init__(self)
WebcamMixin.__init__(self, webcam_enabled, webcam_device,
webcam_encodings)
self.ordinary_packets = []
self.disconnect = disconnect_cb
self.socket_dir = socket_dir
self.unix_socket_paths = unix_socket_paths
self.log_disconnect = log_disconnect
self.idle_add = idle_add
self.timeout_add = timeout_add
self.source_remove = source_remove
self.setting_changed = setting_changed
# network constraints:
self.server_bandwidth_limit = bandwidth_limit
#these statistics are shared by all WindowSource instances:
self.statistics = GlobalPerformanceStatistics()
self.init()
# ready for processing:
protocol.set_packet_source(self.next_packet)
def test_avsync(self):
from xpra.server.source.avsync_mixin import AVSyncMixin
#test disabled:
#what the client sets doesn't matter:
for e in (True, False):
av = AVSyncMixin(False)
av.window_sources = {}
av.init_state()
caps = typedict({"av-sync": e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and not avi.get("enabled", True)
#now enabled:
def get_sound_source_latency():
return 20
for e in (True, False):
av = AVSyncMixin(True)
av.window_sources = {}
av.init_state()
av.get_sound_source_latency = get_sound_source_latency
caps = typedict({"av-sync": e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and avi.get("enabled", not e) == e
def test_avsync(self):
from xpra.server.source.avsync_mixin import AVSyncMixin
self._test_mixin_class(AVSyncMixin)
#test disabled:
#what the client sets doesn't matter:
for e in (True, False):
av = AVSyncMixin()
av.av_sync = False
av.window_sources = {}
av.init_state()
caps = typedict({"av-sync": e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and not avi.get("enabled", True)
#now enabled:
def get_sound_source_latency():
return 20
for e in (True, False):
av = AVSyncMixin()
av.av_sync = True
av.window_sources = {}
av.init_state()
av.get_sound_source_latency = get_sound_source_latency
caps = typedict({"av-sync": e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and avi.get("enabled", not e) == e
av.set_av_sync_delay(10)
av.sound_control_av_sync_delta("100")
try:
av.sound_control_av_sync_delta("invalid")
except Exception:
pass
assert av.get_info().get("av-sync").get("delta") == 100
def test_avsync(self):
#needs both mixins:
from xpra.server.source.windows_mixin import WindowsMixin
from xpra.server.source.audio_mixin import AudioMixin
from xpra.server.source.avsync_mixin import AVSyncMixin
server_props = SourceMixinsTest.AUDIO_SERVER_PROPS.copy()
server_props.update({
"av_sync" : True,
"sound_properties" : {"foo" : "bar"},
"sound.pulseaudio_id" : "fake-one",
"sound.pulseaudio.server" : "some-path",
})
server_props.update(self._get_window_mixin_server_attributes())
self._test_mixin_classes((WindowsMixin, AudioMixin, AVSyncMixin), server_props, {
"sound.send" : True,
"sound.receive" : True,
})
#test disabled:
#what the client sets doesn't matter:
for e in (True, False):
av = AVSyncMixin()
av.av_sync = False
av.window_sources = {}
av.init_state()
caps = typedict({"av-sync" : e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and not avi.get("enabled", True)
#now enabled:
def get_sound_source_latency():
return 20
for e in (True, False):
av = AVSyncMixin()
av.av_sync = True
av.window_sources = {}
av.init_state()
av.get_sound_source_latency = get_sound_source_latency
caps = typedict({"av-sync" : e})
av.parse_client_caps(caps)
i = av.get_info()
assert i
avi = i.get("av-sync")
assert avi and avi.get("enabled", not e)==e
av.set_av_sync_delay(10)
av.sound_control_av_sync_delta("100")
try:
av.sound_control_av_sync_delta("invalid")
except Exception:
pass
assert av.get_info().get("av-sync").get("delta")==100