version[3]))
print('')
#test GetSupportedProperties()
supported_properties = enhanced_position_interface.GetSupportedProperties()
print('GetSupportedProperties()')
for key in supported_properties:
print('{0}:'.format(key))
for item in supported_properties[key]:
print(' {0}'.format(item))
print('')
#test GetProperties()
properties = enhanced_position_interface.GetProperties()
print('GetProperties()')
print('UpdateInterval: {0}'.format(properties.get('UpdateInterval', 'N/A')))
print('SatelliteSystem: {0}'.format(properties['SatelliteSystem']))
print('')
#test SetProperty()
enhanced_position_interface.SetProperty(
dbus.String('SatelliteSystem'),
dbus.UInt32(SATELLITE_SYSTEM, variant_level=1))
enhanced_position_interface.SetProperty(
'UpdateInterval', dbus.Int32(UPDATE_INTERVAL, variant_level=1))
#main loop
gobject.timeout_add(3000, timeout)
loop = gobject.MainLoop()
loop.run()
def set_scan_interval(self, value):
return self.__set_property("ScanInterval", dbus.Int32(value))
def saveDriverSettings(self, resetIfNeeded):
global gJackctl, gResetNeeded
if resetIfNeeded and not gResetNeeded:
resetIfNeeded = False
if self.ui.obj_driver_device.isEnabled():
value = dbus.String(
self.ui.obj_driver_device.currentText().split(" [")[0])
if value != gJackctl.GetParameterValue(["driver", "device"])[2]:
gJackctl.SetParameterValue(["driver", "device"], value)
elif resetIfNeeded:
gJackctl.ResetParameterValue(["driver", "device"])
if self.ui.obj_driver_capture.isEnabled():
if self.fDriverName == "alsa":
value = dbus.String(
self.ui.obj_driver_capture.currentText().split(" ")[0])
elif self.fDriverName == "dummy":
value = dbus.UInt32(
int(self.ui.obj_driver_capture.currentText()))
elif self.fDriverName == "firewire":
value = dbus.Boolean(
self.ui.obj_driver_capture.currentIndex() == 1)
else:
value = None
print(
"JackSettingsW::saveDriverSettings() - Cannot save capture value"
)
if value != None:
setDriverParameter("capture", value, True)
elif resetIfNeeded:
gJackctl.ResetParameterValue(["driver", "capture"])
if self.ui.obj_driver_playback.isEnabled():
if self.fDriverName == "alsa":
value = dbus.String(
self.ui.obj_driver_playback.currentText().split(" ")[0])
elif self.fDriverName == "dummy":
value = dbus.UInt32(
int(self.ui.obj_driver_playback.currentText()))
elif self.fDriverName == "firewire":
value = dbus.Boolean(
self.ui.obj_driver_playback.currentIndex() == 1)
else:
value = None
print(
"JackSettingsW::saveDriverSettings() - Cannot save playback value"
)
if value != None:
setDriverParameter("playback", value, True)
elif resetIfNeeded:
gJackctl.ResetParameterValue(["driver", "playback"])
if self.ui.obj_driver_rate.isEnabled():
value = dbus.UInt32(int(self.ui.obj_driver_rate.currentText()))
setDriverParameter("rate", value, True)
if self.ui.obj_driver_period.isEnabled():
value = dbus.UInt32(int(self.ui.obj_driver_period.currentText()))
setDriverParameter("period", value, True)
if self.ui.obj_driver_nperiods.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_nperiods.value())
setDriverParameter("nperiods", value, True)
if self.ui.obj_driver_hwmon.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_hwmon.isChecked())
setDriverParameter("hwmon", value, True)
if self.ui.obj_driver_hwmeter.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_hwmeter.isChecked())
setDriverParameter("hwmeter", value, True)
if self.ui.obj_driver_duplex.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_duplex.isChecked())
setDriverParameter("duplex", value, True)
if self.ui.obj_driver_hw_alias.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_hw_alias.isChecked())
setDriverParameter("hw-alias", value, True)
if self.ui.obj_driver_softmode.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_softmode.isChecked())
setDriverParameter("softmode", value, True)
if self.ui.obj_driver_monitor.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_monitor.isChecked())
setDriverParameter("monitor", value, True)
if self.ui.obj_driver_dither.isEnabled():
if self.ui.obj_driver_dither.currentIndex() == 0:
value = dbus.Byte("n".encode("utf-8"))
elif self.ui.obj_driver_dither.currentIndex() == 1:
value = dbus.Byte("r".encode("utf-8"))
elif self.ui.obj_driver_dither.currentIndex() == 2:
value = dbus.Byte("s".encode("utf-8"))
elif self.ui.obj_driver_dither.currentIndex() == 3:
value = dbus.Byte("t".encode("utf-8"))
else:
value = None
print(
"JackSettingsW::saveDriverSettings() - Cannot save dither value"
)
if value != None:
setDriverParameter("dither", value, True)
if self.ui.obj_driver_inchannels.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_inchannels.value())
setDriverParameter("inchannels", value, True)
if self.ui.obj_driver_outchannels.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_outchannels.value())
setDriverParameter("outchannels", value, True)
if self.ui.obj_driver_shorts.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_shorts.isChecked())
setDriverParameter("shorts", value, True)
if self.ui.obj_driver_input_latency.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_input_latency.value())
setDriverParameter("input-latency", value, True)
if self.ui.obj_driver_output_latency.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_output_latency.value())
setDriverParameter("output-latency", value, True)
if self.ui.obj_driver_midi_driver.isEnabled():
if self.ui.obj_driver_midi_driver.currentIndex() == 0:
value = dbus.String("none")
elif self.ui.obj_driver_midi_driver.currentIndex() == 1:
value = dbus.String("seq")
elif self.ui.obj_driver_midi_driver.currentIndex() == 2:
value = dbus.String("raw")
else:
value = None
print(
"JackSettingsW::saveDriverSettings() - Cannot save midi-driver value"
)
if value != None:
if driverHasFeature("midi"):
setDriverParameter("midi", value, True)
else:
setDriverParameter("midi-driver", value, True)
if self.ui.obj_driver_wait.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_wait.value())
setDriverParameter("wait", value, True)
if self.ui.obj_driver_verbose.isEnabled():
value = dbus.UInt32(self.ui.obj_driver_verbose.value())
setDriverParameter("verbose", value, True)
if self.ui.obj_driver_snoop.isEnabled():
value = dbus.Boolean(self.ui.obj_driver_snoop.isChecked())
setDriverParameter("snoop", value, True)
if self.ui.obj_driver_channels.isEnabled():
value = dbus.Int32(self.ui.obj_driver_channels.value())
setDriverParameter("channels", value, True)
def _trans(self, s, pack):
if pack:
return dbus.Struct((dbus.Double(s[0]), dbus.Int32(s[1])),
signature="di")
else:
return (float(s[0]), int(s[1]))
import dbus
from servicetest import call_async, EventPattern, sync_dbus, assertEquals
from gabbletest import acknowledge_iq, sync_stream, make_result_iq
import constants as cs
import ns
import tubetestutil as t
from twisted.words.xish import domish, xpath
sample_parameters = dbus.Dictionary(
{
's': 'hello',
'ay': dbus.ByteArray(b'hello'),
'u': dbus.UInt32(123),
'i': dbus.Int32(-123),
},
signature='sv')
new_sample_parameters = dbus.Dictionary(
{
's': 'newhello',
'ay': dbus.ByteArray(b'newhello'),
'u': dbus.UInt32(123),
'i': dbus.Int32(-123),
},
signature='sv')
def contact_offer_dbus_tube(bytestream, tube_id):
iq, si = bytestream.create_si_offer(ns.TUBES)
def test_dbus_unwrap_int32(self):
dbus_value = dbus.Int32(3323213, variant_level=1)
value = dbus_mqtt.unwrap_dbus_value(dbus_value)
self.assertIsInstance(value, int)
self.assertEqual(int(dbus_value), value)
# -*- coding: utf-8 -*-
import sys
import dbus
name = "org.genivi.SotaClient"
bus = dbus.SessionBus()
obj = bus.get_object(name, "/org/genivi/SotaClient")
sota = dbus.Interface(obj, name)
#Wremote_method = obj.get_dbus_method("initiateDownload", name)
reports = {'id': dbus.String("123", variant_level=1),
'result_code': dbus.Int32(0, variant_level=1),
'result_text': dbus.String("Good", variant_level=1)}
if sys.argv[1] == "initiateDownload":
sota.initiateDownload(dbus.String("testupdateid"))
elif sys.argv[1] == "abortDownload":
sota.abortDownload(dbus.String("testupdateid"))
elif sys.argv[1] == "updateReport":
sota.updateReport(dbus.String("testupdateid"), [reports])
def volumeUp(self):
self.tryToSendAction(dbus.Int32("18"))
def volumeDown(self):
self.tryToSendAction(dbus.Int32("17"))
def test_properties(self):
'''add and change properties'''
# no properties by default
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'),
{})
# no such property
with self.assertRaises(dbus.exceptions.DBusException) as ctx:
self.dbus_props.Get('org.freedesktop.Test.Main', 'version')
self.assertEqual(ctx.exception.get_dbus_name(),
'org.freedesktop.Test.Main.UnknownProperty')
self.assertEqual(ctx.exception.get_dbus_message(),
'no such property version')
self.assertRaises(dbus.exceptions.DBusException, self.dbus_props.Set,
'org.freedesktop.Test.Main', 'version',
dbus.Int32(2, variant_level=1))
self.dbus_mock.AddProperty('org.freedesktop.Test.Main', 'version',
dbus.Int32(2, variant_level=1))
# once again on default interface
self.dbus_mock.AddProperty('', 'connected',
dbus.Boolean(True, variant_level=1))
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'version'), 2)
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'connected'),
True)
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'), {
'version': 2,
'connected': True
})
with self.assertRaises(dbus.exceptions.DBusException) as ctx:
self.dbus_props.GetAll('org.freedesktop.Test.Bogus')
self.assertEqual(ctx.exception.get_dbus_name(),
'org.freedesktop.Test.Main.UnknownInterface')
self.assertEqual(ctx.exception.get_dbus_message(),
'no such interface org.freedesktop.Test.Bogus')
# change property
self.dbus_props.Set('org.freedesktop.Test.Main', 'version',
dbus.Int32(4, variant_level=1))
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'version'), 4)
# check that the Get/Set calls get logged
with open(self.mock_log.name) as f:
contents = f.read()
self.assertRegex(
contents, '\n[0-9.]+ Get org.freedesktop.Test.Main.version\n')
self.assertRegex(
contents,
'\n[0-9.]+ Get org.freedesktop.Test.Main.connected\n')
self.assertRegex(contents,
'\n[0-9.]+ GetAll org.freedesktop.Test.Main\n')
self.assertRegex(
contents,
'\n[0-9.]+ Set org.freedesktop.Test.Main.version 4\n')
# add property to different interface
self.dbus_mock.AddProperty('org.freedesktop.Test.Other', 'color',
dbus.String('yellow', variant_level=1))
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'), {
'version': 4,
'connected': True
})
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Other'),
{'color': 'yellow'})
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Other', 'color'),
'yellow')
def togglePause(self):
self.tryToSendAction(dbus.Int32("16"))
def route_calculation_signals_handler(routeHandle, status, percentage):
print 'Route Calculation: ' + str(int(percentage)) + ' %'
if int(percentage) == 100:
#get route overview
overview = g_routing_interface.getRouteOverview(
dbus.UInt32(g_route_handle),
dbus.Array([
dbus.Int32(GENIVI_NAVIGATIONCORE_TOTAL_DISTANCE),
dbus.Int32(GENIVI_NAVIGATIONCORE_TOTAL_TIME)
]))
#retrieve distance
totalDistance = dbus.Struct(
overview[dbus.Int32(GENIVI_NAVIGATIONCORE_TOTAL_DISTANCE)])
print 'Total Distance: ' + str(totalDistance[1] / 1000) + ' km'
totalTime = dbus.Struct(
overview[dbus.Int32(GENIVI_NAVIGATIONCORE_TOTAL_TIME)])
m, s = divmod(totalTime[1], 60)
h, m = divmod(m, 60)
print "Total Time: %d:%02d:%02d" % (h, m, s)
#get route segments GetRouteSegments(const uint32_t& routeHandle, const int16_t& detailLevel, const std::vector< DBusCommonAPIEnumeration >& valuesToReturn, const uint32_t& numberOfSegments, const uint32_t& offset, uint32_t& totalNumberOfSegments, std::vector< std::map< DBusCommonAPIEnumeration, DBusCommonAPIVariant > >& routeSegments)
valuesToReturn = [
dbus.Int32(GENIVI_NAVIGATIONCORE_ROAD_NAME),
dbus.Int32(GENIVI_NAVIGATIONCORE_START_LATITUDE),
dbus.Int32(GENIVI_NAVIGATIONCORE_END_LATITUDE),
dbus.Int32(GENIVI_NAVIGATIONCORE_START_LONGITUDE),
dbus.Int32(GENIVI_NAVIGATIONCORE_END_LONGITUDE),
dbus.Int32(GENIVI_NAVIGATIONCORE_DISTANCE),
dbus.Int32(GENIVI_NAVIGATIONCORE_TIME),
dbus.Int32(GENIVI_NAVIGATIONCORE_SPEED)
]
ret = g_routing_interface.getRouteSegments(dbus.UInt32(g_route_handle),
dbus.Int16(0),
dbus.Array(valuesToReturn),
dbus.UInt32(500),
dbus.UInt32(0))
print "Total number of segments: " + str(ret[0])
#len(ret[1]) is size
#ret[1][0][GENIVI_NAVIGATIONCORE_START_LATITUDE] is the start latitude
# pdb.set_trace()
route = g_current_route + 1
if route < routes.length:
launch_route_calculation(route)
else:
for i in range(routes.length):
g_routing_interface.deleteRoute(
dbus.UInt32(g_session_handle),
dbus.UInt32(routes[i].getElementsByTagName("handle")
[0].childNodes[0].data))
g_session_interface.deleteSession(dbus.UInt32(g_session_handle))
def test_domain_vcpus(self):
obj, domain = self.get_test_domain()
vcpus_expected = 2
domain.SetVcpus(vcpus_expected, 0)
assert domain.GetVcpus(0) == dbus.Int32(vcpus_expected)
def AddUser(self,
uid,
username,
password=DEFAULT_USER_PASSWORD,
overrides=None,
password_policy_overrides=None):
'''Add user via uid and username and optionally overriding properties
Returns the new object path.
'''
path = get_user_path(uid)
default_props = {
'Uid': dbus.UInt64(uid),
'UserName': username,
'RealName': username[0].upper() + username[1:] + ' Fake',
'AccountType': dbus.Int32(1),
'AutomaticLogin': False,
'BackgroundFile': '',
'Email': '{}@python-dbusmock.org'.format(username),
'FormatsLocale': 'C',
'HomeDirectory': '/nonexisting/mock-home/{}'.format(username),
'IconFile': '',
'InputSources': dbus.Array([], signature='a{ss}'),
'Language': 'C',
'LocalAccount': True,
'Location': '',
'Locked': False,
'LoginFrequency': dbus.UInt64(0),
'LoginHistory': dbus.Array([], signature='(xxa{sv})'),
'LoginTime': dbus.Int64(0),
'PasswordHint': 'Remember it, come on!',
'PasswordMode': 0,
'Session': 'mock-session',
'SessionType': 'wayland',
'Shell': '/usr/bin/zsh',
'SystemAccount': False,
'XHasMessages': False,
'XKeyboardLayouts': dbus.Array([], signature='s'),
'XSession': 'mock-xsession',
}
default_props.update(overrides if overrides else {})
self.AddObject(path, USER_IFACE, default_props, [])
had_users = len(self.mock_users) != 0
had_multiple_users = len(self.mock_users) > 1
user = mockobject.objects[path]
user.password = password
user.properties = default_props
user.pwd_expiration_policy = {
'expiration_time': sys.maxsize,
'last_change_time': int(time.time()),
'min_days_between_changes': 0,
'max_days_between_changes': 0,
'days_to_warn': 0,
'days_after_expiration_until_lock': 0,
}
user.pwd_expiration_policy.update(
password_policy_overrides if password_policy_overrides else {})
self.mock_users[uid] = default_props
self.EmitSignal(MAIN_IFACE, 'UserAdded', 'o', [path])
if not had_users:
emit_properties_changed(self, MAIN_IFACE, 'HasNoUsers')
elif not had_multiple_users and len(self.mock_users) > 1:
emit_properties_changed(self, MAIN_IFACE, 'HasMultipleUsers')
return path
def test_dbus_wrap_int(self):
value = 1121
dbus_value = dbus_mqtt.wrap_dbus_value(value)
self.assertIsInstance(dbus_value, dbus.Int32)
self.assertEqual(dbus.Int32(value, variant_level=1), dbus_value)
def seekBackSmall(self):
self.tryToSendAction(dbus.Int32("19"))
def test_dbus_wrap_array(self):
value = [1]
dbus_value = dbus_mqtt.wrap_dbus_value(value)
self.assertIsInstance(dbus_value, dbus.Array)
self.assertEqual(dbus.Array([dbus.Int32(1, variant_level=1)]),
dbus_value)
def seekForwardSmall(self):
self.tryToSendAction(dbus.Int32("20"))
def to_mpris2(self):
"""
Converts the metadata to mpris2 dict
>>> mt = Metadata(title='Title', artist='Artist1, Artist2,Artist3',
... album='Album', arturl='file:///art/url',
... location='file:///path/to/file', length=123,
... tracknum=456,
... extra={ 'title': 'Fake Title',
... 'xesam:album': 'Fake Album',
... 'xesam:useCount': 780,
... 'xesam:userRating': 1.0,
... 'custom value': 'yoooooo',
... })
>>> dict = mt.to_mpris2()
>>> print(dict['xesam:title'])
Title
>>> print(dict['xesam:artist'])
[dbus.String('Artist1'), dbus.String('Artist2'), dbus.String('Artist3')]
>>> print(dict['xesam:url'])
file:///path/to/file
>>> print(dict['mpris:artUrl'])
file:///art/url
>>> print(dict['mpris:length'])
123
>>> print(dict['xesam:trackNumber'])
456
>>> print(dict['xesam:userRating'])
1.0
>>> 'custom value' in dict
False
>>> mt2 = Metadata.from_dict(dict)
>>> print(mt2.title)
Title
>>> print(mt2.artist)
Artist1, Artist2, Artist3
>>> print(mt2.album)
Album
>>> print(mt2.location)
file:///path/to/file
"""
ret = dbus.Dictionary(signature='sv')
mpris2map = {
'title': 'xesam:title',
'album': 'xesam:album',
'arturl': 'mpris:artUrl',
'location': 'xesam:url',
}
for k in ['title', 'album', 'arturl', 'location']:
if getattr(self, k) is not None:
ret[mpris2map[k]] = dbus.String(getattr(self, k))
if self.artist is not None:
ret['xesam:artist'] = [
dbus.String(v.strip()) for v in self.artist.split(',')
]
if self.length >= 0:
ret['mpris:length'] = dbus.Int64(self.length)
if self.tracknum >= 0:
ret['xesam:trackNumber'] = dbus.Int32(self.tracknum)
for k, v in self._extra.items():
if k in self.MPRIS2_KEYS and k not in ret:
ret[k] = v
return ret
def seekBackLarge(self):
self.tryToSendAction(dbus.Int32("21"))
}
if self.current_metadata['title'] != '':
metadata['xesam:title'] = dbus.String (
self.current_metadata['title'], variant_level = 1)
if self.current_metadata['artist'] != '':
metadata['xesam:artist'] = dbus.Array (
[ self.current_metadata['artist'] ], variant_level = 1)
if self.current_metadata['album'] != '':
metadata['xesam:album'] = dbus.String (
self.current_metadata['album'], variant_level = 1)
if self.current_metadata['tracknumber'] != '':
metadata['xesam:trackNumber'] = dbus.Int32 (
self.current_metadata['tracknumber'], variant_level = 1)
return metadata
def __do_update_metadata (self, totem, artist, # pylint: disable-msg=R0913
title, album, num):
self.current_metadata = self.null_metadata.copy ()
if title:
self.current_metadata['title'] = title
if artist:
self.current_metadata['artist'] = artist
if album:
self.current_metadata['album'] = album
if num:
self.current_metadata['tracknumber'] = num
def seekForwardLarge(self):
self.tryToSendAction(dbus.Int32("22"))
def test_properties(self):
'''add and change properties'''
# no properties by default
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'),
{})
# no such property
with self.assertRaises(dbus.exceptions.DBusException) as ctx:
self.dbus_props.Get('org.freedesktop.Test.Main', 'version')
self.assertEqual(ctx.exception.get_dbus_name(),
'org.freedesktop.Test.Main.UnknownProperty')
self.assertEqual(ctx.exception.get_dbus_message(),
'no such property version')
self.assertRaises(dbus.exceptions.DBusException, self.dbus_props.Set,
'org.freedesktop.Test.Main', 'version',
dbus.Int32(2, variant_level=1))
self.dbus_mock.AddProperty('org.freedesktop.Test.Main', 'version',
dbus.Int32(2, variant_level=1))
# once again on default interface
self.dbus_mock.AddProperty('', 'connected',
dbus.Boolean(True, variant_level=1))
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'version'), 2)
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'connected'),
True)
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'), {
'version': 2,
'connected': True
})
with self.assertRaises(dbus.exceptions.DBusException) as ctx:
self.dbus_props.GetAll('org.freedesktop.Test.Bogus')
self.assertEqual(ctx.exception.get_dbus_name(),
'org.freedesktop.Test.Main.UnknownInterface')
self.assertEqual(ctx.exception.get_dbus_message(),
'no such interface org.freedesktop.Test.Bogus')
# change property
self.dbus_props.Set('org.freedesktop.Test.Main', 'version',
dbus.Int32(4, variant_level=1))
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'version'), 4)
# check that the Get/Set calls get logged
with open(self.mock_log.name, encoding="UTF-8") as f:
contents = f.read()
self.assertRegex(
contents,
'\n[0-9.]+ Get / org.freedesktop.Test.Main.version\n')
self.assertRegex(
contents,
'\n[0-9.]+ Get / org.freedesktop.Test.Main.connected\n')
self.assertRegex(contents,
'\n[0-9.]+ GetAll / org.freedesktop.Test.Main\n')
self.assertRegex(
contents,
'\n[0-9.]+ Set / org.freedesktop.Test.Main.version 4\n')
# add property to different interface
self.dbus_mock.AddProperty('org.freedesktop.Test.Other', 'color',
dbus.String('yellow', variant_level=1))
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'), {
'version': 4,
'connected': True
})
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Other'),
{'color': 'yellow'})
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Other', 'color'),
'yellow')
changed_props = []
ml = GLib.MainLoop()
def catch(*args, **kwargs):
if kwargs['interface'] != 'org.freedesktop.DBus.Properties':
return
self.assertEqual(kwargs['interface'],
'org.freedesktop.DBus.Properties')
self.assertEqual(kwargs['member'], 'PropertiesChanged')
[iface, changed, _invalidated] = args
self.assertEqual(iface, 'org.freedesktop.Test.Main')
changed_props.append(changed)
ml.quit()
match = self.dbus_con.add_signal_receiver(
catch,
interface_keyword='interface',
path_keyword='path',
member_keyword='member')
# change property using mock helper
self.dbus_mock.UpdateProperties('org.freedesktop.Test.Main', {
'version': 5,
'connected': False,
})
GLib.timeout_add(3000, ml.quit)
ml.run()
match.remove()
self.assertEqual(self.dbus_props.GetAll('org.freedesktop.Test.Main'), {
'version': 5,
'connected': False
})
self.assertEqual(changed_props, [{'version': 5, 'connected': False}])
# test adding properties with the array type
self.dbus_mock.AddProperty('org.freedesktop.Test.Main', 'array',
dbus.Array(['first'], signature='s'))
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'array'),
['first'])
# test updating properties with the array type
self.dbus_mock.UpdateProperties(
'org.freedesktop.Test.Main',
{'array': dbus.Array(['second', 'third'], signature='s')})
self.assertEqual(
self.dbus_props.Get('org.freedesktop.Test.Main', 'array'),
['second', 'third'])
def prevAudioTrack(self):
self.tryToSendAction(dbus.Int32("6"))
tests = [123, dbus.Dictionary({'foo': 'bar'}, signature='sv')]
for t in tests:
try:
netw_obj.set(t, dbus_interface=WPAS_DBUS_OLD_NETWORK)
raise Exception("Invalid set() accepted: " + str(t))
except dbus.exceptions.DBusException, e:
if "InvalidOptions" not in str(e):
raise Exception("Unexpected error message for invalid set: " +
str(e))
params = dbus.Dictionary(
{
'ssid': ssid,
'key_mgmt': 'WPA-PSK',
'psk': passphrase,
'identity': dbus.ByteArray([1, 2]),
'priority': dbus.Int32(0),
'scan_freq': dbus.UInt32(2412)
},
signature='sv')
netw_obj.set(params, dbus_interface=WPAS_DBUS_OLD_NETWORK)
if_obj.removeNetwork(npath, dbus_interface=WPAS_DBUS_OLD_IFACE)
class TestDbusConnect(TestDbus):
def __init__(self, bus):
TestDbus.__init__(self, bus)
self.state = 0
def __enter__(self):
gobject.timeout_add(1, self.run_connect)
gobject.timeout_add(15000, self.timeout)
self.add_signal(self.scanDone, WPAS_DBUS_OLD_IFACE,
def nextAudioTrack(self):
self.tryToSendAction(dbus.Int32("7"))
def saveServerSettings(self):
# always reset server name
if engineHasFeature("name"):
setEngineParameter("name", "default", True)
if self.ui.obj_server_realtime.isEnabled():
value = dbus.Boolean(self.ui.obj_server_realtime.isChecked())
setEngineParameter("realtime", value, True)
if self.ui.obj_server_realtime_priority.isEnabled():
value = dbus.Int32(self.ui.obj_server_realtime_priority.value())
setEngineParameter("realtime-priority", value, True)
if self.ui.obj_server_temporary.isEnabled():
value = dbus.Boolean(self.ui.obj_server_temporary.isChecked())
setEngineParameter("temporary", value, True)
if self.ui.obj_server_verbose.isEnabled():
value = dbus.Boolean(self.ui.obj_server_verbose.isChecked())
setEngineParameter("verbose", value, True)
if self.ui.obj_server_alias.isEnabled():
value = dbus.Boolean(self.ui.obj_server_alias.isChecked())
setEngineParameter("alias", value, True)
if self.ui.obj_server_client_timeout.isEnabled():
value = dbus.Int32(
int(self.ui.obj_server_client_timeout.currentText()))
setEngineParameter("client-timeout", value, True)
if self.ui.obj_server_clock_source.isEnabled():
if self.ui.obj_server_clock_source_system.isChecked():
if self.fBrokenServerClockSource:
value = dbus.UInt32(JACK_TIMER_SYSTEM_CLOCK)
else:
value = dbus.Byte("s".encode("utf-8"))
elif self.ui.obj_server_clock_source_cycle.isChecked():
if self.fBrokenServerClockSource:
value = dbus.UInt32(JACK_TIMER_CYCLE_COUNTER)
else:
value = dbus.Byte("c".encode("utf-8"))
elif self.ui.obj_server_clock_source_hpet.isChecked():
if self.fBrokenServerClockSource:
value = dbus.UInt32(JACK_TIMER_HPET)
else:
value = dbus.Byte("h".encode("utf-8"))
else:
value = None
print(
"JackSettingsW::saveServerSettings() - Cannot save clock-source value"
)
if value != None:
setEngineParameter("clock-source", value, True)
if self.ui.obj_server_port_max.isEnabled():
value = dbus.UInt32(int(self.ui.obj_server_port_max.currentText()))
setEngineParameter("port-max", value, True)
if self.ui.obj_server_replace_registry.isEnabled():
value = dbus.Boolean(
self.ui.obj_server_replace_registry.isChecked())
setEngineParameter("replace-registry", value, True)
if self.ui.obj_server_sync.isEnabled():
value = dbus.Boolean(self.ui.obj_server_sync.isChecked())
setEngineParameter("sync", value, True)
if self.ui.obj_server_self_connect_mode.isEnabled():
if self.ui.obj_server_self_connect_mode_0.isChecked():
value = dbus.Byte(" ".encode("utf-8"))
elif self.ui.obj_server_self_connect_mode_1.isChecked():
value = dbus.Byte("E".encode("utf-8"))
elif self.ui.obj_server_self_connect_mode_2.isChecked():
value = dbus.Byte("e".encode("utf-8"))
elif self.ui.obj_server_self_connect_mode_3.isChecked():
value = dbus.Byte("A".encode("utf-8"))
elif self.ui.obj_server_self_connect_mode_4.isChecked():
value = dbus.Byte("a".encode("utf-8"))
else:
value = None
print(
"JackSettingsW::saveServerSettings() - Cannot save self-connect-mode value"
)
if value != None:
setEngineParameter("self-connect-mode", value, True)
# type mapping
# in most cases it is a utf-8 string
DBUS_STRING = dbus.String
# general type (for use in dicts, where all values should have the same type)
DBUS_BOOLEAN = dbus.Boolean
DBUS_DOUBLE = dbus.Double
DBUS_INT32 = dbus.Int32
# dictionary with string key and binary value
DBUS_DICT_SV = lambda : dbus.Dictionary({}, signature="sv")
# dictionary with string key and value
DBUS_DICT_SS = lambda : dbus.Dictionary({}, signature="ss")
# empty type (there is no equivalent of None on D-Bus, but historically gajim
# used 0 instead)
DBUS_NONE = lambda : dbus.Int32(0)
def get_dbus_struct(obj):
"""
Recursively go through all the items and replace them with their casted dbus
equivalents
"""
if obj is None:
return DBUS_NONE()
if isinstance(obj, str):
return DBUS_STRING(obj)
if isinstance(obj, int):
return DBUS_INT32(obj)
if isinstance(obj, float):
return DBUS_DOUBLE(obj)
if isinstance(obj, bool):
def MultipleReturnWithoutSignature(self):
# https://bugs.freedesktop.org/show_bug.cgi?id=10174
return dbus.String('abc'), dbus.Int32(123)
def setConf(self, srvid, key, value):
if key == "username":
key = "playername"
self.meta.setConf(dbus.Int32(srvid), key, value)
