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)